@galacean/effects 1.3.1 → 1.4.0-beta.0

package/dist/index.js

@@ -3,7 +3,7 @@
  * Description: Galacean Effects runtime player for the web
  * Author: Ant Group CO., Ltd.
  * Contributors: 燃然,飂兮,十弦,云垣,茂安,意绮
- * Version: v1.3.1
+ * Version: v1.4.0-beta.0
  */
 
 'use strict';
@@ -686,7 +686,7 @@ function asserts(condition, msg) {
  * Name: @galacean/effects-specification
  * Description: Galacean Effects JSON Specification
  * Author: Ant Group CO., Ltd.
- * Version: v1.1.0
+ * Version: v1.2.0-beta.0
  */
 
 /*********************************************/
@@ -7303,6 +7303,448 @@ function trianglesFromRect(position, halfWidth, halfHeight) {
         { p0: p0.clone(), p1: p2.clone(), p2: p3 },
     ];
 }
+function decimalEqual(a, b, epsilon) {
+    if (epsilon === void 0) { epsilon = 0.000001; }
+    return Math.abs(a - b) < epsilon;
+}
+function numberToFix(a, fixed) {
+    if (fixed === void 0) { fixed = 2; }
+    var base = Math.pow(10, fixed);
+    return Math.floor(a * base) / base;
+}
+function pointOnLine(x1, y1, x2, y2, x3, y3) {
+    var det1 = (x1 * y2) + (y1 * x3) + (x2 * y3) - (x3 * y2) - (y3 * x1) - (x2 * y1);
+    return det1 > -0.001 && det1 < 0.001;
+}
+
+var keyframeInfo = {
+    /**
+     * 根据不同关键帧类型，获取位于曲线上的点
+     */
+    getPointInCurve: function (keyframe) {
+        var _a = __read$3(keyframe, 2); _a[0]; var data = _a[1];
+        var _b = this.getPointIndexInCurve(keyframe), xIndex = _b.xIndex, yIndex = _b.yIndex;
+        var time = data[xIndex];
+        var value = data[yIndex];
+        return new Vector2(time, value);
+    },
+    /**
+     * 根据不同关键帧类型，获取位于曲线上的点的索引
+     */
+    getPointIndexInCurve: function (keyframe) {
+        var _a = __read$3(keyframe, 3), type = _a[0], markType = _a[2];
+        // 不同类型，存放的时间不同
+        var index = type === BezierKeyframeType$1.LINE ? 0
+            : type === BezierKeyframeType$1.EASE_OUT ? 0
+                : type === BezierKeyframeType$1.EASE_IN ? 2
+                    : type === BezierKeyframeType$1.EASE ? 2
+                        : type === BezierKeyframeType$1.HOLD ? (markType === BezierKeyframeType$1.EASE_IN ? 2 : 0)
+                            : 0;
+        return { xIndex: index, yIndex: index + 1 };
+    },
+    /**
+     * 关键帧左侧是否为缓动类型（否则为线段）
+     */
+    isLeftSideEase: function (keyframe) {
+        var _a = __read$3(keyframe, 3), keyframeType = _a[0]; _a[1]; var markType = _a[2];
+        // 定格关键帧的左侧类型，需要借助markType判断
+        if (keyframeType === BezierKeyframeType$1.HOLD && this.isKeyframeTypeLeftSideEase(markType)) {
+            return true;
+        }
+        return this.isKeyframeTypeLeftSideEase(keyframeType);
+    },
+    /**
+     * 关键帧右侧是否为缓动类型（否则为线段）
+     */
+    isRightSideEase: function (keyframe) {
+        var _a = __read$3(keyframe, 3), keyframeType = _a[0]; _a[1]; var markType = _a[2];
+        // 定格关键帧的右侧类型，需要借助markType判断
+        if (keyframeType === BezierKeyframeType$1.HOLD && this.isKeyframeTypeRightSideEase(markType)) {
+            return true;
+        }
+        return this.isKeyframeTypeRightSideEase(keyframeType);
+    },
+    /**
+     * 关键帧左侧是否为缓动类型（否则为线段）
+     */
+    isKeyframeTypeLeftSideEase: function (keyframeType) {
+        return [BezierKeyframeType$1.EASE, BezierKeyframeType$1.EASE_IN, BezierKeyframeType$1.AUTO].includes(keyframeType);
+    },
+    /**
+     * 关键帧右侧是否为缓动类型（否则为线段）
+     */
+    isKeyframeTypeRightSideEase: function (keyframeType) {
+        return [BezierKeyframeType$1.EASE, BezierKeyframeType$1.EASE_OUT, BezierKeyframeType$1.AUTO].includes(keyframeType);
+    },
+    /**
+     * 是否为定格进关键帧
+     */
+    isHoldInKeyframe: function (keyframe) {
+        var _a = __read$3(keyframe, 3), keyframeType = _a[0]; _a[1]; var leftSubType = _a[2];
+        return keyframeType === BezierKeyframeType$1.HOLD && [BezierKeyframeType$1.HOLD, BezierKeyframeType$1.LINE_OUT, BezierKeyframeType$1.EASE_OUT].includes(leftSubType);
+    },
+    /**
+     * 是否为定格出关键帧
+     */
+    isHoldOutKeyframe: function (keyframe) {
+        var _a = __read$3(keyframe, 3), keyframeType = _a[0]; _a[1]; var leftSubType = _a[2];
+        return keyframeType === BezierKeyframeType$1.HOLD && [BezierKeyframeType$1.HOLD, BezierKeyframeType$1.LINE, BezierKeyframeType$1.EASE_IN].includes(leftSubType);
+    },
+};
+
+var BezierLengthData = /** @class */ (function () {
+    function BezierLengthData(points, totalLength) {
+        this.points = points;
+        this.totalLength = totalLength;
+    }
+    return BezierLengthData;
+}());
+var BezierMap = {};
+var BezierDataMap = {};
+var NEWTON_ITERATIONS = 4;
+var NEWTON_MIN_SLOPE = 0.001;
+var SUBDIVISION_PRECISION = 0.0000001;
+var SUBDIVISION_MAX_ITERATIONS = 10;
+var CURVE_SEGMENTS = 300;
+var kSplineTableSize = 11;
+var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
+function A(a1, a2) { return 1.0 - 3.0 * a2 + 3.0 * a1; }
+function B(a1, a2) { return 3.0 * a2 - 6.0 * a1; }
+function C(a1) { return 3.0 * a1; }
+// A * t ^ 3 + B * t ^ 2 + C * t
+// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
+function calcBezier(t, a1, a2) {
+    return ((A(a1, a2) * t + B(a1, a2)) * t + C(a1)) * t;
+}
+// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
+function getSlope(t, a1, a2) {
+    return 3.0 * A(a1, a2) * t * t + 2.0 * B(a1, a2) * t + C(a1);
+}
+function binarySubdivide(aX, aA, aB, mX1, mX2) {
+    var currentX, currentT, i = 0;
+    do {
+        currentT = aA + (aB - aA) / 2.0;
+        currentX = calcBezier(currentT, mX1, mX2) - aX;
+        if (currentX > 0.0) {
+            aB = currentT;
+        }
+        else {
+            aA = currentT;
+        }
+    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+    return currentT;
+}
+function newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {
+    for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
+        var currentSlope = getSlope(aGuessT, mX1, mX2);
+        if (currentSlope === 0.0) {
+            return aGuessT;
+        }
+        var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+        aGuessT -= currentX / currentSlope;
+    }
+    return aGuessT;
+}
+// de Casteljau算法构建曲线
+/**
+ * @param p1 起始点
+ * @param p2 终点
+ * @param p3 起始控制点
+ * @param p4 终止控制点
+ * @returns
+ */
+function buildBezierData(p1, p2, p3, p4) {
+    // 使用平移后的终点、控制点作为key
+    var s1 = numberToFix(p2.x - p1.x, 3) + '_' + numberToFix(p2.y - p1.y, 3) + '_' + numberToFix(p2.z - p1.z, 3);
+    var s2 = numberToFix(p3.x - p1.x, 3) + '_' + numberToFix(p3.y - p1.y, 3) + '_' + numberToFix(p3.z - p1.z, 3);
+    var s3 = numberToFix(p4.x - p1.x, 3) + '_' + numberToFix(p4.y - p1.y, 3) + '_' + numberToFix(p4.z - p1.z, 3);
+    var str = s1 + '&' + s2 + '&' + s3;
+    if (BezierDataMap[str]) {
+        return {
+            data: BezierDataMap[str],
+            interval: p1,
+        };
+    }
+    else {
+        var samples = [];
+        var lastPoint = null, addedLength = 0, ptDistance = 0;
+        var curveSegments = CURVE_SEGMENTS;
+        for (var k = 0; k < curveSegments; k += 1) {
+            var point = new Vector3();
+            var perc = k / (curveSegments - 1);
+            ptDistance = 0;
+            point.x = 3 * Math.pow(1 - perc, 2) * perc * (p3.x - p1.x) + 3 * (1 - perc) * Math.pow(perc, 2) * (p4.x - p1.x) + Math.pow(perc, 3) * (p2.x - p1.x);
+            point.y = 3 * Math.pow(1 - perc, 2) * perc * (p3.y - p1.y) + 3 * (1 - perc) * Math.pow(perc, 2) * (p4.y - p1.y) + Math.pow(perc, 3) * (p2.y - p1.y);
+            point.z = 3 * Math.pow(1 - perc, 2) * perc * (p3.z - p1.z) + 3 * (1 - perc) * Math.pow(perc, 2) * (p4.z - p1.z) + Math.pow(perc, 3) * (p2.z - p1.z);
+            if (lastPoint !== null) {
+                ptDistance += Math.pow(point.x - lastPoint.x, 2);
+                ptDistance += Math.pow(point.y - lastPoint.y, 2);
+                ptDistance += Math.pow(point.z - lastPoint.z, 2);
+            }
+            lastPoint = point;
+            ptDistance = Math.sqrt(ptDistance);
+            addedLength += ptDistance;
+            samples[k] = {
+                partialLength: ptDistance,
+                point: point,
+            };
+        }
+        var data = new BezierLengthData(samples, addedLength);
+        BezierDataMap[str] = data;
+        return {
+            data: data,
+            interval: new Vector3(p1.x, p1.y, p1.z),
+        };
+    }
+}
+var BezierPath = /** @class */ (function () {
+    function BezierPath(p1, p2, p3, p4) {
+        this.p1 = p1;
+        this.p2 = p2;
+        this.p3 = p3;
+        this.p4 = p4;
+        this.catching = {
+            lastPoint: 0,
+            lastAddedLength: 0,
+        };
+        var _a = buildBezierData(p1, p2, p3, p4), data = _a.data, interval = _a.interval;
+        this.lengthData = data;
+        this.interval = interval;
+        this.totalLength = data.totalLength;
+    }
+    /**
+     * 获取路径在指定比例长度上点的坐标
+     * @param percent 路径长度的比例
+     */
+    BezierPath.prototype.getPointInPercent = function (percent) {
+        var bezierData = this.lengthData;
+        if (percent === 0) {
+            return bezierData.points[0].point.clone().add(this.interval);
+        }
+        if (decimalEqual(1 - percent, 0)) {
+            return bezierData.points[CURVE_SEGMENTS - 1].point.clone().add(this.interval);
+        }
+        if (decimalEqual(bezierData.totalLength, 0)) {
+            return this.p1.clone();
+        }
+        var point = new Vector3();
+        var segmentLength = numberToFix(bezierData.totalLength * percent, 4);
+        var addedLength = this.catching.lastAddedLength;
+        var j = this.catching.lastPoint;
+        if (decimalEqual(addedLength, segmentLength)) {
+            return bezierData.points[j].point.clone().add(this.interval);
+        }
+        var flag = true;
+        var dir = 1;
+        if (segmentLength < addedLength) {
+            dir = -1;
+        }
+        while (flag) {
+            if (segmentLength >= addedLength) {
+                if (j === CURVE_SEGMENTS - 1) {
+                    point.x = bezierData.points[j].point.x;
+                    point.y = bezierData.points[j].point.y;
+                    point.z = bezierData.points[j].point.z;
+                    break;
+                }
+                if (segmentLength < addedLength + bezierData.points[j + 1].partialLength) {
+                    var segmentPerc = (segmentLength - addedLength) / bezierData.points[j + 1].partialLength;
+                    point.x = bezierData.points[j].point.x + (bezierData.points[j + 1].point.x - bezierData.points[j].point.x) * segmentPerc;
+                    point.y = bezierData.points[j].point.y + (bezierData.points[j + 1].point.y - bezierData.points[j].point.y) * segmentPerc;
+                    point.z = bezierData.points[j].point.z + (bezierData.points[j + 1].point.z - bezierData.points[j].point.z) * segmentPerc;
+                    break;
+                }
+            }
+            if (dir > 0 && j < (CURVE_SEGMENTS - 1)) {
+                j += dir;
+                addedLength += numberToFix(bezierData.points[j].partialLength, 5);
+            }
+            else if (dir < 0 && j > 0) {
+                addedLength -= numberToFix(bezierData.points[j].partialLength, 5);
+                j += dir;
+            }
+            else {
+                flag = false;
+            }
+        }
+        this.catching.lastPoint = j;
+        this.catching.lastAddedLength = addedLength;
+        point.add(this.interval);
+        return point;
+    };
+    return BezierPath;
+}());
+var BezierEasing = /** @class */ (function () {
+    function BezierEasing(mX1, mY1, mX2, mY2) {
+        this.mX1 = mX1;
+        this.mY1 = mY1;
+        this.mX2 = mX2;
+        this.mY2 = mY2;
+        this.precomputed = false;
+        this.mSampleValues = new Array(kSplineTableSize);
+        this.cachingValue = {};
+    }
+    BezierEasing.prototype.precompute = function () {
+        this.precomputed = true;
+        if (this.mX1 !== this.mY1 || this.mX2 !== this.mY2) {
+            this.calcSampleValues();
+        }
+    };
+    BezierEasing.prototype.getValue = function (x) {
+        if (this.mX1 === this.mY1 && this.mX2 === this.mY2) {
+            return x;
+        }
+        if (isNaN(this.mY1) || isNaN(this.mY2)) {
+            return 0;
+        }
+        if (x === 0 || x === 1) {
+            return x;
+        }
+        if (!this.precomputed) {
+            this.precompute();
+        }
+        var keys = Object.keys(this.cachingValue);
+        var index = keys.findIndex(function (key) { return decimalEqual(Number(key), x, 0.005); });
+        if (index !== -1) {
+            return this.cachingValue[keys[index]];
+        }
+        var value = calcBezier(this.getTForX(x), this.mY1, this.mY2);
+        if (keys.length < 300) {
+            this.cachingValue[x] = value;
+        }
+        return value;
+    };
+    BezierEasing.prototype.calcSampleValues = function () {
+        for (var i = 0; i < kSplineTableSize; ++i) {
+            this.mSampleValues[i] = calcBezier(i * kSampleStepSize, this.mX1, this.mX2);
+        }
+    };
+    BezierEasing.prototype.getTForX = function (aX) {
+        var mSampleValues = this.mSampleValues, lastSample = kSplineTableSize - 1;
+        var intervalStart = 0, currentSample = 1;
+        for (; currentSample !== lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {
+            intervalStart += kSampleStepSize;
+        }
+        --currentSample;
+        // Interpolate to provide an initial guess for t
+        var dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample + 1] - mSampleValues[currentSample]);
+        var guessForT = intervalStart + dist * kSampleStepSize;
+        var initialSlope = getSlope(guessForT, this.mX1, this.mX2);
+        if (initialSlope >= NEWTON_MIN_SLOPE) {
+            return newtonRaphsonIterate(aX, guessForT, this.mX1, this.mX2);
+        }
+        if (initialSlope === 0.0) {
+            return guessForT;
+        }
+        return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, this.mX1, this.mX2);
+    };
+    return BezierEasing;
+}());
+function buildEasingCurve(leftKeyframe, rightKeyframe) {
+    // 获取控制点和曲线类型
+    var _a = getControlPoints(leftKeyframe, rightKeyframe, true), p0 = _a.p0, p1 = _a.p1, p2 = _a.p2, p3 = _a.p3;
+    assertExist(p2);
+    assertExist(p3);
+    var timeInterval = p3.x - p0.x;
+    var valueInterval = p3.y - p0.y;
+    var y1, y2;
+    var x1 = numberToFix((p1.x - p0.x) / timeInterval, 5);
+    var x2 = numberToFix((p2.x - p0.x) / timeInterval, 5);
+    if (decimalEqual(valueInterval, 0)) {
+        y1 = y2 = NaN;
+    }
+    else {
+        y1 = numberToFix((p1.y - p0.y) / valueInterval, 5);
+        y2 = numberToFix((p2.y - p0.y) / valueInterval, 5);
+    }
+    if (x1 < 0) {
+        console.error('invalid bezier points, x1 < 0', p0, p1, p2, p3);
+        x1 = 0;
+    }
+    if (x2 < 0) {
+        console.error('invalid bezier points, x2 < 0', p0, p1, p2, p3);
+        x2 = 0;
+    }
+    if (x1 > 1) {
+        console.error('invalid bezier points, x1 >= 1', p0, p1, p2, p3);
+        x1 = 1;
+    }
+    if (x2 > 1) {
+        console.error('invalid bezier points, x2 >= 1', p0, p1, p2, p3);
+        x2 = 1;
+    }
+    var str = ('bez_' + x1 + '_' + y1 + '_' + x2 + '_' + y2).replace(/\./g, 'p');
+    var bezEasing;
+    if (BezierMap[str]) {
+        bezEasing = BezierMap[str];
+    }
+    else {
+        bezEasing = new BezierEasing(x1, y1, x2, y2);
+        BezierMap[str] = bezEasing;
+    }
+    return {
+        points: [p0, p1, p2, p3],
+        timeInterval: timeInterval,
+        valueInterval: valueInterval,
+        curve: bezEasing,
+    };
+}
+/**
+ * 根据关键帧类型获取贝塞尔曲线上的关键点
+ */
+function getControlPoints(leftKeyframe, rightKeyframe, lineToBezier) {
+    var _a = __read$3(leftKeyframe, 2), leftValue = _a[1];
+    var leftHoldLine = keyframeInfo.isHoldOutKeyframe(leftKeyframe);
+    var rightHoldLine = keyframeInfo.isHoldInKeyframe(rightKeyframe);
+    var leftEase = !rightHoldLine && keyframeInfo.isRightSideEase(leftKeyframe);
+    var rightEase = !leftHoldLine && keyframeInfo.isLeftSideEase(rightKeyframe);
+    // 1. 左边为ease，右边为line（补充右边的控制点，该点在曲线上的点的偏左边位置）
+    if (leftEase && !rightEase && !rightHoldLine) {
+        var p0_1 = new Vector2(leftValue[leftValue.length - 4], leftValue[leftValue.length - 3]);
+        var p1_1 = new Vector2(leftValue[leftValue.length - 2], leftValue[leftValue.length - 1]);
+        var rightPoint = keyframeInfo.getPointInCurve(rightKeyframe);
+        var p3 = new Vector2(rightPoint.x, rightPoint.y);
+        var p2 = new Vector2(p3.x - (p3.x - p0_1.x) / 10, p3.y);
+        return { type: 'ease', p0: p0_1, p1: p1_1, p2: p2, p3: p3 };
+    }
+    // 2. 左边为line，右边为ease（补充左边的控制点，该点在曲线上的点的偏右边位置）
+    if (!leftEase && rightEase && !leftHoldLine) {
+        var _b = __read$3(rightKeyframe, 2), rightValue = _b[1];
+        var leftPoint = keyframeInfo.getPointInCurve(leftKeyframe);
+        var p0_2 = new Vector2(leftPoint.x, leftPoint.y);
+        var p2 = new Vector2(rightValue[0], rightValue[1]);
+        var p3 = new Vector2(rightValue[2], rightValue[3]);
+        var p1_2 = new Vector2(p0_2.x + (p3.x - p0_2.x) / 10, p0_2.y);
+        return { type: 'ease', p0: p0_2, p1: p1_2, p2: p2, p3: p3 };
+    }
+    // 3. 左边为ease，右边为ease
+    if (leftEase && rightEase) {
+        var _c = __read$3(rightKeyframe, 2), rightValue = _c[1];
+        var p0_3 = new Vector2(leftValue[leftValue.length - 4], leftValue[leftValue.length - 3]);
+        var p1_3 = new Vector2(leftValue[leftValue.length - 2], leftValue[leftValue.length - 1]);
+        var p2 = new Vector2(rightValue[0], rightValue[1]);
+        var p3 = new Vector2(rightValue[2], rightValue[3]);
+        return { type: 'ease', p0: p0_3, p1: p1_3, p2: p2, p3: p3 };
+    }
+    // 4. 左边为line，右边为line
+    var p0 = keyframeInfo.getPointInCurve(leftKeyframe);
+    var p1 = keyframeInfo.getPointInCurve(rightKeyframe);
+    if (leftHoldLine) {
+        p1.y = p0.y; // 定格关键帧使用相同的点
+    }
+    else if (rightHoldLine) {
+        p0.y = p1.y;
+    }
+    if (lineToBezier) {
+        // 补上两个在直线上的控制点
+        var p2 = new Vector2((p1.x - p0.x) / 3 + p0.x, (p1.y - p0.y) / 3 + p0.y);
+        var p3 = new Vector2((p1.x - p0.x) / 3 * 2 + p0.x, (p1.y - p0.y) / 3 * 2 + p0.y);
+        return { type: 'ease', p0: p0, p1: p2, p2: p3, p3: p1, isHold: leftHoldLine || rightHoldLine, leftHoldLine: leftHoldLine, rightHoldLine: rightHoldLine };
+    }
+    else {
+        return { type: 'line', p0: p0, p1: p1, isHold: leftHoldLine || rightHoldLine, leftHoldLine: leftHoldLine, rightHoldLine: rightHoldLine };
+    }
+}
 
 var _a$8;
 var NOT_IMPLEMENT = 'not_implement';
@@ -7310,6 +7752,15 @@ var ValueGetter = /** @class */ (function () {
     function ValueGetter(arg) {
         this.onCreate(arg);
     }
+    ValueGetter.getAllData = function (meta, halfFloat) {
+        var ret = new (halfFloat ? Float16ArrayWrapper : Float32Array)(meta.index * 4);
+        for (var i = 0, cursor = 0, curves = meta.curves; i < curves.length; i++) {
+            var data = curves[i].toData();
+            ret.set(data, cursor);
+            cursor += data.length;
+        }
+        return halfFloat ? ret.data : ret;
+    };
     ValueGetter.prototype.onCreate = function (props) {
         throw Error(NOT_IMPLEMENT);
     };
@@ -7331,6 +7782,9 @@ var ValueGetter = /** @class */ (function () {
     ValueGetter.prototype.scaleXCoord = function (scale) {
         return this;
     };
+    ValueGetter.prototype.toData = function () {
+        throw Error(NOT_IMPLEMENT);
+    };
     return ValueGetter;
 }());
 var StaticValue = /** @class */ (function (_super) {
@@ -7493,153 +7947,6 @@ var GradientValue = /** @class */ (function (_super) {
     };
     return GradientValue;
 }(ValueGetter));
-var CURVE_PRO_TIME = 0;
-var CURVE_PRO_VALUE = 1;
-var CURVE_PRO_IN_TANGENT = 2;
-var CURVE_PRO_OUT_TANGENT = 3;
-var CurveValue = /** @class */ (function (_super) {
-    __extends(CurveValue, _super);
-    function CurveValue() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    CurveValue.getAllData = function (meta, halfFloat) {
-        var ret = new (halfFloat ? Float16ArrayWrapper : Float32Array)(meta.index * 4);
-        for (var i = 0, cursor = 0, curves = meta.curves; i < curves.length; i++) {
-            var data = curves[i].toData();
-            ret.set(data, cursor);
-            cursor += data.length;
-        }
-        return halfFloat ? ret.data : ret;
-    };
-    CurveValue.prototype.onCreate = function (props) {
-        var min = Infinity;
-        var max = -Infinity;
-        //formatted number
-        if (Number.isFinite(props[0]) && Number.isFinite(props[1])) {
-            var keys = [];
-            for (var i = 2; i < props.length; i++) {
-                // FIXME
-                keys.push(props[i].slice(0, 4));
-            }
-            this.keys = keys;
-            this.min = props[0];
-            this.dist = props[1] - props[0];
-        }
-        else {
-            var keys = props.map(function (item) {
-                if (isArray(item)) {
-                    min = Math.min(min, item[1]);
-                    max = Math.max(max, item[1]);
-                    return item.slice(0, 4);
-                }
-                else if (typeof item === 'object' && item) {
-                    var _a = item, time = _a.time, value = _a.value, _b = _a.inTangent, inTangent = _b === void 0 ? 0 : _b, _c = _a.outTangent, outTangent = _c === void 0 ? 0 : _c;
-                    min = Math.min(min, value);
-                    max = Math.max(max, value);
-                    return [time, value, inTangent, outTangent];
-                }
-                throw new Error('invalid keyframe');
-            });
-            var dist = max - min;
-            this.keys = keys;
-            if (dist !== 0) {
-                for (var i = 0; i < keys.length; i++) {
-                    var key = keys[i];
-                    key[1] = (key[1] - min) / dist;
-                }
-            }
-            var key0 = keys[0];
-            if (key0[0] > 0) {
-                key0[2] = 0;
-                keys.unshift([0, key0[1], 0, 0]);
-            }
-            var key1 = keys[keys.length - 1];
-            if (key1[0] < 1) {
-                key1[3] = 0;
-                keys.push([1, key1[1], 0, 0]);
-            }
-            this.min = min;
-            this.dist = dist;
-        }
-        this.isCurveValue = true;
-    };
-    CurveValue.prototype.getValue = function (time) {
-        var _a = this, keys = _a.keys, min = _a.min, dist = _a.dist;
-        var keysNumerArray = keys;
-        if (time <= keysNumerArray[0][CURVE_PRO_TIME]) {
-            return keysNumerArray[0][CURVE_PRO_VALUE] * dist + min;
-        }
-        var end = keysNumerArray.length - 1;
-        for (var i = 0; i < end; i++) {
-            var key = keysNumerArray[i];
-            var k2 = keysNumerArray[i + 1];
-            if (time > key[CURVE_PRO_TIME] && time <= k2[CURVE_PRO_TIME]) {
-                return curveValueEvaluate(time, key, k2) * dist + min;
-            }
-        }
-        return keysNumerArray[end][CURVE_PRO_VALUE] * dist + min;
-    };
-    CurveValue.prototype.getIntegrateByTime = function (t0, t1) {
-        var d = this.integrate(t1, true) - this.integrate(t0, true);
-        return this.min * 0.5 * (t1 - t0) * (t1 - t0) + d * this.dist;
-    };
-    CurveValue.prototype.getIntegrateValue = function (t0, t1, ts) {
-        ts = ts || 1;
-        var d = (this.integrate(t1 / ts, false) - this.integrate(t0 / ts, false)) * ts;
-        var dt = (t1 - t0) / ts;
-        return this.min * dt + d * this.dist;
-    };
-    CurveValue.prototype.integrate = function (time, byTime) {
-        var keys = this.keys;
-        if (time <= keys[0][CURVE_PRO_TIME]) {
-            return 0;
-        }
-        var ret = 0;
-        var end = keys.length - 1;
-        var func = byTime ? curveValueIntegrateByTime : curveValueIntegrate;
-        for (var i = 0; i < end; i++) {
-            var key = keys[i];
-            var k2 = keys[i + 1];
-            var t1 = key[CURVE_PRO_TIME];
-            var t2 = k2[CURVE_PRO_TIME];
-            if (time > t1 && time <= t2) {
-                return ret + func(time, key, k2);
-            }
-            else {
-                ret += func(t2, key, k2);
-            }
-        }
-        return ret;
-    };
-    CurveValue.prototype.toData = function () {
-        var keys = this.keys;
-        var data = new Float32Array(keys.length * 4);
-        for (var i = 0, cursor = 0; i < keys.length; i++, cursor += 4) {
-            data.set(keys[i], cursor);
-        }
-        return data;
-    };
-    CurveValue.prototype.toUniform = function (meta) {
-        var index = meta.index;
-        var keys = this.keys;
-        meta.curves.push(this);
-        meta.index += keys.length;
-        meta.max = Math.max(meta.max, keys.length);
-        meta.curveCount += keys.length;
-        return new Float32Array([2, index + 1 / keys.length, this.min, this.dist]);
-    };
-    CurveValue.prototype.map = function (func) {
-        this.keys.forEach(function (k) {
-            k[CURVE_PRO_VALUE] = func(k[CURVE_PRO_VALUE]);
-        });
-        return this;
-    };
-    CurveValue.prototype.scaleXCoord = function (scale) {
-        this.keys.forEach(function (k) { return k[CURVE_PRO_TIME] = scale * k[CURVE_PRO_TIME]; });
-        return this;
-    };
-    return CurveValue;
-}(ValueGetter));
 var LineSegments = /** @class */ (function (_super) {
     __extends(LineSegments, _super);
     function LineSegments() {
@@ -7741,77 +8048,247 @@ var LineSegments = /** @class */ (function (_super) {
     };
     return LineSegments;
 }(ValueGetter));
-var PathSegments = /** @class */ (function (_super) {
-    __extends(PathSegments, _super);
-    function PathSegments() {
+// export class PathSegments extends ValueGetter<number[]> {
+//   keys: number[][];
+//   values: number[][];
+//
+//   override onCreate (props: number[][][]) {
+//     this.keys = props[0];
+//     this.values = props[1];
+//   }
+//
+//   override getValue (time: number) {
+//     const keys = this.keys;
+//     const values = this.values;
+//
+//     for (let i = 0; i < keys.length - 1; i++) {
+//       const k0 = keys[i];
+//       const k1 = keys[i + 1];
+//
+//       if (k0[0] <= time && k1[0] >= time) {
+//         const dis = k1[1] - k0[1];
+//         let dt;
+//
+//         if (dis === 0) {
+//           dt = (time - k0[0]) / (k1[0] - k0[0]);
+//         } else {
+//           const val = curveValueEvaluate(time, k0, k1);
+//
+//           dt = (val - k0[1]) / dis;
+//         }
+//
+//         return this.calculateVec(i, dt);
+//       }
+//     }
+//     if (time <= keys[0][0]) {
+//       return values[0].slice();
+//     }
+//
+//     return values[values.length - 1].slice();
+//   }
+//
+//   calculateVec (i: number, dt: number) {
+//     const vec0 = this.values[i];
+//     const vec1 = this.values[i + 1];
+//     const ret = [0, 0, 0];
+//
+//     for (let j = 0; j < vec0.length; j++) {
+//       ret[j] = vec0[j] * (1 - dt) + vec1[j] * dt;
+//     }
+//
+//     return ret;
+//   }
+// }
+var BezierCurve = /** @class */ (function (_super) {
+    __extends(BezierCurve, _super);
+    function BezierCurve() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    PathSegments.prototype.onCreate = function (props) {
-        this.keys = props[0];
-        this.values = props[1];
+    BezierCurve.prototype.onCreate = function (props) {
+        var keyframes = props;
+        this.curveMap = {};
+        this.keys = [];
+        for (var i = 0; i < keyframes.length - 1; i++) {
+            var leftKeyframe = keyframes[i];
+            var rightKeyframe = keyframes[i + 1];
+            var _a = buildEasingCurve(leftKeyframe, rightKeyframe), points = _a.points, curve = _a.curve, timeInterval = _a.timeInterval, valueInterval = _a.valueInterval;
+            var s = points[0];
+            var e = points[points.length - 1];
+            this.keys.push(__spreadArray$2(__spreadArray$2([], __read$3(s.toArray()), false), __read$3(points[1].toArray()), false));
+            this.keys.push(__spreadArray$2(__spreadArray$2([], __read$3(e.toArray()), false), __read$3(points[2].toArray()), false));
+            this.curveMap["".concat(s.x, "&").concat(e.x)] = {
+                points: points,
+                timeInterval: timeInterval,
+                valueInterval: valueInterval,
+                curve: curve,
+            };
+        }
     };
-    PathSegments.prototype.getValue = function (time) {
-        var keys = this.keys;
-        var values = this.values;
-        for (var i = 0; i < keys.length - 1; i++) {
-            var k0 = keys[i];
-            var k1 = keys[i + 1];
-            if (k0[0] <= time && k1[0] >= time) {
-                var dis = k1[1] - k0[1];
-                var dt = void 0;
-                if (dis === 0) {
-                    dt = (time - k0[0]) / (k1[0] - k0[0]);
-                }
-                else {
-                    var val = curveValueEvaluate(time, k0, k1);
-                    dt = (val - k0[1]) / dis;
-                }
-                return this.calculateVec(i, dt);
+    BezierCurve.prototype.getValue = function (time) {
+        var result = 0;
+        var keyTimeData = Object.keys(this.curveMap);
+        var keyTimeStart = Number(keyTimeData[0].split('&')[0]);
+        var keyTimeEnd = Number(keyTimeData[keyTimeData.length - 1].split('&')[1]);
+        if (time <= keyTimeStart) {
+            return this.getCurveValue(keyTimeData[0], keyTimeStart);
+        }
+        if (time >= keyTimeEnd) {
+            return this.getCurveValue(keyTimeData[keyTimeData.length - 1], keyTimeEnd);
+        }
+        for (var i = 0; i < keyTimeData.length; i++) {
+            var _a = __read$3(keyTimeData[i].split('&'), 2), xMin = _a[0], xMax = _a[1];
+            if (time >= Number(xMin) && time < Number(xMax)) {
+                result = this.getCurveValue(keyTimeData[i], time);
+                break;
             }
         }
-        if (time <= keys[0][0]) {
-            return values[0].slice();
+        return result;
+    };
+    BezierCurve.prototype.getIntegrateValue = function (t0, t1, ts) {
+        if (ts === void 0) { ts = 1; }
+        var time = (t1 - t0);
+        var result = 0;
+        var keyTimeData = Object.keys(this.curveMap);
+        var keyTimeStart = Number(keyTimeData[0].split('&')[0]);
+        if (time <= keyTimeStart) {
+            return 0;
+        }
+        for (var i = 0; i < keyTimeData.length; i++) {
+            var _a = __read$3(keyTimeData[i].split('&'), 2), xMin = _a[0], xMax = _a[1];
+            if (time >= Number(xMax)) {
+                result += ts * this.getCurveIntegrateValue(keyTimeData[i], Number(xMax));
+            }
+            if (time >= Number(xMin) && time < Number(xMax)) {
+                result += ts * this.getCurveIntegrateValue(keyTimeData[i], time);
+                break;
+            }
         }
-        return values[values.length - 1].slice();
+        return result;
     };
-    PathSegments.prototype.calculateVec = function (i, dt) {
-        var vec0 = this.values[i];
-        var vec1 = this.values[i + 1];
-        var ret = [0, 0, 0];
-        for (var j = 0; j < vec0.length; j++) {
-            ret[j] = vec0[j] * (1 - dt) + vec1[j] * dt;
+    // 速度变化曲线面板移除后下线
+    BezierCurve.prototype.getCurveIntegrateValue = function (curveKey, time) {
+        var curveInfo = this.curveMap[curveKey];
+        var _a = __read$3(curveInfo.points, 1), p0 = _a[0];
+        var timeInterval = curveInfo.timeInterval;
+        var valueInterval = curveInfo.valueInterval;
+        var segments = 100;
+        var total = 0;
+        var h = (time - p0.x) / segments;
+        for (var i = 0; i <= segments; i++) {
+            var t = i * h;
+            var normalizeTime = t / timeInterval;
+            var y = p0.y + valueInterval * curveInfo.curve.getValue(normalizeTime);
+            if (i === 0 || i === segments) {
+                total += y;
+            }
+            else if (i % 2 === 1) {
+                total += 4 * y;
+            }
+            else {
+                total += 2 * y;
+            }
         }
-        return ret;
+        total *= h / 3;
+        return total;
+    };
+    BezierCurve.prototype.getCurveValue = function (curveKey, time) {
+        var curveInfo = this.curveMap[curveKey];
+        var _a = __read$3(curveInfo.points, 1), p0 = _a[0];
+        var timeInterval = curveInfo.timeInterval;
+        var valueInterval = curveInfo.valueInterval;
+        var normalizeTime = (time - p0.x) / timeInterval;
+        var value = curveInfo.curve.getValue(normalizeTime);
+        return p0.y + valueInterval * value;
+    };
+    BezierCurve.prototype.toUniform = function (meta) {
+        var index = meta.index;
+        var count = this.keys.length;
+        meta.curves.push(this);
+        meta.index = index + count;
+        // 兼容 WebGL1
+        meta.max = Math.max(meta.max, count);
+        meta.curveCount += count;
+        return new Float32Array([5, index + 1 / count, index, count]);
+    };
+    BezierCurve.prototype.toData = function () {
+        var keys = this.keys;
+        var data = new Float32Array(keys.length * 4);
+        for (var i = 0, cursor = 0; i < keys.length; i++, cursor += 4) {
+            data.set(keys[i], cursor);
+        }
+        return data;
     };
-    return PathSegments;
+    return BezierCurve;
 }(ValueGetter));
-var BezierSegments = /** @class */ (function (_super) {
-    __extends(BezierSegments, _super);
-    function BezierSegments() {
+var BezierCurvePath = /** @class */ (function (_super) {
+    __extends(BezierCurvePath, _super);
+    function BezierCurvePath() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
-    BezierSegments.prototype.onCreate = function (props) {
-        _super.prototype.onCreate.call(this, props);
-        this.cps = props[2];
-    };
-    BezierSegments.prototype.calculateVec = function (i, t) {
-        var vec0 = this.values[i];
-        var vec1 = this.values[i + 1];
-        var outCp = this.cps[i + i];
-        var inCp = this.cps[i + i + 1];
-        var ret = [0, 0, 0];
-        var ddt = 1 - t;
-        var a = ddt * ddt * ddt;
-        var b = 3 * t * ddt * ddt;
-        var c = 3 * t * t * ddt;
-        var d = t * t * t;
-        for (var j = 0; j < vec0.length; j++) {
-            ret[j] = a * vec0[j] + b * outCp[j] + c * inCp[j] + d * vec1[j];
+    BezierCurvePath.prototype.onCreate = function (props) {
+        var _a = __read$3(props, 3), keyframes = _a[0], points = _a[1], controlPoints = _a[2];
+        this.curveSegments = {};
+        if (!controlPoints.length) {
+            return;
+        }
+        for (var i = 0; i < keyframes.length - 1; i++) {
+            var leftKeyframe = keyframes[i];
+            var rightKeyframe = keyframes[i + 1];
+            var ps1 = new Vector3(points[i][0], points[i][1], points[i][2]), ps2 = new Vector3(points[i + 1][0], points[i + 1][1], points[i + 1][2]);
+            var cp1 = new Vector3(controlPoints[2 * i][0], controlPoints[2 * i][1], controlPoints[2 * i][2]), cp2 = new Vector3(controlPoints[2 * i + 1][0], controlPoints[2 * i + 1][1], controlPoints[2 * i + 1][2]);
+            var _b = buildEasingCurve(leftKeyframe, rightKeyframe), ps = _b.points, easingCurve = _b.curve, timeInterval = _b.timeInterval, valueInterval = _b.valueInterval;
+            var s = ps[0];
+            var e = ps[ps.length - 1];
+            var pathCurve = new BezierPath(ps1, ps2, cp1, cp2);
+            this.curveSegments["".concat(s.x, "&").concat(e.x)] = {
+                points: ps,
+                timeInterval: timeInterval,
+                valueInterval: valueInterval,
+                easingCurve: easingCurve,
+                pathCurve: pathCurve,
+            };
         }
-        return ret;
     };
-    return BezierSegments;
-}(PathSegments));
+    BezierCurvePath.prototype.getValue = function (time) {
+        var t = numberToFix(time, 5);
+        var perc = 0, point = new Vector3();
+        var keyTimeData = Object.keys(this.curveSegments);
+        if (!keyTimeData.length) {
+            return point;
+        }
+        var keyTimeStart = Number(keyTimeData[0].split('&')[0]);
+        var keyTimeEnd = Number(keyTimeData[keyTimeData.length - 1].split('&')[1]);
+        if (t <= keyTimeStart) {
+            var pathCurve = this.curveSegments[keyTimeData[0]].pathCurve;
+            point = pathCurve.getPointInPercent(0);
+            return point;
+        }
+        if (t >= keyTimeEnd) {
+            var pathCurve = this.curveSegments[keyTimeData[keyTimeData.length - 1]].pathCurve;
+            point = pathCurve.getPointInPercent(1);
+            return point;
+        }
+        for (var i = 0; i < keyTimeData.length; i++) {
+            var _a = __read$3(keyTimeData[i].split('&'), 2), xMin = _a[0], xMax = _a[1];
+            if (t >= Number(xMin) && t < Number(xMax)) {
+                var bezierPath = this.curveSegments[keyTimeData[i]].pathCurve;
+                perc = this.getPercValue(keyTimeData[i], t);
+                point = bezierPath.getPointInPercent(perc);
+            }
+        }
+        return point;
+    };
+    BezierCurvePath.prototype.getPercValue = function (curveKey, time) {
+        var curveInfo = this.curveSegments[curveKey];
+        var _a = __read$3(curveInfo.points, 1), p0 = _a[0];
+        var timeInterval = curveInfo.timeInterval;
+        var normalizeTime = numberToFix((time - p0.x) / timeInterval, 4);
+        var value = curveInfo.easingCurve.getValue(normalizeTime);
+        // TODO 测试用 编辑器限制值域后移除clamp
+        return clamp$1(value, 0, 1);
+    };
+    return BezierCurvePath;
+}(ValueGetter));
 var map$2 = (_a$8 = {},
     _a$8[ValueType$1.RANDOM] = function (props) {
         if (props[0] instanceof Array) {
@@ -7831,9 +8308,6 @@ var map$2 = (_a$8 = {},
     _a$8[ValueType$1.CONSTANT_VEC4] = function (props) {
         return new StaticValue(props);
     },
-    _a$8[ValueType$1.CURVE] = function (props) {
-        return new CurveValue(props);
-    },
     _a$8[ValueType$1.RGBA_COLOR] = function (props) {
         return new StaticValue(props);
     },
@@ -7849,11 +8323,20 @@ var map$2 = (_a$8 = {},
     _a$8[ValueType$1.GRADIENT_COLOR] = function (props) {
         return new GradientValue(props);
     },
-    _a$8[ValueType$1.LINEAR_PATH] = function (pros) {
-        return new PathSegments(pros);
+    // [spec.ValueType.LINEAR_PATH] (pros: number[][][]) {
+    //   return new PathSegments(pros);
+    // },
+    _a$8[ValueType$1.BEZIER_CURVE] = function (props) {
+        if (props.length === 1) {
+            return new StaticValue(props[0][1][1]);
+        }
+        return new BezierCurve(props);
     },
-    _a$8[ValueType$1.BEZIER_PATH] = function (pros) {
-        return new BezierSegments(pros);
+    _a$8[ValueType$1.BEZIER_CURVE_PATH] = function (props) {
+        if (props[0].length === 1) {
+            return new StaticValue(new Vector3(props[0][0][1][1], props[1][0][1][1], props[2][0][1][1]));
+        }
+        return new BezierCurvePath(props);
     },
     _a$8);
 function createValueGetter(args) {
@@ -7881,53 +8364,6 @@ function lineSegIntegrateByTime(t, t0, t1, y0, y1) {
     var t03 = t02 * t0;
     return (2 * t3 * (y0 - y1) + 3 * t2 * (t0 * y1 - t1 * y0) - t03 * (2 * y0 + y1) + 3 * t02 * t1 * y0) / (6 * (t0 - t1));
 }
-function curveValueEvaluate(time, keyframe0, keyframe1) {
-    var dt = keyframe1[CURVE_PRO_TIME] - keyframe0[CURVE_PRO_TIME];
-    var m0 = keyframe0[CURVE_PRO_OUT_TANGENT] * dt;
-    var m1 = keyframe1[CURVE_PRO_IN_TANGENT] * dt;
-    var t = (time - keyframe0[CURVE_PRO_TIME]) / dt;
-    var t2 = t * t;
-    var t3 = t2 * t;
-    var a = 2 * t3 - 3 * t2 + 1;
-    var b = t3 - 2 * t2 + t;
-    var c = t3 - t2;
-    var d = -2 * t3 + 3 * t2;
-    //(2*v0+m0+m1-2*v1)*(t-t0)^3/k^3+(3*v1-3*v0-2*m0-m1)*(t-t0)^2/k^2+m0 *(t-t0)/k+v0
-    return a * keyframe0[CURVE_PRO_VALUE] + b * m0 + c * m1 + d * keyframe1[CURVE_PRO_VALUE];
-}
-function curveValueIntegrate(time, keyframe0, keyframe1) {
-    var k = keyframe1[CURVE_PRO_TIME] - keyframe0[CURVE_PRO_TIME];
-    var m0 = keyframe0[CURVE_PRO_OUT_TANGENT] * k;
-    var m1 = keyframe1[CURVE_PRO_IN_TANGENT] * k;
-    var t0 = keyframe0[CURVE_PRO_TIME];
-    var v0 = keyframe0[CURVE_PRO_VALUE];
-    var v1 = keyframe1[CURVE_PRO_VALUE];
-    var dt = t0 - time;
-    var dt2 = dt * dt;
-    var dt3 = dt2 * dt;
-    return (m0 + m1 + 2 * v0 - 2 * v1) * dt3 * dt / (4 * k * k * k) +
-        (2 * m0 + m1 + 3 * v0 - 3 * v1) * dt3 / (3 * k * k) +
-        m0 * dt2 / 2 / k - v0 * dt;
-}
-function curveValueIntegrateByTime(t1, keyframe0, keyframe1) {
-    var k = keyframe1[CURVE_PRO_TIME] - keyframe0[CURVE_PRO_TIME];
-    var m0 = keyframe0[CURVE_PRO_OUT_TANGENT] * k;
-    var m1 = keyframe1[CURVE_PRO_IN_TANGENT] * k;
-    var t0 = keyframe0[CURVE_PRO_TIME];
-    var v0 = keyframe0[CURVE_PRO_VALUE];
-    var v1 = keyframe1[CURVE_PRO_VALUE];
-    var dt = t0 - t1;
-    var dt2 = dt * dt;
-    var dt3 = dt2 * dt;
-    var k2 = k * k;
-    var k3 = k2 * k;
-    //(30 k^3 v0 (t1^2 - t0^2) + 10 k^2 m0 (t0 + 2 t1) (t0 - t1)^2 + 5 k (t0 + 3 t1) (t0 - t1)^3 (2 m0 + m1 + 3 v0 - 3 v1) + 3 (t0 + 4 t1) (t0 - t1)^4 (m0 + m1 + 2 v0 - 2 v1))/(60 k^3)
-    var ret = -30 * k3 * v0 * (t0 + t1) * dt +
-        10 * k2 * m0 * (t0 + 2 * t1) * dt2 +
-        5 * k * (t0 + 3 * t1) * (2 * m0 + m1 + 3 * v0 - 3 * v1) * dt3 +
-        3 * (t0 + 4 * t1) * (m0 + m1 + 2 * v0 - 2 * v1) * dt3 * dt;
-    return ret / 60 / k3;
-}
 function getKeyFrameMetaByRawValue(meta, value) {
     if (value) {
         var type = value[0];
@@ -7962,6 +8398,13 @@ function getKeyFrameMetaByRawValue(meta, value) {
             meta.index += uniformCount;
             meta.max = Math.max(meta.max, uniformCount);
         }
+        else if (type === ValueType$1.BEZIER_CURVE) {
+            var keyLen = keys.length - 1;
+            meta.index += 2 * keyLen;
+            meta.curves.push(keys);
+            meta.max = Math.max(meta.max, 2 * keyLen);
+            meta.curveCount += 2 * keyLen;
+        }
     }
 }
 function createKeyFrameMeta() {
@@ -11692,21 +12135,19 @@ var compatible_vert = "#version 300 es\n#ifdef WEBGL2\n#define texture2D texture
 
 var itemFrameFrag = "#version 300 es\nprecision highp float;\n#version 300 es\n#ifdef WEBGL2\n#define texture2D texture\n#define textureCube texture\n#define textureCubeLodEXT textureLod\nlayout(location=0)out vec4 fragColor;\n#else\n#define fragColor gl_FragColor\n#endif\nvec4 blendColor(vec4 color,vec4 vc,float mode){vec4 ret=color*vc;\n#ifdef PRE_MULTIPLY_ALPHA\nfloat alpha=vc.a;\n#else\nfloat alpha=ret.a;\n#endif\nif(mode==1.){ret.rgb*=alpha;}else if(mode==2.){ret.rgb*=alpha;ret.a=dot(ret.rgb,vec3(0.33333333));}else if(mode==3.){alpha=color.r*alpha;ret=vec4(vc.rgb*alpha,alpha);}return ret;}in vec4 vColor;in vec4 vTexCoord;in highp vec2 vParams;uniform vec3 uFrameColor;void main(){fragColor=vec4(uFrameColor.xyz,1.0);}";
 
-var integrate = "float integrateCurveFrames(float t1,vec4 k0,vec4 k1){float k=k1.x-k0.x;float m0=k0.w*k;float m1=k1.z*k;float t0=k0.x;float v0=k0.y;float v1=k1.y;float dt=t0-t1;float dt2=dt*dt;float dt3=dt2*dt;vec4 a=vec4(dt3*dt,dt3,dt2,dt)/vec4(4.*k*k*k,3.*k*k,2.*k,1.);vec4 b=vec4(m0+m1+2.*v0-2.*v1,2.*m0+m1+3.*v0-3.*v1,m0,-v0);return dot(a,b);}float integrateByTimeCurveFrames(float t1,vec4 k0,vec4 k1){float k=k1.x-k0.x;float m0=k0.w*k;float m1=k1.z*k;float t0=k0.x;float v0=k0.y;float v1=k1.y;float dt=t0-t1;float dt2=dt*dt;float dt3=dt2*dt;float k2=k*k;float k3=k2*k;vec4 a=vec4(-30.*k3,10.*k2,5.*k,3.)*vec4(dt,dt2,dt3,dt3*dt);vec4 b=vec4(v0,m0,2.*m0+m1+3.*v0-3.*v1,m0+m1+2.*v0-2.*v1)*vec4(t0+t1,t0+2.*t1,t0+3.*t1,t0+4.*t1);return dot(a,b)/60./k3;}float integrateByTimeFromCurveFrames(float t1,float frameStart,float frameCount){if(t1==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i==count){return ret;}vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);if(t1>k0.x&&t1<=k1.x){return ret+integrateByTimeCurveFrames(t1,k0,k1);}ret+=integrateByTimeCurveFrames(k1.x,k0,k1);}return ret;}float integrateFromCurveFrames(float time,float frameStart,float frameCount){if(time==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i==count){return ret;}vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);if(time>k0.x&&time<=k1.x){return ret+integrateCurveFrames(time,k0,k1);}ret+=integrateCurveFrames(k1.x,k0,k1);}return ret;}float integrateByTimeLineSeg(float t,vec2 p0,vec2 p1){float t0=p0.x;float t1=p1.x;float y0=p0.y;float y1=p1.y;vec4 tSqr=vec4(t,t,t0,t0);tSqr=tSqr*tSqr;vec4 a=vec4(2.*t,3.,-t0,3.)*tSqr;float t1y0=t1*y0;vec4 b=vec4(y0-y1,t0*y1-t1y0,2.*y0+y1,t1y0);float r=dot(a,b);return r/(t0-t1)*0.16666667;}float integrateLineSeg(float time,vec2 p0,vec2 p1){float h=time-p0.x;float y0=p0.y;return(y0+y0+(p1.y-y0)*h/(p1.x-p0.x))*h/2.;}float integrateFromLineSeg(float time,float frameStart,float frameCount){if(time==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i>count){return ret;}vec4 ks=lookup_curve(i+start);vec2 k0=ks.xy;vec2 k1=ks.zw;if(time>k0.x&&time<=k1.x){return ret+integrateLineSeg(time,k0,k1);}ret+=integrateLineSeg(k1.x,k0,k1);vec2 k2=lookup_curve(i+start+1).xy;if(time>k1.x&&time<=k2.x){return ret+integrateLineSeg(time,k1,k2);}ret+=integrateLineSeg(k2.x,k1,k2);}return ret;}float integrateByTimeFromLineSeg(float time,float frameStart,float frameCount){if(time==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i>count){return ret;}vec4 ks=lookup_curve(i+start);vec2 k0=ks.xy;vec2 k1=ks.zw;if(time>k0.x&&time<=k1.x){return ret+integrateByTimeLineSeg(time,k0,k1);}ret+=integrateByTimeLineSeg(k1.x,k0,k1);vec2 k2=lookup_curve(i+start+1).xy;if(time>k1.x&&time<=k2.x){return ret+integrateByTimeLineSeg(time,k1,k2);}ret+=integrateByTimeLineSeg(k2.x,k1,k2);}return ret;}float getIntegrateFromTime0(float t1,vec4 value){float type=value.x;if(type==0.){return value.y*t1;}else if(type==1.){vec2 p0=vec2(0.,value.y);vec2 p1=vec2(value.w,value.z);return integrateLineSeg(t1,p0,p1);}if(type==3.){return integrateFromLineSeg(t1,value.y,value.z);}if(type==2.){float idx=floor(value.y);float ilen=floor(1./fract(value.y)+0.5);float d=integrateFromCurveFrames(t1,idx,ilen);return d*value.w+value.z*t1;}if(type==4.){return mix(value.y,value.z,aSeed)*t1;}return 0.;}float getIntegrateByTimeFromTime(float t0,float t1,vec4 value){float type=value.x;if(type==0.){return value.y*(t1*t1-t0*t0)/2.;}else if(type==1.){vec2 p0=vec2(0.,value.y);vec2 p1=vec2(value.w,value.z);return integrateByTimeLineSeg(t1,p0,p1)-integrateByTimeLineSeg(t0,p0,p1);}if(type==2.){float idx=floor(value.y);float ilen=floor(1./fract(value.y)+0.5);float d=integrateByTimeFromCurveFrames(t1,idx,ilen)-integrateByTimeFromCurveFrames(t0,idx,ilen);return d*value.w+value.z*pow(t1-t0,2.)*0.5;}if(type==3.){return integrateByTimeFromLineSeg(t1,value.y,value.z)-integrateByTimeFromLineSeg(t0,value.y,value.z);}if(type==4.){return mix(value.y,value.z,aSeed)*(t1*t1-t0*t0)/2.;}return 0.;}";
+var integrate = "float calculateMovement(float t,vec2 p1,vec2 p2,vec2 p3,vec2 p4){float movement=0.0;float h=(t-p1.x)*0.1;float delta=1./(p4.x-p1.x);for(int i=0;i<=10;i++){float t=float(i)*h*delta;float nt=binarySearchT(t,p1.x,p2.x,p3.x,p4.x);float y=cubicBezier(nt,p1.y,p2.y,p3.y,p4.y);float weight=(i==0||i==10)? 1.0 :(mod(float(i),2.)!=0.)? 4.0 : 2.0;movement+=weight*y;}movement*=h/3.;return movement;}float integrateFromBezierCurveFrames(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i+=2){vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);if(i==0&&time<k0.x){return ret;}vec2 p1=vec2(k0.x,k0.y);vec2 p2=vec2(k0.z,k0.w);vec2 p3=vec2(k1.z,k1.w);vec2 p4=vec2(k1.x,k1.y);if(time>=k1.x){ret+=calculateMovement(k1.x,p1,p2,p3,p4);}if(time>=k0.x&&time<k1.x){return ret+calculateMovement(time,p1,p2,p3,p4);}}return ret;}float integrateByTimeLineSeg(float t,vec2 p0,vec2 p1){float t0=p0.x;float t1=p1.x;float y0=p0.y;float y1=p1.y;vec4 tSqr=vec4(t,t,t0,t0);tSqr=tSqr*tSqr;vec4 a=vec4(2.*t,3.,-t0,3.)*tSqr;float t1y0=t1*y0;vec4 b=vec4(y0-y1,t0*y1-t1y0,2.*y0+y1,t1y0);float r=dot(a,b);return r/(t0-t1)*0.16666667;}float integrateLineSeg(float time,vec2 p0,vec2 p1){float h=time-p0.x;float y0=p0.y;return(y0+y0+(p1.y-y0)*h/(p1.x-p0.x))*h/2.;}float integrateFromLineSeg(float time,float frameStart,float frameCount){if(time==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i>count){return ret;}vec4 ks=lookup_curve(i+start);vec2 k0=ks.xy;vec2 k1=ks.zw;if(time>k0.x&&time<=k1.x){return ret+integrateLineSeg(time,k0,k1);}ret+=integrateLineSeg(k1.x,k0,k1);vec2 k2=lookup_curve(i+start+1).xy;if(time>k1.x&&time<=k2.x){return ret+integrateLineSeg(time,k1,k2);}ret+=integrateLineSeg(k2.x,k1,k2);}return ret;}float integrateByTimeFromLineSeg(float time,float frameStart,float frameCount){if(time==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i>count){return ret;}vec4 ks=lookup_curve(i+start);vec2 k0=ks.xy;vec2 k1=ks.zw;if(time>k0.x&&time<=k1.x){return ret+integrateByTimeLineSeg(time,k0,k1);}ret+=integrateByTimeLineSeg(k1.x,k0,k1);vec2 k2=lookup_curve(i+start+1).xy;if(time>k1.x&&time<=k2.x){return ret+integrateByTimeLineSeg(time,k1,k2);}ret+=integrateByTimeLineSeg(k2.x,k1,k2);}return ret;}float getIntegrateFromTime0(float t1,vec4 value){float type=value.x;if(type==0.){return value.y*t1;}else if(type==1.){vec2 p0=vec2(0.,value.y);vec2 p1=vec2(value.w,value.z);return integrateLineSeg(t1,p0,p1);}if(type==3.){return integrateFromLineSeg(t1,value.y,value.z);}if(type==4.){return mix(value.y,value.z,aSeed)*t1;}if(type==5.){return integrateFromBezierCurveFrames(t1,value.z,value.w);}return 0.;}float getIntegrateByTimeFromTime(float t0,float t1,vec4 value){float type=value.x;if(type==0.){return value.y*(t1*t1-t0*t0)/2.;}else if(type==1.){vec2 p0=vec2(0.,value.y);vec2 p1=vec2(value.w,value.z);return integrateByTimeLineSeg(t1,p0,p1)-integrateByTimeLineSeg(t0,p0,p1);}if(type==3.){return integrateByTimeFromLineSeg(t1,value.y,value.z)-integrateByTimeFromLineSeg(t0,value.y,value.z);}if(type==4.){return mix(value.y,value.z,aSeed)*(t1*t1-t0*t0)/2.;}if(type==5.){return integrateFromBezierCurveFrames(t1,value.z,value.w)-integrateFromBezierCurveFrames(t0,value.z,value.w);}return 0.;}";
 
 var itemVert = "#version 300 es\nprecision highp float;\n#define SHADER_VERTEX 1\n#define SPRITE_SHADER 1\nin vec4 aPoint;in vec2 aIndex;uniform mat4 uMainData[MAX_ITEM_COUNT];uniform vec4 uTexParams[MAX_ITEM_COUNT];uniform vec4 uTexOffset[MAX_ITEM_COUNT];uniform mat4 effects_ObjectToWorld;uniform mat4 effects_MatrixInvV;uniform mat4 effects_MatrixVP;out vec4 vColor;out vec4 vTexCoord;\n#ifdef ADJUST_LAYER\nout vec2 vFeatherCoord;\n#endif\nout highp vec3 vParams;const float d2r=3.141592653589793/180.;\n#ifdef ENV_EDITOR\nuniform vec4 uEditorTransform;\n#endif\nvec4 filterMain(float t,vec4 position);\n#pragma FILTER_VERT\nvec3 rotateByQuat(vec3 a,vec4 quat){vec3 qvec=quat.xyz;vec3 uv=cross(qvec,a);vec3 uuv=cross(qvec,uv)*2.;return a+(uv*2.*quat.w+uuv);}void main(){int index=int(aIndex.x);vec4 texParams=uTexParams[index];mat4 mainData=uMainData[index];float life=mainData[1].z;if(life<0.||life>1.){gl_Position=vec4(3.,3.,3.,1.);}else{vec4 _pos=mainData[0];vec2 size=mainData[1].xy;vec3 point=rotateByQuat(vec3(aPoint.xy*size,0.),mainData[2]);vec4 pos=vec4(_pos.xyz,1.0);float renderMode=texParams.z;if(renderMode==0.){pos=effects_ObjectToWorld*pos;pos.xyz+=effects_MatrixInvV[0].xyz*point.x+effects_MatrixInvV[1].xyz*point.y;}else if(renderMode==1.){pos.xyz+=point;pos=effects_ObjectToWorld*pos;}else if(renderMode==2.){pos=effects_ObjectToWorld*pos;pos.xy+=point.xy;}else if(renderMode==3.){pos=effects_ObjectToWorld*pos;pos.xyz+=effects_MatrixInvV[0].xyz*point.x+effects_MatrixInvV[2].xyz*point.y;}gl_Position=effects_MatrixVP*pos;\n#ifdef ADJUST_LAYER\nvec4 filter_Position=filterMain(life,pos);\n#endif\ngl_PointSize=6.0;\n#ifdef ENV_EDITOR\ngl_Position=vec4(gl_Position.xy*uEditorTransform.xy+uEditorTransform.zw*gl_Position.w,gl_Position.zw);\n#ifdef ADJUST_LAYER\nfilter_Position=vec4(filter_Position.xy*uEditorTransform.xy+uEditorTransform.zw*filter_Position.w,filter_Position.zw);\n#endif\n#endif\n#ifdef ADJUST_LAYER\nvTexCoord=vec4(filter_Position.xy/filter_Position.w+1.,gl_Position.xy/gl_Position.w+1.)/2.;vFeatherCoord=aPoint.zw;\n#else\nvec4 texOffset=uTexOffset[index];vTexCoord=vec4(aPoint.zw*texOffset.zw+texOffset.xy,texParams.xy);\n#endif\nvColor=mainData[3];vParams=vec3(aIndex.y,texParams.y,texParams.x);}}";
 
-var item_define = "uniform mat4 uMainData[MAX_ITEM_COUNT];uniform vec4 uTexParams[MAX_ITEM_COUNT];uniform vec4 uTexOffset[MAX_ITEM_COUNT];";
-
 var itemFrag = "#version 300 es\nprecision highp float;\n#version 300 es\n#ifdef WEBGL2\n#define texture2D texture\n#define textureCube texture\n#define textureCubeLodEXT textureLod\nlayout(location=0)out vec4 fragColor;\n#else\n#define fragColor gl_FragColor\n#endif\nvec4 blendColor(vec4 color,vec4 vc,float mode){vec4 ret=color*vc;\n#ifdef PRE_MULTIPLY_ALPHA\nfloat alpha=vc.a;\n#else\nfloat alpha=ret.a;\n#endif\nif(mode==1.){ret.rgb*=alpha;}else if(mode==2.){ret.rgb*=alpha;ret.a=dot(ret.rgb,vec3(0.33333333));}else if(mode==3.){alpha=color.r*alpha;ret=vec4(vc.rgb*alpha,alpha);}return ret;}\n#define SPRITE_SHADER 1\nin vec4 vColor;in vec4 vTexCoord;in highp vec3 vParams;\n#ifdef ADJUST_LAYER\nuniform sampler2D uSamplerPre;vec4 filterMain(vec2 coord,sampler2D tex);in vec2 vFeatherCoord;uniform sampler2D uFeatherSampler;\n#endif\nuniform sampler2D uSampler0;uniform sampler2D uSampler1;uniform sampler2D uSampler2;uniform sampler2D uSampler3;uniform sampler2D uSampler4;uniform sampler2D uSampler5;uniform sampler2D uSampler6;uniform sampler2D uSampler7;\n#if MAX_FRAG_TEX == 16\nuniform sampler2D uSampler8;uniform sampler2D uSampler9;uniform sampler2D uSampler10;uniform sampler2D uSampler11;uniform sampler2D uSampler12;uniform sampler2D uSampler13;uniform sampler2D uSampler14;uniform sampler2D uSampler15;\n#endif\nvec4 texture2DbyIndex(float index,vec2 coord);\n#pragma FILTER_FRAG\n#ifndef WEBGL2\n#define round(a) floor(0.5+a)\n#endif\nvoid main(){vec4 color=vec4(0.);\n#ifdef ADJUST_LAYER\nvec2 featherCoord=abs(vFeatherCoord-vec2(0.5))/0.5;float cc=sqrt(max(featherCoord.x,featherCoord.y));float blend=vColor.a*texture2D(uFeatherSampler,vec2(cc,0.)).r;if(blend>=1.){color=filterMain(vTexCoord.xy,uSamplerPre);}else if(blend<=0.){color=texture2D(uSamplerPre,vTexCoord.zw);}else{color=mix(texture2D(uSamplerPre,vTexCoord.zw),filterMain(vTexCoord.xy,uSamplerPre),blend);}\n#else\nvec4 texColor=texture2DbyIndex(round(vParams.x),vTexCoord.xy);color=blendColor(texColor,vColor,round(vParams.y));if(vParams.z==0.&&color.a<0.04){discard;}\n#endif\ncolor.a=clamp(color.a,0.0,1.0);fragColor=color;}vec4 texture2DbyIndex(float index,vec2 coord){\n#ifndef ADJUST_LAYER\nif(index==0.){return texture2D(uSampler0,coord);}if(index==1.){return texture2D(uSampler1,coord);}if(index==2.){return texture2D(uSampler2,coord);}if(index==3.){return texture2D(uSampler3,coord);}if(index==4.){return texture2D(uSampler4,coord);}if(index==5.){return texture2D(uSampler5,coord);}if(index==6.){return texture2D(uSampler6,coord);}if(index==7.){return texture2D(uSampler7,coord);}\n#if MAX_FRAG_TEX == 16\nif(index==8.){return texture2D(uSampler8,coord);}if(index==9.){return texture2D(uSampler9,coord);}if(index==10.){return texture2D(uSampler10,coord);}if(index==11.){return texture2D(uSampler11,coord);}if(index==12.){return texture2D(uSampler12,coord);}if(index==13.){return texture2D(uSampler13,coord);}if(index==14.){return texture2D(uSampler14,coord);}if(index==15.){return texture2D(uSampler15,coord);}\n#endif\nreturn texture2D(uSampler0,coord);\n#else\nreturn vec4(0.);\n#endif\n}";
 
-var particleFrag = "#version 300 es\nprecision mediump float;\n#version 300 es\n#ifdef WEBGL2\n#define texture2D texture\n#define textureCube texture\n#define textureCubeLodEXT textureLod\nlayout(location=0)out vec4 fragColor;\n#else\n#define fragColor gl_FragColor\n#endif\nvec4 blendColor(vec4 color,vec4 vc,float mode){vec4 ret=color*vc;\n#ifdef PRE_MULTIPLY_ALPHA\nfloat alpha=vc.a;\n#else\nfloat alpha=ret.a;\n#endif\nif(mode==1.){ret.rgb*=alpha;}else if(mode==2.){ret.rgb*=alpha;ret.a=dot(ret.rgb,vec3(0.33333333));}else if(mode==3.){alpha=color.r*alpha;ret=vec4(vc.rgb*alpha,alpha);}return ret;}\n#define PATICLE_SHADER 1\nin float vLife;in vec2 vTexCoord;in vec4 vColor;uniform vec3 emissionColor;uniform float emissionIntensity;uniform sampler2D uMaskTex;uniform vec4 uColorParams;uniform vec2 uTexOffset;\n#ifdef COLOR_OVER_LIFETIME\nuniform sampler2D uColorOverLifetime;\n#endif\n#ifdef USE_SPRITE\nin vec4 vTexCoordBlend;\n#ifdef USE_FILTER\nuniform vec4 uFSprite;\n#endif\n#endif\nin float vSeed;\n#ifdef PREVIEW_BORDER\nuniform vec4 uPreviewColor;\n#endif\n#ifdef USE_SPRITE\nvec4 getTextureColor(sampler2D tex,vec2 texCoord){if(vTexCoordBlend.w>0.){return mix(texture2D(tex,texCoord),texture2D(tex,vTexCoordBlend.xy+texCoord),vTexCoordBlend.z);}return texture2D(tex,texCoord);}\n#else\n#define getTextureColor texture2D\n#endif\n#ifndef WEBGL2\n#define round(a) floor(0.5+a)\n#endif\n#ifdef PREVIEW_BORDER\nvoid main(){fragColor=uPreviewColor;}\n#else\n#pragma FILTER_FRAG\nvoid main(){vec4 color=vec4(1.0);vec4 tempColor=vColor;vec2 texOffset=uTexOffset;if(vLife<0.){discard;}\n#ifdef USE_FILTER\n#ifdef USE_SPRITE\ntexOffset=uTexOffset/uFSprite.xy;\n#endif\ncolor=filterMain(vTexCoord,uMaskTex);\n#else\nif(uColorParams.x>0.0){color=getTextureColor(uMaskTex,vTexCoord);}\n#endif\n#ifdef COLOR_OVER_LIFETIME\n#ifndef ENABLE_VERTEX_TEXTURE\ntempColor*=texture2D(uColorOverLifetime,vec2(vLife,0.));\n#endif\n#endif\ncolor=blendColor(color,tempColor,round(uColorParams.y));if(color.a<=0.01&&uColorParams.w>0.){float _at=texture2D(uMaskTex,vTexCoord+texOffset).a+texture2D(uMaskTex,vTexCoord+texOffset*-1.).a;if(_at<=0.02){discard;}}vec3 emission=emissionColor*pow(2.0,emissionIntensity);color=vec4(pow(pow(color.rgb,vec3(2.2))+emission,vec3(1.0/2.2)),color.a);fragColor=color;}\n#endif\n";
+var particleFrag = "#version 300 es\nprecision highp float;\n#version 300 es\n#ifdef WEBGL2\n#define texture2D texture\n#define textureCube texture\n#define textureCubeLodEXT textureLod\nlayout(location=0)out vec4 fragColor;\n#else\n#define fragColor gl_FragColor\n#endif\nvec4 blendColor(vec4 color,vec4 vc,float mode){vec4 ret=color*vc;\n#ifdef PRE_MULTIPLY_ALPHA\nfloat alpha=vc.a;\n#else\nfloat alpha=ret.a;\n#endif\nif(mode==1.){ret.rgb*=alpha;}else if(mode==2.){ret.rgb*=alpha;ret.a=dot(ret.rgb,vec3(0.33333333));}else if(mode==3.){alpha=color.r*alpha;ret=vec4(vc.rgb*alpha,alpha);}return ret;}\n#define PATICLE_SHADER 1\nin float vLife;in vec2 vTexCoord;in vec4 vColor;uniform vec3 emissionColor;uniform float emissionIntensity;uniform sampler2D uMaskTex;uniform vec4 uColorParams;uniform vec2 uTexOffset;\n#ifdef COLOR_OVER_LIFETIME\nuniform sampler2D uColorOverLifetime;\n#endif\n#ifdef USE_SPRITE\nin vec4 vTexCoordBlend;\n#ifdef USE_FILTER\nuniform vec4 uFSprite;\n#endif\n#endif\nin float vSeed;\n#ifdef PREVIEW_BORDER\nuniform vec4 uPreviewColor;\n#endif\n#ifdef USE_SPRITE\nvec4 getTextureColor(sampler2D tex,vec2 texCoord){if(vTexCoordBlend.w>0.){return mix(texture2D(tex,texCoord),texture2D(tex,vTexCoordBlend.xy+texCoord),vTexCoordBlend.z);}return texture2D(tex,texCoord);}\n#else\n#define getTextureColor texture2D\n#endif\n#ifndef WEBGL2\n#define round(a) floor(0.5+a)\n#endif\n#ifdef PREVIEW_BORDER\nvoid main(){fragColor=uPreviewColor;}\n#else\n#pragma FILTER_FRAG\nvoid main(){vec4 color=vec4(1.0);vec4 tempColor=vColor;vec2 texOffset=uTexOffset;if(vLife<0.){discard;}\n#ifdef USE_FILTER\n#ifdef USE_SPRITE\ntexOffset=uTexOffset/uFSprite.xy;\n#endif\ncolor=filterMain(vTexCoord,uMaskTex);\n#else\nif(uColorParams.x>0.0){color=getTextureColor(uMaskTex,vTexCoord);}\n#endif\n#ifdef COLOR_OVER_LIFETIME\n#ifndef ENABLE_VERTEX_TEXTURE\ntempColor*=texture2D(uColorOverLifetime,vec2(vLife,0.));\n#endif\n#endif\ncolor=blendColor(color,tempColor,round(uColorParams.y));if(color.a<=0.01&&uColorParams.w>0.){float _at=texture2D(uMaskTex,vTexCoord+texOffset).a+texture2D(uMaskTex,vTexCoord+texOffset*-1.).a;if(_at<=0.02){discard;}}vec3 emission=emissionColor*pow(2.0,emissionIntensity);color=vec4(pow(pow(color.rgb,vec3(2.2))+emission,vec3(1.0/2.2)),color.a);fragColor=color;}\n#endif\n";
 
-var particleVert = "#version 300 es\nprecision highp float;\n#define SHADER_VERTEX 1\n#define PATICLE_SHADER 1\n#version 300 es\n#ifdef WEBGL2\n#define texture2D texture\n#else\n#endif\n#ifdef SHADER_VERTEX\n#define CURVE_VALUE_TEXTURE uVCurveValueTexture\n#define CURVE_VALUE_ARRAY uVCurveValues\n#define CURVE_VALUE_COUNT VERT_CURVE_VALUE_COUNT\n#define FRAG_CURVE_VALUE_COUNT 0\n#else\n#define CURVE_VALUE_TEXTURE uFCurveValueTexture\n#define CURVE_VALUE_ARRAY uFCurveValues\n#define CURVE_VALUE_COUNT FRAG_CURVE_VALUE_COUNT\n#define VERT_CURVE_VALUE_COUNT 0\n#endif\n#if CURVE_VALUE_COUNT > 0\n#if LOOKUP_TEXTURE_CURVE\nuniform sampler2D CURVE_VALUE_TEXTURE;const float uCurveCount=1./float(CURVE_VALUE_COUNT);\n#define lookup_curve(i) texture2D(CURVE_VALUE_TEXTURE,vec2(float(i) * uCurveCount,0.))\n#else\nuniform vec4 CURVE_VALUE_ARRAY[CURVE_VALUE_COUNT];\n#define lookup_curve(i) CURVE_VALUE_ARRAY[i]\n#endif\n#else\n#define lookup_curve(i) vec4(0.)\n#endif\n#ifdef WEBGL2\n#define ITR_END (count + 1)\n#else\n#define ITR_END MAX_C\n#endif\n#ifdef SHADER_VERTEX\nin float aSeed;out float vSeed;\n#define NONE_CONST_INDEX 1\n#else\n#if LOOKUP_TEXTURE_CURVE\n#define NONE_CONST_INDEX 1\n#endif\n#endif\n#ifdef NONE_CONST_INDEX\n#ifdef SHADER_VERTEX\n#define MAX_C VERT_MAX_KEY_FRAME_COUNT\n#else\n#define MAX_C FRAG_MAX_KEY_FRAME_COUNT\n#endif\n#else\n#define MAX_C CURVE_VALUE_COUNT\n#endif\nfloat evaluateCurveFrames(float time,vec4 keyframe0,vec4 keyframe1){float dt=keyframe1.x-keyframe0.x;float m0=keyframe0.w*dt;float m1=keyframe1.z*dt;float t=(time-keyframe0.x)/dt;float t2=t*t;float t3=t2*t;return dot(vec4(dot(vec3(2.,-3.,1.),vec3(t3,t2,1.)),dot(vec3(1,-2.,1),vec3(t3,t2,t)),t3-t2,dot(vec2(-2,3),vec2(t3,t2))),vec4(keyframe0.y,m0,m1,keyframe1.y));}float valueFromCurveFrames(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);int end=start+count;for(int i=0;i<ITR_END;i++){\n#ifdef NONE_CONST_INDEX\nif(i==count){return lookup_curve(count).y;}vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);\n#else\nif(i<start){continue;}vec4 k0=lookup_curve(i);vec4 k1=lookup_curve(i+1);if(i==end){return k0.y;}\n#endif\nif(time>=k0.x&&time<=k1.x){return evaluateCurveFrames(time,k0,k1);}}return lookup_curve(0).y;}float evaluteLineSeg(float t,vec2 p0,vec2 p1){return p0.y+(p1.y-p0.y)*(t-p0.x)/(p1.x-p0.x);}float valueFromLineSegs(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);int end=start+count;for(int i=0;i<ITR_END;i++){\n#ifdef NONE_CONST_INDEX\nif(i>count){return lookup_curve(i).w;}\n#else\nif(i<start){continue;}if(i>end){return lookup_curve(i-2).w;}\n#endif\n#ifdef NONE_CONST_INDEX\nvec4 seg=lookup_curve(i+start);\n#else\nvec4 seg=lookup_curve(i);\n#endif\nvec2 p0=seg.xy;vec2 p1=seg.zw;if(time>=p0.x&&time<=p1.x){return evaluteLineSeg(time,p0,p1);}\n#ifdef NONE_CONST_INDEX\nvec2 p2=lookup_curve(i+start+1).xy;\n#else\nvec2 p2=lookup_curve(i+1).xy;\n#endif\nif(time>p1.x&&time<=p2.x){return evaluteLineSeg(time,p1,p2);}}return lookup_curve(0).y;}float getValueFromTime(float time,vec4 value){float type=value.x;if(type==0.){return value.y;}else if(type==1.){return mix(value.y,value.z,time/value.w);}if(type==2.){return valueFromCurveFrames(time,floor(value.y),floor(1./fract(value.y)+0.5))*value.w+value.z;}if(type==3.){return valueFromLineSegs(time,value.y,value.z);}if(type==4.){\n#ifdef SHADER_VERTEX\nfloat seed=aSeed;\n#else\nfloat seed=vSeed;\n#endif\nreturn mix(value.y,value.z,seed);}return 0.;}float integrateCurveFrames(float t1,vec4 k0,vec4 k1){float k=k1.x-k0.x;float m0=k0.w*k;float m1=k1.z*k;float t0=k0.x;float v0=k0.y;float v1=k1.y;float dt=t0-t1;float dt2=dt*dt;float dt3=dt2*dt;vec4 a=vec4(dt3*dt,dt3,dt2,dt)/vec4(4.*k*k*k,3.*k*k,2.*k,1.);vec4 b=vec4(m0+m1+2.*v0-2.*v1,2.*m0+m1+3.*v0-3.*v1,m0,-v0);return dot(a,b);}float integrateByTimeCurveFrames(float t1,vec4 k0,vec4 k1){float k=k1.x-k0.x;float m0=k0.w*k;float m1=k1.z*k;float t0=k0.x;float v0=k0.y;float v1=k1.y;float dt=t0-t1;float dt2=dt*dt;float dt3=dt2*dt;float k2=k*k;float k3=k2*k;vec4 a=vec4(-30.*k3,10.*k2,5.*k,3.)*vec4(dt,dt2,dt3,dt3*dt);vec4 b=vec4(v0,m0,2.*m0+m1+3.*v0-3.*v1,m0+m1+2.*v0-2.*v1)*vec4(t0+t1,t0+2.*t1,t0+3.*t1,t0+4.*t1);return dot(a,b)/60./k3;}float integrateByTimeFromCurveFrames(float t1,float frameStart,float frameCount){if(t1==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i==count){return ret;}vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);if(t1>k0.x&&t1<=k1.x){return ret+integrateByTimeCurveFrames(t1,k0,k1);}ret+=integrateByTimeCurveFrames(k1.x,k0,k1);}return ret;}float integrateFromCurveFrames(float time,float frameStart,float frameCount){if(time==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i==count){return ret;}vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);if(time>k0.x&&time<=k1.x){return ret+integrateCurveFrames(time,k0,k1);}ret+=integrateCurveFrames(k1.x,k0,k1);}return ret;}float integrateByTimeLineSeg(float t,vec2 p0,vec2 p1){float t0=p0.x;float t1=p1.x;float y0=p0.y;float y1=p1.y;vec4 tSqr=vec4(t,t,t0,t0);tSqr=tSqr*tSqr;vec4 a=vec4(2.*t,3.,-t0,3.)*tSqr;float t1y0=t1*y0;vec4 b=vec4(y0-y1,t0*y1-t1y0,2.*y0+y1,t1y0);float r=dot(a,b);return r/(t0-t1)*0.16666667;}float integrateLineSeg(float time,vec2 p0,vec2 p1){float h=time-p0.x;float y0=p0.y;return(y0+y0+(p1.y-y0)*h/(p1.x-p0.x))*h/2.;}float integrateFromLineSeg(float time,float frameStart,float frameCount){if(time==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i>count){return ret;}vec4 ks=lookup_curve(i+start);vec2 k0=ks.xy;vec2 k1=ks.zw;if(time>k0.x&&time<=k1.x){return ret+integrateLineSeg(time,k0,k1);}ret+=integrateLineSeg(k1.x,k0,k1);vec2 k2=lookup_curve(i+start+1).xy;if(time>k1.x&&time<=k2.x){return ret+integrateLineSeg(time,k1,k2);}ret+=integrateLineSeg(k2.x,k1,k2);}return ret;}float integrateByTimeFromLineSeg(float time,float frameStart,float frameCount){if(time==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i>count){return ret;}vec4 ks=lookup_curve(i+start);vec2 k0=ks.xy;vec2 k1=ks.zw;if(time>k0.x&&time<=k1.x){return ret+integrateByTimeLineSeg(time,k0,k1);}ret+=integrateByTimeLineSeg(k1.x,k0,k1);vec2 k2=lookup_curve(i+start+1).xy;if(time>k1.x&&time<=k2.x){return ret+integrateByTimeLineSeg(time,k1,k2);}ret+=integrateByTimeLineSeg(k2.x,k1,k2);}return ret;}float getIntegrateFromTime0(float t1,vec4 value){float type=value.x;if(type==0.){return value.y*t1;}else if(type==1.){vec2 p0=vec2(0.,value.y);vec2 p1=vec2(value.w,value.z);return integrateLineSeg(t1,p0,p1);}if(type==3.){return integrateFromLineSeg(t1,value.y,value.z);}if(type==2.){float idx=floor(value.y);float ilen=floor(1./fract(value.y)+0.5);float d=integrateFromCurveFrames(t1,idx,ilen);return d*value.w+value.z*t1;}if(type==4.){return mix(value.y,value.z,aSeed)*t1;}return 0.;}float getIntegrateByTimeFromTime(float t0,float t1,vec4 value){float type=value.x;if(type==0.){return value.y*(t1*t1-t0*t0)/2.;}else if(type==1.){vec2 p0=vec2(0.,value.y);vec2 p1=vec2(value.w,value.z);return integrateByTimeLineSeg(t1,p0,p1)-integrateByTimeLineSeg(t0,p0,p1);}if(type==2.){float idx=floor(value.y);float ilen=floor(1./fract(value.y)+0.5);float d=integrateByTimeFromCurveFrames(t1,idx,ilen)-integrateByTimeFromCurveFrames(t0,idx,ilen);return d*value.w+value.z*pow(t1-t0,2.)*0.5;}if(type==3.){return integrateByTimeFromLineSeg(t1,value.y,value.z)-integrateByTimeFromLineSeg(t0,value.y,value.z);}if(type==4.){return mix(value.y,value.z,aSeed)*(t1*t1-t0*t0)/2.;}return 0.;}const float d2r=3.141592653589793/180.;in vec3 aPos;in vec4 aOffset;in vec3 aVel;in vec3 aRot;in vec4 aColor;in vec3 aDirX;in vec3 aDirY;\n#ifdef USE_SPRITE\nin vec3 aSprite;uniform vec4 uSprite;struct UVDetail{vec2 uv0;vec3 uv1;};UVDetail getSpriteUV(vec2 uv,float lifeTime);out vec4 vTexCoordBlend;\n#endif\n#pragma EDITOR_VERT_DEFINE\n#ifdef FINAL_TARGET\nuniform vec3 uFinalTarget;uniform vec4 uForceCurve;\n#endif\nuniform mat4 effects_ObjectToWorld;uniform mat4 effects_MatrixV;uniform mat4 effects_MatrixVP;uniform vec4 uParams;uniform vec4 uAcceleration;uniform vec4 uGravityModifierValue;uniform vec4 uOpacityOverLifetimeValue;\n#ifdef ROT_X_LIFETIME\nuniform vec4 uRXByLifeTimeValue;\n#endif\n#ifdef ROT_Y_LIFETIME\nuniform vec4 uRYByLifeTimeValue;\n#endif\n#ifdef ROT_Z_LIFETIME\nuniform vec4 uRZByLifeTimeValue;\n#endif\n#ifdef COLOR_OVER_LIFETIME\nuniform sampler2D uColorOverLifetime;\n#endif\n#if LINEAR_VEL_X + LINEAR_VEL_Y + LINEAR_VEL_Z\n#if LINEAR_VEL_X\nuniform vec4 uLinearXByLifetimeValue;\n#endif\n#if LINEAR_VEL_Y\nuniform vec4 uLinearYByLifetimeValue;\n#endif\n#if LINEAR_VEL_Z\nuniform vec4 uLinearZByLifetimeValue;\n#endif\n#endif\n#ifdef SPEED_OVER_LIFETIME\nuniform vec4 uSpeedLifetimeValue;\n#endif\n#if ORB_VEL_X + ORB_VEL_Y + ORB_VEL_Z\n#if ORB_VEL_X\nuniform vec4 uOrbXByLifetimeValue;\n#endif\n#if ORB_VEL_Y\nuniform vec4 uOrbYByLifetimeValue;\n#endif\n#if ORB_VEL_Z\nuniform vec4 uOrbZByLifetimeValue;\n#endif\nuniform vec3 uOrbCenter;\n#endif\nuniform vec4 uSizeByLifetimeValue;\n#ifdef SIZE_Y_BY_LIFE\nuniform vec4 uSizeYByLifetimeValue;\n#endif\nout float vLife;out vec4 vColor;out vec2 vTexCoord;\n#ifdef USE_FILTER\n#pragma FILTER_VERT\n#endif\n#ifdef ENV_EDITOR\nuniform vec4 uEditorTransform;\n#endif\nvec3 calOrbitalMov(float _life,float _dur){vec3 orb=vec3(0.0);\n#ifdef AS_ORBITAL_MOVEMENT\n#define FUNC(a) getValueFromTime(_life,a)\n#else\n#define FUNC(a) getIntegrateFromTime0(_life,a) * _dur\n#endif\n#if ORB_VEL_X\norb.x=FUNC(uOrbXByLifetimeValue);\n#endif\n#if ORB_VEL_Y\norb.y=FUNC(uOrbYByLifetimeValue);\n#endif\n#if ORB_VEL_Z\norb.z=FUNC(uOrbZByLifetimeValue);\n#endif\n#undef FUNC\nreturn orb;}vec3 calLinearMov(float _life,float _dur){vec3 mov=vec3(0.0);\n#ifdef AS_LINEAR_MOVEMENT\n#define FUNC(a) getValueFromTime(_life,a)\n#else\n#define FUNC(a) getIntegrateFromTime0(_life,a) * _dur\n#endif\n#if LINEAR_VEL_X\nmov.x=FUNC(uLinearXByLifetimeValue);\n#endif\n#if LINEAR_VEL_Y\nmov.y=FUNC(uLinearYByLifetimeValue);\n#endif\n#if LINEAR_VEL_Z\nmov.z=FUNC(uLinearZByLifetimeValue);\n#endif\n#undef FUNC\nreturn mov;}mat3 mat3FromRotation(vec3 rotation){vec3 sinR=sin(rotation*d2r);vec3 cosR=cos(rotation*d2r);return mat3(cosR.z,-sinR.z,0.,sinR.z,cosR.z,0.,0.,0.,1.)*mat3(cosR.y,0.,sinR.y,0.,1.,0.,-sinR.y,0,cosR.y)*mat3(1.,0.,0.,0,cosR.x,-sinR.x,0.,sinR.x,cosR.x);}\n#ifdef USE_SPRITE\nUVDetail getSpriteUV(vec2 uv,float lifeTime){float t=fract(clamp((lifeTime-aSprite.x)/aSprite.y,0.0,1.)*aSprite.z);float frame=uSprite.z*t;float frameIndex=max(ceil(frame)-1.,0.);float row=floor((frameIndex+0.1)/uSprite.x);float col=frameIndex-row*uSprite.x;vec2 retUV=(vec2(col,row)+uv)/uSprite.xy;UVDetail ret;if(uSprite.w>0.){float blend=frame-frameIndex;float frameIndex1=min(ceil(frame),uSprite.z-1.);float row1=floor((frameIndex1+0.1)/uSprite.x);float col1=frameIndex1-row1*uSprite.x;vec2 coord=(vec2(col1,row1)+uv)/uSprite.xy-retUV;ret.uv1=vec3(coord.x,1.-coord.y,blend);}ret.uv0=vec2(retUV.x,1.-retUV.y);return ret;}\n#endif\nvec3 calculateTranslation(vec3 vel,float t0,float t1,float dur){float dt=t1-t0;float d=getIntegrateByTimeFromTime(0.,dt,uGravityModifierValue);vec3 acc=uAcceleration.xyz*d;\n#ifdef SPEED_OVER_LIFETIME\nreturn vel*getIntegrateFromTime0(dt/dur,uSpeedLifetimeValue)*dur+acc;\n#endif\nreturn vel*dt+acc;}mat3 transformFromRotation(vec3 rot,float _life,float _dur){vec3 rotation=rot;\n#ifdef ROT_LIFETIME_AS_MOVEMENT\n#define FUNC1(a) getValueFromTime(_life,a)\n#else\n#define FUNC1(a) getIntegrateFromTime0(_life,a) * _dur\n#endif\n#ifdef ROT_X_LIFETIME\nrotation.x+=FUNC1(uRXByLifeTimeValue);\n#endif\n#ifdef ROT_Y_LIFETIME\nrotation.y+=FUNC1(uRYByLifeTimeValue);\n#endif\n#ifdef ROT_Z_LIFETIME\nrotation.z+=FUNC1(uRZByLifeTimeValue);\n#endif\nif(dot(rotation,rotation)==0.0){return mat3(1.0);}\n#undef FUNC1\nreturn mat3FromRotation(rotation);}void main(){float time=uParams.x-aOffset.z;float dur=aOffset.w;if(time<0.||time>dur){gl_Position=vec4(-3.,-3.,-3.,1.);}else{float life=clamp(time/dur,0.0,1.0);vLife=life;\n#ifdef USE_SPRITE\nUVDetail uvD=getSpriteUV(aOffset.xy,time);vTexCoord=uvD.uv0;vTexCoordBlend=vec4(uvD.uv1,uSprite.w);\n#else\nvTexCoord=aOffset.xy;\n#endif\nvColor=aColor;\n#ifdef COLOR_OVER_LIFETIME\n#ifdef ENABLE_VERTEX_TEXTURE\nvColor*=texture2D(uColorOverLifetime,vec2(life,0.));\n#endif\n#endif\nvColor.a*=clamp(getValueFromTime(life,uOpacityOverLifetimeValue),0.,1.);vec3 size=vec3(vec2(getValueFromTime(life,uSizeByLifetimeValue)),1.0);\n#ifdef SIZE_Y_BY_LIFE\nsize.y=getValueFromTime(life,uSizeYByLifetimeValue);\n#endif\nvec3 point=transformFromRotation(aRot,life,dur)*(aDirX*size.x+aDirY*size.y);vec3 pt=calculateTranslation(aVel,aOffset.z,uParams.x,dur);vec3 _pos=aPos+pt;\n#if ORB_VEL_X + ORB_VEL_Y + ORB_VEL_Z\n_pos=mat3FromRotation(calOrbitalMov(life,dur))*(_pos-uOrbCenter);_pos+=uOrbCenter;\n#endif\n#if LINEAR_VEL_X + LINEAR_VEL_Y + LINEAR_VEL_Z\n_pos.xyz+=calLinearMov(life,dur);\n#endif\n#ifdef FINAL_TARGET\nfloat force=getValueFromTime(life,uForceCurve);vec4 pos=vec4(mix(_pos,uFinalTarget,force),1.);\n#else\nvec4 pos=vec4(_pos,1.0);\n#endif\n#if RENDER_MODE == 1\npos.xyz+=point;pos=effects_ObjectToWorld*pos;\n#elif RENDER_MODE == 3\npos=effects_ObjectToWorld*pos;pos.xyz+=effects_MatrixV[0].xyz*point.x+effects_MatrixV[2].xyz*point.y;\n#elif RENDER_MODE == 2\npos=effects_ObjectToWorld*pos;pos.xy+=point.xy;\n#elif RENDER_MODE == 0\npos=effects_ObjectToWorld*pos;pos.xyz+=effects_MatrixV[0].xyz*point.x+effects_MatrixV[1].xyz*point.y;\n#endif\ngl_Position=effects_MatrixVP*pos;vSeed=aSeed;gl_PointSize=6.0;\n#ifdef USE_FILTER\nfilterMain(life);\n#endif\n#ifdef ENV_EDITOR\ngl_Position=vec4(gl_Position.xy*uEditorTransform.xy+uEditorTransform.zw*gl_Position.w,gl_Position.zw);\n#endif\n#pragma EDITOR_VERT_TRANSFORM\n}}";
+var particleVert = "#version 300 es\nprecision mediump float;\n#define SHADER_VERTEX 1\n#define PATICLE_SHADER 1\n#version 300 es\n#ifdef WEBGL2\n#define texture2D texture\n#else\n#endif\n#ifdef SHADER_VERTEX\n#define CURVE_VALUE_TEXTURE uVCurveValueTexture\n#define CURVE_VALUE_ARRAY uVCurveValues\n#define CURVE_VALUE_COUNT VERT_CURVE_VALUE_COUNT\n#define FRAG_CURVE_VALUE_COUNT 0\n#else\n#define CURVE_VALUE_TEXTURE uFCurveValueTexture\n#define CURVE_VALUE_ARRAY uFCurveValues\n#define CURVE_VALUE_COUNT FRAG_CURVE_VALUE_COUNT\n#define VERT_CURVE_VALUE_COUNT 0\n#endif\n#if CURVE_VALUE_COUNT > 0\n#if LOOKUP_TEXTURE_CURVE\nuniform sampler2D CURVE_VALUE_TEXTURE;const float uCurveCount=1./float(CURVE_VALUE_COUNT);\n#define lookup_curve(i) texture2D(CURVE_VALUE_TEXTURE,vec2(float(i) * uCurveCount,0.))\n#else\nuniform vec4 CURVE_VALUE_ARRAY[CURVE_VALUE_COUNT];\n#define lookup_curve(i) CURVE_VALUE_ARRAY[i]\n#endif\n#else\n#define lookup_curve(i) vec4(0.)\n#endif\n#ifdef WEBGL2\n#define ITR_END (count + 1)\n#else\n#define ITR_END MAX_C\n#endif\n#define NONE_CONST_INDEX 1\n#ifdef SHADER_VERTEX\nin float aSeed;out float vSeed;\n#endif\n#ifdef SHADER_VERTEX\n#define MAX_C VERT_MAX_KEY_FRAME_COUNT\n#else\n#define MAX_C FRAG_MAX_KEY_FRAME_COUNT\n#endif\nmat4 cubicBezierMatrix=mat4(1.0,-3.0,3.0,-1.0,0.0,3.0,-6.0,3.0,0.0,0.0,3.0,-3.0,0.0,0.0,0.0,1.0);float cubicBezier(float t,float y1,float y2,float y3,float y4){vec4 tVec=vec4(1.0,t,t*t,t*t*t);vec4 yVec=vec4(y1,y2,y3,y4);vec4 result=tVec*cubicBezierMatrix*yVec;return result.x+result.y+result.z+result.w;}float binarySearchT(float x,float x1,float x2,float x3,float x4){float left=0.0;float right=1.0;float mid=0.0;float computedX;for(int i=0;i<12;i++){mid=(left+right)*0.5;computedX=cubicBezier(mid,x1,x2,x3,x4);if(abs(computedX-x)<0.0001){break;}else if(computedX>x){right=mid;}else{left=mid;}}return mid;}float valueFromBezierCurveFrames(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);for(int i=0;i<ITR_END;i+=2){if(i>=count){break;}vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);if(i==0&&time<k0.x){return k0.y;}if(i==int(frameCount-2.)&&time>=k1.x){return k1.y;}if(time>=k0.x&&time<=k1.x){float t=(time-k0.x)/(k1.x-k0.x);float nt=binarySearchT(time,k0.x,k0.z,k1.z,k1.x);return cubicBezier(nt,k0.y,k0.w,k1.w,k1.y);}}}float evaluteLineSeg(float t,vec2 p0,vec2 p1){return p0.y+(p1.y-p0.y)*(t-p0.x)/(p1.x-p0.x);}float valueFromLineSegs(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);int end=start+count;for(int i=0;i<ITR_END;i++){if(i>count){return lookup_curve(i).w;}vec4 seg=lookup_curve(i+start);vec2 p0=seg.xy;vec2 p1=seg.zw;if(time>=p0.x&&time<=p1.x){return evaluteLineSeg(time,p0,p1);}vec2 p2=lookup_curve(i+start+1).xy;if(time>p1.x&&time<=p2.x){return evaluteLineSeg(time,p1,p2);}}return lookup_curve(0).y;}float getValueFromTime(float time,vec4 value){float type=value.x;if(type==0.){return value.y;}if(type==1.){return mix(value.y,value.z,time/value.w);}if(type==3.){return valueFromLineSegs(time,value.y,value.z);}if(type==4.){return mix(value.y,value.z,aSeed);}if(type==5.){return valueFromBezierCurveFrames(time,value.z,value.w);}return 0.;}float calculateMovement(float t,vec2 p1,vec2 p2,vec2 p3,vec2 p4){float movement=0.0;float h=(t-p1.x)*0.1;float delta=1./(p4.x-p1.x);for(int i=0;i<=10;i++){float t=float(i)*h*delta;float nt=binarySearchT(t,p1.x,p2.x,p3.x,p4.x);float y=cubicBezier(nt,p1.y,p2.y,p3.y,p4.y);float weight=(i==0||i==10)? 1.0 :(mod(float(i),2.)!=0.)? 4.0 : 2.0;movement+=weight*y;}movement*=h/3.;return movement;}float integrateFromBezierCurveFrames(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i+=2){vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);if(i==0&&time<k0.x){return ret;}vec2 p1=vec2(k0.x,k0.y);vec2 p2=vec2(k0.z,k0.w);vec2 p3=vec2(k1.z,k1.w);vec2 p4=vec2(k1.x,k1.y);if(time>=k1.x){ret+=calculateMovement(k1.x,p1,p2,p3,p4);}if(time>=k0.x&&time<k1.x){return ret+calculateMovement(time,p1,p2,p3,p4);}}return ret;}float integrateByTimeLineSeg(float t,vec2 p0,vec2 p1){float t0=p0.x;float t1=p1.x;float y0=p0.y;float y1=p1.y;vec4 tSqr=vec4(t,t,t0,t0);tSqr=tSqr*tSqr;vec4 a=vec4(2.*t,3.,-t0,3.)*tSqr;float t1y0=t1*y0;vec4 b=vec4(y0-y1,t0*y1-t1y0,2.*y0+y1,t1y0);float r=dot(a,b);return r/(t0-t1)*0.16666667;}float integrateLineSeg(float time,vec2 p0,vec2 p1){float h=time-p0.x;float y0=p0.y;return(y0+y0+(p1.y-y0)*h/(p1.x-p0.x))*h/2.;}float integrateFromLineSeg(float time,float frameStart,float frameCount){if(time==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i>count){return ret;}vec4 ks=lookup_curve(i+start);vec2 k0=ks.xy;vec2 k1=ks.zw;if(time>k0.x&&time<=k1.x){return ret+integrateLineSeg(time,k0,k1);}ret+=integrateLineSeg(k1.x,k0,k1);vec2 k2=lookup_curve(i+start+1).xy;if(time>k1.x&&time<=k2.x){return ret+integrateLineSeg(time,k1,k2);}ret+=integrateLineSeg(k2.x,k1,k2);}return ret;}float integrateByTimeFromLineSeg(float time,float frameStart,float frameCount){if(time==0.){return 0.;}int start=int(frameStart);int count=int(frameCount-1.);float ret=0.;for(int i=0;i<ITR_END;i++){if(i>count){return ret;}vec4 ks=lookup_curve(i+start);vec2 k0=ks.xy;vec2 k1=ks.zw;if(time>k0.x&&time<=k1.x){return ret+integrateByTimeLineSeg(time,k0,k1);}ret+=integrateByTimeLineSeg(k1.x,k0,k1);vec2 k2=lookup_curve(i+start+1).xy;if(time>k1.x&&time<=k2.x){return ret+integrateByTimeLineSeg(time,k1,k2);}ret+=integrateByTimeLineSeg(k2.x,k1,k2);}return ret;}float getIntegrateFromTime0(float t1,vec4 value){float type=value.x;if(type==0.){return value.y*t1;}else if(type==1.){vec2 p0=vec2(0.,value.y);vec2 p1=vec2(value.w,value.z);return integrateLineSeg(t1,p0,p1);}if(type==3.){return integrateFromLineSeg(t1,value.y,value.z);}if(type==4.){return mix(value.y,value.z,aSeed)*t1;}if(type==5.){return integrateFromBezierCurveFrames(t1,value.z,value.w);}return 0.;}float getIntegrateByTimeFromTime(float t0,float t1,vec4 value){float type=value.x;if(type==0.){return value.y*(t1*t1-t0*t0)/2.;}else if(type==1.){vec2 p0=vec2(0.,value.y);vec2 p1=vec2(value.w,value.z);return integrateByTimeLineSeg(t1,p0,p1)-integrateByTimeLineSeg(t0,p0,p1);}if(type==3.){return integrateByTimeFromLineSeg(t1,value.y,value.z)-integrateByTimeFromLineSeg(t0,value.y,value.z);}if(type==4.){return mix(value.y,value.z,aSeed)*(t1*t1-t0*t0)/2.;}if(type==5.){return integrateFromBezierCurveFrames(t1,value.z,value.w)-integrateFromBezierCurveFrames(t0,value.z,value.w);}return 0.;}const float d2r=3.141592653589793/180.;in vec3 aPos;in vec4 aOffset;in vec3 aVel;in vec3 aRot;in vec4 aColor;in vec3 aDirX;in vec3 aDirY;\n#ifdef USE_SPRITE\nin vec3 aSprite;uniform vec4 uSprite;struct UVDetail{vec2 uv0;vec3 uv1;};UVDetail getSpriteUV(vec2 uv,float lifeTime);out vec4 vTexCoordBlend;\n#endif\n#ifdef FINAL_TARGET\nuniform vec3 uFinalTarget;uniform vec4 uForceCurve;\n#endif\nuniform mat4 effects_ObjectToWorld;uniform mat4 effects_MatrixV;uniform mat4 effects_MatrixVP;uniform vec4 uParams;uniform vec4 uAcceleration;uniform vec4 uGravityModifierValue;uniform vec4 uOpacityOverLifetimeValue;\n#ifdef ROT_X_LIFETIME\nuniform vec4 uRXByLifeTimeValue;\n#endif\n#ifdef ROT_Y_LIFETIME\nuniform vec4 uRYByLifeTimeValue;\n#endif\n#ifdef ROT_Z_LIFETIME\nuniform vec4 uRZByLifeTimeValue;\n#endif\n#ifdef COLOR_OVER_LIFETIME\nuniform sampler2D uColorOverLifetime;\n#endif\n#if LINEAR_VEL_X + LINEAR_VEL_Y + LINEAR_VEL_Z\n#if LINEAR_VEL_X\nuniform vec4 uLinearXByLifetimeValue;\n#endif\n#if LINEAR_VEL_Y\nuniform vec4 uLinearYByLifetimeValue;\n#endif\n#if LINEAR_VEL_Z\nuniform vec4 uLinearZByLifetimeValue;\n#endif\n#endif\n#ifdef SPEED_OVER_LIFETIME\nuniform vec4 uSpeedLifetimeValue;\n#endif\n#if ORB_VEL_X + ORB_VEL_Y + ORB_VEL_Z\n#if ORB_VEL_X\nuniform vec4 uOrbXByLifetimeValue;\n#endif\n#if ORB_VEL_Y\nuniform vec4 uOrbYByLifetimeValue;\n#endif\n#if ORB_VEL_Z\nuniform vec4 uOrbZByLifetimeValue;\n#endif\nuniform vec3 uOrbCenter;\n#endif\nuniform vec4 uSizeByLifetimeValue;\n#ifdef SIZE_Y_BY_LIFE\nuniform vec4 uSizeYByLifetimeValue;\n#endif\nout float vLife;out vec4 vColor;out vec2 vTexCoord;\n#ifdef USE_FILTER\n#pragma FILTER_VERT\n#endif\n#ifdef ENV_EDITOR\nuniform vec4 uEditorTransform;\n#endif\nvec3 calOrbitalMov(float _life,float _dur){vec3 orb=vec3(0.0);\n#ifdef AS_ORBITAL_MOVEMENT\n#define FUNC(a) getValueFromTime(_life,a)\n#else\n#define FUNC(a) getIntegrateFromTime0(_life,a) * _dur\n#endif\n#if ORB_VEL_X\norb.x=FUNC(uOrbXByLifetimeValue);\n#endif\n#if ORB_VEL_Y\norb.y=FUNC(uOrbYByLifetimeValue);\n#endif\n#if ORB_VEL_Z\norb.z=FUNC(uOrbZByLifetimeValue);\n#endif\n#undef FUNC\nreturn orb;}vec3 calLinearMov(float _life,float _dur){vec3 mov=vec3(0.0);\n#ifdef AS_LINEAR_MOVEMENT\n#define FUNC(a) getValueFromTime(_life,a)\n#else\n#define FUNC(a) getIntegrateFromTime0(_life,a) * _dur\n#endif\n#if LINEAR_VEL_X\nmov.x=FUNC(uLinearXByLifetimeValue);\n#endif\n#if LINEAR_VEL_Y\nmov.y=FUNC(uLinearYByLifetimeValue);\n#endif\n#if LINEAR_VEL_Z\nmov.z=FUNC(uLinearZByLifetimeValue);\n#endif\n#undef FUNC\nreturn mov;}mat3 mat3FromRotation(vec3 rotation){vec3 sinR=sin(rotation*d2r);vec3 cosR=cos(rotation*d2r);return mat3(cosR.z,-sinR.z,0.,sinR.z,cosR.z,0.,0.,0.,1.)*mat3(cosR.y,0.,sinR.y,0.,1.,0.,-sinR.y,0,cosR.y)*mat3(1.,0.,0.,0,cosR.x,-sinR.x,0.,sinR.x,cosR.x);}\n#ifdef USE_SPRITE\nUVDetail getSpriteUV(vec2 uv,float lifeTime){float t=fract(clamp((lifeTime-aSprite.x)/aSprite.y,0.0,1.)*aSprite.z);float frame=uSprite.z*t;float frameIndex=max(ceil(frame)-1.,0.);float row=floor((frameIndex+0.1f)/uSprite.x);float col=frameIndex-row*uSprite.x;vec2 retUV=(vec2(col,row)+uv)/uSprite.xy;UVDetail ret;if(uSprite.w>0.){float blend=frame-frameIndex;float frameIndex1=min(ceil(frame),uSprite.z-1.);float row1=floor((frameIndex1+0.1f)/uSprite.x);float col1=frameIndex1-row1*uSprite.x;vec2 coord=(vec2(col1,row1)+uv)/uSprite.xy-retUV;ret.uv1=vec3(coord.x,1.-coord.y,blend);}ret.uv0=vec2(retUV.x,1.-retUV.y);return ret;}\n#endif\nvec3 calculateTranslation(vec3 vel,float t0,float t1,float dur){float dt=t1-t0;float d=getIntegrateByTimeFromTime(0.,dt,uGravityModifierValue);vec3 acc=uAcceleration.xyz*d;\n#ifdef SPEED_OVER_LIFETIME\nreturn vel*getIntegrateFromTime0(dt/dur,uSpeedLifetimeValue)*dur+acc;\n#endif\nreturn vel*dt+acc;}mat3 transformFromRotation(vec3 rot,float _life,float _dur){vec3 rotation=rot;\n#ifdef ROT_LIFETIME_AS_MOVEMENT\n#define FUNC1(a) getValueFromTime(_life,a)\n#else\n#define FUNC1(a) getIntegrateFromTime0(_life,a) * _dur\n#endif\n#ifdef ROT_X_LIFETIME\nrotation.x+=FUNC1(uRXByLifeTimeValue);\n#endif\n#ifdef ROT_Y_LIFETIME\nrotation.y+=FUNC1(uRYByLifeTimeValue);\n#endif\n#ifdef ROT_Z_LIFETIME\nrotation.z+=FUNC1(uRZByLifeTimeValue);\n#endif\nif(dot(rotation,rotation)==0.0){return mat3(1.0);}\n#undef FUNC1\nreturn mat3FromRotation(rotation);}void main(){float time=uParams.x-aOffset.z;float dur=aOffset.w;if(time<0.||time>dur){gl_Position=vec4(-3.,-3.,-3.,1.);}else{float life=clamp(time/dur,0.0,1.0);vLife=life;\n#ifdef USE_SPRITE\nUVDetail uvD=getSpriteUV(aOffset.xy,time);vTexCoord=uvD.uv0;vTexCoordBlend=vec4(uvD.uv1,uSprite.w);\n#else\nvTexCoord=aOffset.xy;\n#endif\nvColor=aColor;\n#ifdef COLOR_OVER_LIFETIME\n#ifdef ENABLE_VERTEX_TEXTURE\nvColor*=texture2D(uColorOverLifetime,vec2(life,0.));\n#endif\n#endif\nvColor.a*=clamp(getValueFromTime(life,uOpacityOverLifetimeValue),0.,1.);vec3 size=vec3(vec2(getValueFromTime(life,uSizeByLifetimeValue)),1.0);\n#ifdef SIZE_Y_BY_LIFE\nsize.y=getValueFromTime(life,uSizeYByLifetimeValue);\n#endif\nvec3 point=transformFromRotation(aRot,life,dur)*(aDirX*size.x+aDirY*size.y);vec3 pt=calculateTranslation(aVel,aOffset.z,uParams.x,dur);vec3 _pos=aPos+pt;\n#if ORB_VEL_X + ORB_VEL_Y + ORB_VEL_Z\n_pos=mat3FromRotation(calOrbitalMov(life,dur))*(_pos-uOrbCenter);_pos+=uOrbCenter;\n#endif\n#if LINEAR_VEL_X + LINEAR_VEL_Y + LINEAR_VEL_Z\n_pos.xyz+=calLinearMov(life,dur);\n#endif\n#ifdef FINAL_TARGET\nfloat force=getValueFromTime(life,uForceCurve);vec4 pos=vec4(mix(_pos,uFinalTarget,force),1.);\n#else\nvec4 pos=vec4(_pos,1.0);\n#endif\n#if RENDER_MODE == 1\npos.xyz+=point;pos=effects_ObjectToWorld*pos;\n#elif RENDER_MODE == 3\npos=effects_ObjectToWorld*pos;pos.xyz+=effects_MatrixV[0].xyz*point.x+effects_MatrixV[2].xyz*point.y;\n#elif RENDER_MODE == 2\npos=effects_ObjectToWorld*pos;pos.xy+=point.xy;\n#elif RENDER_MODE == 0\npos=effects_ObjectToWorld*pos;pos.xyz+=effects_MatrixV[0].xyz*point.x+effects_MatrixV[1].xyz*point.y;\n#endif\ngl_Position=effects_MatrixVP*pos;vSeed=aSeed;gl_PointSize=6.0;\n#ifdef USE_FILTER\nfilterMain(life);\n#endif\n#ifdef ENV_EDITOR\ngl_Position=vec4(gl_Position.xy*uEditorTransform.xy+uEditorTransform.zw*gl_Position.w,gl_Position.zw);\n#endif\n}}";
 
-var trailVert = "#version 300 es\nprecision mediump float;\n#define SHADER_VERTEX 1\n#version 300 es\n#ifdef WEBGL2\n#define texture2D texture\n#else\n#endif\n#ifdef SHADER_VERTEX\n#define CURVE_VALUE_TEXTURE uVCurveValueTexture\n#define CURVE_VALUE_ARRAY uVCurveValues\n#define CURVE_VALUE_COUNT VERT_CURVE_VALUE_COUNT\n#define FRAG_CURVE_VALUE_COUNT 0\n#else\n#define CURVE_VALUE_TEXTURE uFCurveValueTexture\n#define CURVE_VALUE_ARRAY uFCurveValues\n#define CURVE_VALUE_COUNT FRAG_CURVE_VALUE_COUNT\n#define VERT_CURVE_VALUE_COUNT 0\n#endif\n#if CURVE_VALUE_COUNT > 0\n#if LOOKUP_TEXTURE_CURVE\nuniform sampler2D CURVE_VALUE_TEXTURE;const float uCurveCount=1./float(CURVE_VALUE_COUNT);\n#define lookup_curve(i) texture2D(CURVE_VALUE_TEXTURE,vec2(float(i) * uCurveCount,0.))\n#else\nuniform vec4 CURVE_VALUE_ARRAY[CURVE_VALUE_COUNT];\n#define lookup_curve(i) CURVE_VALUE_ARRAY[i]\n#endif\n#else\n#define lookup_curve(i) vec4(0.)\n#endif\n#ifdef WEBGL2\n#define ITR_END (count + 1)\n#else\n#define ITR_END MAX_C\n#endif\n#ifdef SHADER_VERTEX\nin float aSeed;out float vSeed;\n#define NONE_CONST_INDEX 1\n#else\n#if LOOKUP_TEXTURE_CURVE\n#define NONE_CONST_INDEX 1\n#endif\n#endif\n#ifdef NONE_CONST_INDEX\n#ifdef SHADER_VERTEX\n#define MAX_C VERT_MAX_KEY_FRAME_COUNT\n#else\n#define MAX_C FRAG_MAX_KEY_FRAME_COUNT\n#endif\n#else\n#define MAX_C CURVE_VALUE_COUNT\n#endif\nfloat evaluateCurveFrames(float time,vec4 keyframe0,vec4 keyframe1){float dt=keyframe1.x-keyframe0.x;float m0=keyframe0.w*dt;float m1=keyframe1.z*dt;float t=(time-keyframe0.x)/dt;float t2=t*t;float t3=t2*t;return dot(vec4(dot(vec3(2.,-3.,1.),vec3(t3,t2,1.)),dot(vec3(1,-2.,1),vec3(t3,t2,t)),t3-t2,dot(vec2(-2,3),vec2(t3,t2))),vec4(keyframe0.y,m0,m1,keyframe1.y));}float valueFromCurveFrames(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);int end=start+count;for(int i=0;i<ITR_END;i++){\n#ifdef NONE_CONST_INDEX\nif(i==count){return lookup_curve(count).y;}vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);\n#else\nif(i<start){continue;}vec4 k0=lookup_curve(i);vec4 k1=lookup_curve(i+1);if(i==end){return k0.y;}\n#endif\nif(time>=k0.x&&time<=k1.x){return evaluateCurveFrames(time,k0,k1);}}return lookup_curve(0).y;}float evaluteLineSeg(float t,vec2 p0,vec2 p1){return p0.y+(p1.y-p0.y)*(t-p0.x)/(p1.x-p0.x);}float valueFromLineSegs(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);int end=start+count;for(int i=0;i<ITR_END;i++){\n#ifdef NONE_CONST_INDEX\nif(i>count){return lookup_curve(i).w;}\n#else\nif(i<start){continue;}if(i>end){return lookup_curve(i-2).w;}\n#endif\n#ifdef NONE_CONST_INDEX\nvec4 seg=lookup_curve(i+start);\n#else\nvec4 seg=lookup_curve(i);\n#endif\nvec2 p0=seg.xy;vec2 p1=seg.zw;if(time>=p0.x&&time<=p1.x){return evaluteLineSeg(time,p0,p1);}\n#ifdef NONE_CONST_INDEX\nvec2 p2=lookup_curve(i+start+1).xy;\n#else\nvec2 p2=lookup_curve(i+1).xy;\n#endif\nif(time>p1.x&&time<=p2.x){return evaluteLineSeg(time,p1,p2);}}return lookup_curve(0).y;}float getValueFromTime(float time,vec4 value){float type=value.x;if(type==0.){return value.y;}else if(type==1.){return mix(value.y,value.z,time/value.w);}if(type==2.){return valueFromCurveFrames(time,floor(value.y),floor(1./fract(value.y)+0.5))*value.w+value.z;}if(type==3.){return valueFromLineSegs(time,value.y,value.z);}if(type==4.){\n#ifdef SHADER_VERTEX\nfloat seed=aSeed;\n#else\nfloat seed=vSeed;\n#endif\nreturn mix(value.y,value.z,seed);}return 0.;}in vec4 aPos;in vec3 aDir;in vec3 aInfo;in vec4 aColor;in float aTime;\n#ifdef ATTR_TRAIL_START\nin float aTrailStart;\n#else\nuniform float uTrailStart[64];in float aTrailStartIndex;\n#endif\nuniform mat4 effects_MatrixInvV;uniform mat4 effects_ObjectToWorld;uniform mat4 effects_MatrixVP;uniform vec4 uTextureMap;uniform float uTime;uniform vec4 uParams;uniform vec4 uColorParams;uniform vec4 uOpacityOverLifetimeValue;uniform vec4 uWidthOverTrail;\n#ifdef COLOR_OVER_TRAIL\nuniform sampler2D uColorOverTrail;\n#endif\n#ifdef COLOR_OVER_LIFETIME\nuniform sampler2D uColorOverLifetime;\n#endif\nout float vLife;out vec2 vTexCoord;out vec4 vColor;\n#ifdef ENV_EDITOR\nuniform vec4 uEditorTransform;\n#endif\nvoid main(){vec4 _pa=effects_MatrixVP*vec4(aPos.xyz,1.);vec4 _pb=effects_MatrixVP*vec4(aPos.xyz+aDir,1.);vec2 dir=normalize(_pb.xy/_pb.w-_pa.xy/_pa.w);vec2 screen_xy=vec2(-dir.y,dir.x);vec4 pos=effects_ObjectToWorld*vec4(aPos.xyz,1.);\n#ifdef ATTR_TRAIL_START\nfloat ts=aTrailStart;\n#else\nfloat ts=uTrailStart[int(aTrailStartIndex)];\n#endif\nfloat trail=(ts-aInfo.y)/uParams.y;float width=aPos.w*getValueFromTime(trail,uWidthOverTrail)/max(abs(screen_xy.x),abs(screen_xy.y));pos.xyz+=(effects_MatrixInvV[0].xyz*screen_xy.x+effects_MatrixInvV[1].xyz*screen_xy.y)*width;float time=min((uTime-aTime)/aInfo.x,1.0);gl_Position=effects_MatrixVP*pos;vColor=aColor;\n#ifdef COLOR_OVER_LIFETIME\n#ifdef ENABLE_VERTEX_TEXTURE\nvColor*=texture2D(uColorOverLifetime,vec2(time,0.));\n#endif\n#endif\n#ifdef COLOR_OVER_TRAIL\nvColor*=texture2D(uColorOverTrail,vec2(trail,0.));\n#endif\nvColor.a*=clamp(getValueFromTime(time,uOpacityOverLifetimeValue),0.,1.);vLife=time;vTexCoord=uTextureMap.xy+vec2(trail,aInfo.z)*uTextureMap.zw;vSeed=aSeed;\n#ifdef ENV_EDITOR\ngl_Position=vec4(gl_Position.xy*uEditorTransform.xy+uEditorTransform.zw*gl_Position.w,gl_Position.zw);\n#endif\n}";
+var trailVert = "#version 300 es\nprecision mediump float;\n#define SHADER_VERTEX 1\n#version 300 es\n#ifdef WEBGL2\n#define texture2D texture\n#else\n#endif\n#ifdef SHADER_VERTEX\n#define CURVE_VALUE_TEXTURE uVCurveValueTexture\n#define CURVE_VALUE_ARRAY uVCurveValues\n#define CURVE_VALUE_COUNT VERT_CURVE_VALUE_COUNT\n#define FRAG_CURVE_VALUE_COUNT 0\n#else\n#define CURVE_VALUE_TEXTURE uFCurveValueTexture\n#define CURVE_VALUE_ARRAY uFCurveValues\n#define CURVE_VALUE_COUNT FRAG_CURVE_VALUE_COUNT\n#define VERT_CURVE_VALUE_COUNT 0\n#endif\n#if CURVE_VALUE_COUNT > 0\n#if LOOKUP_TEXTURE_CURVE\nuniform sampler2D CURVE_VALUE_TEXTURE;const float uCurveCount=1./float(CURVE_VALUE_COUNT);\n#define lookup_curve(i) texture2D(CURVE_VALUE_TEXTURE,vec2(float(i) * uCurveCount,0.))\n#else\nuniform vec4 CURVE_VALUE_ARRAY[CURVE_VALUE_COUNT];\n#define lookup_curve(i) CURVE_VALUE_ARRAY[i]\n#endif\n#else\n#define lookup_curve(i) vec4(0.)\n#endif\n#ifdef WEBGL2\n#define ITR_END (count + 1)\n#else\n#define ITR_END MAX_C\n#endif\n#define NONE_CONST_INDEX 1\n#ifdef SHADER_VERTEX\nin float aSeed;out float vSeed;\n#endif\n#ifdef SHADER_VERTEX\n#define MAX_C VERT_MAX_KEY_FRAME_COUNT\n#else\n#define MAX_C FRAG_MAX_KEY_FRAME_COUNT\n#endif\nmat4 cubicBezierMatrix=mat4(1.0,-3.0,3.0,-1.0,0.0,3.0,-6.0,3.0,0.0,0.0,3.0,-3.0,0.0,0.0,0.0,1.0);float cubicBezier(float t,float y1,float y2,float y3,float y4){vec4 tVec=vec4(1.0,t,t*t,t*t*t);vec4 yVec=vec4(y1,y2,y3,y4);vec4 result=tVec*cubicBezierMatrix*yVec;return result.x+result.y+result.z+result.w;}float binarySearchT(float x,float x1,float x2,float x3,float x4){float left=0.0;float right=1.0;float mid=0.0;float computedX;for(int i=0;i<12;i++){mid=(left+right)*0.5;computedX=cubicBezier(mid,x1,x2,x3,x4);if(abs(computedX-x)<0.0001){break;}else if(computedX>x){right=mid;}else{left=mid;}}return mid;}float valueFromBezierCurveFrames(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);for(int i=0;i<ITR_END;i+=2){if(i>=count){break;}vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);if(i==0&&time<k0.x){return k0.y;}if(i==int(frameCount-2.)&&time>=k1.x){return k1.y;}if(time>=k0.x&&time<=k1.x){float t=(time-k0.x)/(k1.x-k0.x);float nt=binarySearchT(time,k0.x,k0.z,k1.z,k1.x);return cubicBezier(nt,k0.y,k0.w,k1.w,k1.y);}}}float evaluteLineSeg(float t,vec2 p0,vec2 p1){return p0.y+(p1.y-p0.y)*(t-p0.x)/(p1.x-p0.x);}float valueFromLineSegs(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);int end=start+count;for(int i=0;i<ITR_END;i++){if(i>count){return lookup_curve(i).w;}vec4 seg=lookup_curve(i+start);vec2 p0=seg.xy;vec2 p1=seg.zw;if(time>=p0.x&&time<=p1.x){return evaluteLineSeg(time,p0,p1);}vec2 p2=lookup_curve(i+start+1).xy;if(time>p1.x&&time<=p2.x){return evaluteLineSeg(time,p1,p2);}}return lookup_curve(0).y;}float getValueFromTime(float time,vec4 value){float type=value.x;if(type==0.){return value.y;}if(type==1.){return mix(value.y,value.z,time/value.w);}if(type==3.){return valueFromLineSegs(time,value.y,value.z);}if(type==4.){return mix(value.y,value.z,aSeed);}if(type==5.){return valueFromBezierCurveFrames(time,value.z,value.w);}return 0.;}in vec4 aPos;in vec3 aDir;in vec3 aInfo;in vec4 aColor;in float aTime;\n#ifdef ATTR_TRAIL_START\nin float aTrailStart;\n#else\nuniform float uTrailStart[64];in float aTrailStartIndex;\n#endif\nuniform mat4 effects_MatrixInvV;uniform mat4 effects_ObjectToWorld;uniform mat4 effects_MatrixVP;uniform vec4 uTextureMap;uniform float uTime;uniform vec4 uParams;uniform vec4 uColorParams;uniform vec4 uOpacityOverLifetimeValue;uniform vec4 uWidthOverTrail;\n#ifdef COLOR_OVER_TRAIL\nuniform sampler2D uColorOverTrail;\n#endif\n#ifdef COLOR_OVER_LIFETIME\nuniform sampler2D uColorOverLifetime;\n#endif\nout float vLife;out vec2 vTexCoord;out vec4 vColor;\n#ifdef ENV_EDITOR\nuniform vec4 uEditorTransform;\n#endif\nvoid main(){vec4 _pa=effects_MatrixVP*vec4(aPos.xyz,1.);vec4 _pb=effects_MatrixVP*vec4(aPos.xyz+aDir,1.);vec2 dir=normalize(_pb.xy/_pb.w-_pa.xy/_pa.w);vec2 screen_xy=vec2(-dir.y,dir.x);vec4 pos=effects_ObjectToWorld*vec4(aPos.xyz,1.);\n#ifdef ATTR_TRAIL_START\nfloat ts=aTrailStart;\n#else\nfloat ts=uTrailStart[int(aTrailStartIndex)];\n#endif\nfloat trail=(ts-aInfo.y)/uParams.y;float width=aPos.w*getValueFromTime(trail,uWidthOverTrail)/max(abs(screen_xy.x),abs(screen_xy.y));pos.xyz+=(effects_MatrixInvV[0].xyz*screen_xy.x+effects_MatrixInvV[1].xyz*screen_xy.y)*width;float time=min((uTime-aTime)/aInfo.x,1.0);gl_Position=effects_MatrixVP*pos;vColor=aColor;\n#ifdef COLOR_OVER_LIFETIME\n#ifdef ENABLE_VERTEX_TEXTURE\nvColor*=texture2D(uColorOverLifetime,vec2(time,0.));\n#endif\n#endif\n#ifdef COLOR_OVER_TRAIL\nvColor*=texture2D(uColorOverTrail,vec2(trail,0.));\n#endif\nvColor.a*=clamp(getValueFromTime(time,uOpacityOverLifetimeValue),0.,1.);vLife=time;vTexCoord=uTextureMap.xy+vec2(trail,aInfo.z)*uTextureMap.zw;vSeed=aSeed;\n#ifdef ENV_EDITOR\ngl_Position=vec4(gl_Position.xy*uEditorTransform.xy+uEditorTransform.zw*gl_Position.w,gl_Position.zw);\n#endif\n}";
 
-var value = "#ifdef SHADER_VERTEX\n#define CURVE_VALUE_TEXTURE uVCurveValueTexture\n#define CURVE_VALUE_ARRAY uVCurveValues\n#define CURVE_VALUE_COUNT VERT_CURVE_VALUE_COUNT\n#define FRAG_CURVE_VALUE_COUNT 0\n#else\n#define CURVE_VALUE_TEXTURE uFCurveValueTexture\n#define CURVE_VALUE_ARRAY uFCurveValues\n#define CURVE_VALUE_COUNT FRAG_CURVE_VALUE_COUNT\n#define VERT_CURVE_VALUE_COUNT 0\n#endif\n#if CURVE_VALUE_COUNT > 0\n#if LOOKUP_TEXTURE_CURVE\nuniform sampler2D CURVE_VALUE_TEXTURE;const float uCurveCount=1./float(CURVE_VALUE_COUNT);\n#define lookup_curve(i) texture2D(CURVE_VALUE_TEXTURE,vec2(float(i) * uCurveCount,0.))\n#else\nuniform vec4 CURVE_VALUE_ARRAY[CURVE_VALUE_COUNT];\n#define lookup_curve(i) CURVE_VALUE_ARRAY[i]\n#endif\n#else\n#define lookup_curve(i) vec4(0.)\n#endif\n#ifdef WEBGL2\n#define ITR_END (count + 1)\n#else\n#define ITR_END MAX_C\n#endif\n#ifdef SHADER_VERTEX\nin float aSeed;out float vSeed;\n#define NONE_CONST_INDEX 1\n#else\n#if LOOKUP_TEXTURE_CURVE\n#define NONE_CONST_INDEX 1\n#endif\n#endif\n#ifdef NONE_CONST_INDEX\n#ifdef SHADER_VERTEX\n#define MAX_C VERT_MAX_KEY_FRAME_COUNT\n#else\n#define MAX_C FRAG_MAX_KEY_FRAME_COUNT\n#endif\n#else\n#define MAX_C CURVE_VALUE_COUNT\n#endif\nfloat evaluateCurveFrames(float time,vec4 keyframe0,vec4 keyframe1){float dt=keyframe1.x-keyframe0.x;float m0=keyframe0.w*dt;float m1=keyframe1.z*dt;float t=(time-keyframe0.x)/dt;float t2=t*t;float t3=t2*t;return dot(vec4(dot(vec3(2.,-3.,1.),vec3(t3,t2,1.)),dot(vec3(1,-2.,1),vec3(t3,t2,t)),t3-t2,dot(vec2(-2,3),vec2(t3,t2))),vec4(keyframe0.y,m0,m1,keyframe1.y));}float valueFromCurveFrames(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);int end=start+count;for(int i=0;i<ITR_END;i++){\n#ifdef NONE_CONST_INDEX\nif(i==count){return lookup_curve(count).y;}vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);\n#else\nif(i<start){continue;}vec4 k0=lookup_curve(i);vec4 k1=lookup_curve(i+1);if(i==end){return k0.y;}\n#endif\nif(time>=k0.x&&time<=k1.x){return evaluateCurveFrames(time,k0,k1);}}return lookup_curve(0).y;}float evaluteLineSeg(float t,vec2 p0,vec2 p1){return p0.y+(p1.y-p0.y)*(t-p0.x)/(p1.x-p0.x);}float valueFromLineSegs(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);int end=start+count;for(int i=0;i<ITR_END;i++){\n#ifdef NONE_CONST_INDEX\nif(i>count){return lookup_curve(i).w;}\n#else\nif(i<start){continue;}if(i>end){return lookup_curve(i-2).w;}\n#endif\n#ifdef NONE_CONST_INDEX\nvec4 seg=lookup_curve(i+start);\n#else\nvec4 seg=lookup_curve(i);\n#endif\nvec2 p0=seg.xy;vec2 p1=seg.zw;if(time>=p0.x&&time<=p1.x){return evaluteLineSeg(time,p0,p1);}\n#ifdef NONE_CONST_INDEX\nvec2 p2=lookup_curve(i+start+1).xy;\n#else\nvec2 p2=lookup_curve(i+1).xy;\n#endif\nif(time>p1.x&&time<=p2.x){return evaluteLineSeg(time,p1,p2);}}return lookup_curve(0).y;}float getValueFromTime(float time,vec4 value){float type=value.x;if(type==0.){return value.y;}else if(type==1.){return mix(value.y,value.z,time/value.w);}if(type==2.){return valueFromCurveFrames(time,floor(value.y),floor(1./fract(value.y)+0.5))*value.w+value.z;}if(type==3.){return valueFromLineSegs(time,value.y,value.z);}if(type==4.){\n#ifdef SHADER_VERTEX\nfloat seed=aSeed;\n#else\nfloat seed=vSeed;\n#endif\nreturn mix(value.y,value.z,seed);}return 0.;}";
+var value = "#ifdef SHADER_VERTEX\n#define CURVE_VALUE_TEXTURE uVCurveValueTexture\n#define CURVE_VALUE_ARRAY uVCurveValues\n#define CURVE_VALUE_COUNT VERT_CURVE_VALUE_COUNT\n#define FRAG_CURVE_VALUE_COUNT 0\n#else\n#define CURVE_VALUE_TEXTURE uFCurveValueTexture\n#define CURVE_VALUE_ARRAY uFCurveValues\n#define CURVE_VALUE_COUNT FRAG_CURVE_VALUE_COUNT\n#define VERT_CURVE_VALUE_COUNT 0\n#endif\n#if CURVE_VALUE_COUNT > 0\n#if LOOKUP_TEXTURE_CURVE\nuniform sampler2D CURVE_VALUE_TEXTURE;const float uCurveCount=1./float(CURVE_VALUE_COUNT);\n#define lookup_curve(i) texture2D(CURVE_VALUE_TEXTURE,vec2(float(i) * uCurveCount,0.))\n#else\nuniform vec4 CURVE_VALUE_ARRAY[CURVE_VALUE_COUNT];\n#define lookup_curve(i) CURVE_VALUE_ARRAY[i]\n#endif\n#else\n#define lookup_curve(i) vec4(0.)\n#endif\n#ifdef WEBGL2\n#define ITR_END (count + 1)\n#else\n#define ITR_END MAX_C\n#endif\n#define NONE_CONST_INDEX 1\n#ifdef SHADER_VERTEX\nin float aSeed;out float vSeed;\n#endif\n#ifdef SHADER_VERTEX\n#define MAX_C VERT_MAX_KEY_FRAME_COUNT\n#else\n#define MAX_C FRAG_MAX_KEY_FRAME_COUNT\n#endif\nmat4 cubicBezierMatrix=mat4(1.0,-3.0,3.0,-1.0,0.0,3.0,-6.0,3.0,0.0,0.0,3.0,-3.0,0.0,0.0,0.0,1.0);float cubicBezier(float t,float y1,float y2,float y3,float y4){vec4 tVec=vec4(1.0,t,t*t,t*t*t);vec4 yVec=vec4(y1,y2,y3,y4);vec4 result=tVec*cubicBezierMatrix*yVec;return result.x+result.y+result.z+result.w;}float binarySearchT(float x,float x1,float x2,float x3,float x4){float left=0.0;float right=1.0;float mid=0.0;float computedX;for(int i=0;i<12;i++){mid=(left+right)*0.5;computedX=cubicBezier(mid,x1,x2,x3,x4);if(abs(computedX-x)<0.0001){break;}else if(computedX>x){right=mid;}else{left=mid;}}return mid;}float valueFromBezierCurveFrames(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);for(int i=0;i<ITR_END;i+=2){if(i>=count){break;}vec4 k0=lookup_curve(i+start);vec4 k1=lookup_curve(i+1+start);if(i==0&&time<k0.x){return k0.y;}if(i==int(frameCount-2.)&&time>=k1.x){return k1.y;}if(time>=k0.x&&time<=k1.x){float t=(time-k0.x)/(k1.x-k0.x);float nt=binarySearchT(time,k0.x,k0.z,k1.z,k1.x);return cubicBezier(nt,k0.y,k0.w,k1.w,k1.y);}}}float evaluteLineSeg(float t,vec2 p0,vec2 p1){return p0.y+(p1.y-p0.y)*(t-p0.x)/(p1.x-p0.x);}float valueFromLineSegs(float time,float frameStart,float frameCount){int start=int(frameStart);int count=int(frameCount-1.);int end=start+count;for(int i=0;i<ITR_END;i++){if(i>count){return lookup_curve(i).w;}vec4 seg=lookup_curve(i+start);vec2 p0=seg.xy;vec2 p1=seg.zw;if(time>=p0.x&&time<=p1.x){return evaluteLineSeg(time,p0,p1);}vec2 p2=lookup_curve(i+start+1).xy;if(time>p1.x&&time<=p2.x){return evaluteLineSeg(time,p1,p2);}}return lookup_curve(0).y;}float getValueFromTime(float time,vec4 value){float type=value.x;if(type==0.){return value.y;}if(type==1.){return mix(value.y,value.z,time/value.w);}if(type==3.){return valueFromLineSegs(time,value.y,value.z);}if(type==4.){return mix(value.y,value.z,aSeed);}if(type==5.){return valueFromBezierCurveFrames(time,value.z,value.w);}return 0.;}";
 
 var valueDefine = "#ifdef SHADER_VERTEX\n#define CURVE_VALUE_TEXTURE uVCurveValueTexture\n#define CURVE_VALUE_ARRAY uVCurveValues\n#define CURVE_VALUE_COUNT VERT_CURVE_VALUE_COUNT\n#define FRAG_CURVE_VALUE_COUNT 0\n#else\n#define CURVE_VALUE_TEXTURE uFCurveValueTexture\n#define CURVE_VALUE_ARRAY uFCurveValues\n#define CURVE_VALUE_COUNT FRAG_CURVE_VALUE_COUNT\n#define VERT_CURVE_VALUE_COUNT 0\n#endif\n#if CURVE_VALUE_COUNT > 0\n#if LOOKUP_TEXTURE_CURVE\nuniform sampler2D CURVE_VALUE_TEXTURE;const float uCurveCount=1./float(CURVE_VALUE_COUNT);\n#define lookup_curve(i) texture2D(CURVE_VALUE_TEXTURE,vec2(float(i) * uCurveCount,0.))\n#else\nuniform vec4 CURVE_VALUE_ARRAY[CURVE_VALUE_COUNT];\n#define lookup_curve(i) CURVE_VALUE_ARRAY[i]\n#endif\n#else\n#define lookup_curve(i) vec4(0.)\n#endif\n#ifdef WEBGL2\n#define ITR_END (count + 1)\n#else\n#define ITR_END MAX_C\n#endif\n";
 
@@ -15142,819 +15583,146 @@ var FilterSpriteVFXItem = /** @class */ (function (_super) {
     return FilterSpriteVFXItem;
 }(SpriteVFXItem));
 
-var ParticleMesh = /** @class */ (function () {
-    function ParticleMesh(props, rendererOptions) {
-        var _a, _b, _c, _d;
-        this.particleCount = 0;
-        var engine = rendererOptions.composition.getEngine();
-        var env = ((_a = engine.renderer) !== null && _a !== void 0 ? _a : {}).env;
-        var speedOverLifetime = props.speedOverLifetime, colorOverLifetime = props.colorOverLifetime, linearVelOverLifetime = props.linearVelOverLifetime, orbitalVelOverLifetime = props.orbitalVelOverLifetime, sizeOverLifetime = props.sizeOverLifetime, rotationOverLifetime = props.rotationOverLifetime, sprite = props.sprite, gravityModifier = props.gravityModifier, maxCount = props.maxCount, duration = props.duration, textureFlip = props.textureFlip, useSprite = props.useSprite, name = props.name, filter = props.filter, gravity = props.gravity, forceTarget = props.forceTarget, side = props.side, occlusion = props.occlusion, anchor = props.anchor, blending = props.blending, maskMode = props.maskMode, mask = props.mask, transparentOcclusion = props.transparentOcclusion, listIndex = props.listIndex, meshSlots = props.meshSlots, _e = props.renderMode, renderMode = _e === void 0 ? 0 : _e, _f = props.diffuse, diffuse = _f === void 0 ? Texture.createWithData(engine) : _f;
-        var detail = engine.gpuCapability.detail;
-        var halfFloatTexture = detail.halfFloatTexture, maxVertexUniforms = detail.maxVertexUniforms;
-        var marcos = [
-            ['RENDER_MODE', +renderMode],
-            ['PRE_MULTIPLY_ALPHA', false],
-            ['ENV_EDITOR', env === PLAYER_OPTIONS_ENV_EDITOR],
-        ];
-        var level = engine.gpuCapability.level;
-        var vertexKeyFrameMeta = createKeyFrameMeta();
-        var fragmentKeyFrameMeta = createKeyFrameMeta();
-        var enableVertexTexture = maxVertexUniforms > 0;
-        var uniformValues = {};
-        var vertex_lookup_texture = 0;
-        var shaderCacheId = 0;
-        var particleDefine;
-        var useOrbitalVel;
-        this.useSprite = useSprite;
-        if (enableVertexTexture) {
-            marcos.push(['ENABLE_VERTEX_TEXTURE', true]);
-        }
-        if (speedOverLifetime) {
-            marcos.push(['SPEED_OVER_LIFETIME', true]);
-            shaderCacheId |= 1 << 1;
-            uniformValues.uSpeedLifetimeValue = speedOverLifetime.toUniform(vertexKeyFrameMeta);
-        }
-        if (sprite === null || sprite === void 0 ? void 0 : sprite.animate) {
-            marcos.push(['USE_SPRITE', true]);
-            shaderCacheId |= 1 << 2;
-            uniformValues.uFSprite = uniformValues.uSprite = new Float32Array([sprite.col, sprite.row, sprite.total, sprite.blend ? 1 : 0]);
-            this.useSprite = true;
+var LinkNode = /** @class */ (function () {
+    function LinkNode(content) {
+        this.content = content;
+    }
+    return LinkNode;
+}());
+var Link = /** @class */ (function () {
+    function Link(sort) {
+        this.sort = sort;
+        this.length = 0;
+    }
+    Link.prototype.findNodeByContent = function (filter) {
+        var node = this.first;
+        if (node) {
+            do {
+                if (filter(node.content)) {
+                    return node;
+                }
+                // @ts-expect-error
+                // eslint-disable-next-line no-cond-assign
+            } while (node = node.next);
         }
-        if (filter && filter.name !== FILTER_NAME_NONE) {
-            marcos.push(['USE_FILTER', true]);
-            shaderCacheId |= 1 << 3;
-            var filterDefine = createFilter(filter, rendererOptions.composition);
-            if (!filterDefine.particle) {
-                throw new Error("particle filter ".concat(filter.name, " not implement"));
+    };
+    Link.prototype.insertNode = function (a, next) {
+        var b = a.next;
+        a.next = next;
+        next.pre = a;
+        next.next = b;
+        if (b) {
+            b.pre = next;
+        }
+        // a -> next -> b
+    };
+    Link.prototype.shiftNode = function (content) {
+        var node = new LinkNode(content);
+        this.length++;
+        if (this.length === 1) {
+            return this.first = this.last = node;
+        }
+        var current = this.first;
+        while (current) {
+            if (this.sort(current.content, node.content) <= 0) {
+                if (current.next) {
+                    current = current.next;
+                }
+                else {
+                    this.insertNode(current, node);
+                    return this.last = node;
+                }
             }
-            particleDefine = filterDefine.particle;
-            Object.keys((_b = particleDefine.uniforms) !== null && _b !== void 0 ? _b : {}).forEach(function (uName) {
-                var _a;
-                var getter = (_a = particleDefine.uniforms) === null || _a === void 0 ? void 0 : _a[uName];
-                if (uniformValues[uName]) {
-                    throw new Error('conflict uniform name:' + uName);
+            else {
+                if (current.pre) {
+                    this.insertNode(current.pre, node);
                 }
-                uniformValues[uName] = getter === null || getter === void 0 ? void 0 : getter.toUniform(vertexKeyFrameMeta);
-            });
-            Object.keys((_c = particleDefine.uniformValues) !== null && _c !== void 0 ? _c : {}).forEach(function (uName) {
-                var _a;
-                var val = (_a = particleDefine.uniformValues) === null || _a === void 0 ? void 0 : _a[uName];
-                if (uniformValues[uName]) {
-                    throw new Error('conflict uniform name:' + uName);
+                else {
+                    this.first = node;
+                    node.next = current;
+                    current.pre = node;
                 }
-                uniformValues[uName] = val;
-            });
-        }
-        if (colorOverLifetime === null || colorOverLifetime === void 0 ? void 0 : colorOverLifetime.color) {
-            marcos.push(['COLOR_OVER_LIFETIME', true]);
-            shaderCacheId |= 1 << 4;
-            uniformValues.uColorOverLifetime = colorOverLifetime.color instanceof Texture ? colorOverLifetime.color : Texture.createWithData(engine, imageDataFromGradient(colorOverLifetime.color));
-        }
-        if (colorOverLifetime === null || colorOverLifetime === void 0 ? void 0 : colorOverLifetime.opacity) {
-            uniformValues.uOpacityOverLifetimeValue = colorOverLifetime.opacity.toUniform(vertexKeyFrameMeta);
+                return node;
+            }
         }
-        else {
-            uniformValues.uOpacityOverLifetimeValue = createValueGetter(1).toUniform(vertexKeyFrameMeta);
+    };
+    Link.prototype.pushNode = function (content) {
+        var node = new LinkNode(content);
+        this.length++;
+        if (this.length === 1) {
+            return this.last = this.first = node;
         }
-        ['x', 'y', 'z'].forEach(function (pro, i) {
-            var defL = 0;
-            var defO = 0;
-            if (linearVelOverLifetime === null || linearVelOverLifetime === void 0 ? void 0 : linearVelOverLifetime[pro]) {
-                uniformValues["uLinear".concat(pro.toUpperCase(), "ByLifetimeValue")] = linearVelOverLifetime[pro].toUniform(vertexKeyFrameMeta);
-                defL = 1;
-                shaderCacheId |= 1 << (7 + i);
-                linearVelOverLifetime.enabled = true;
+        var current = this.last;
+        while (current) {
+            if (this.sort(node.content, current.content) <= 0) {
+                if (this.first === current) {
+                    current.pre = node;
+                    node.next = current;
+                    return this.first = node;
+                }
+                else {
+                    // @ts-expect-error
+                    current = current.pre;
+                }
             }
-            marcos.push(["LINEAR_VEL_".concat(pro.toUpperCase()), defL]);
-            if (orbitalVelOverLifetime === null || orbitalVelOverLifetime === void 0 ? void 0 : orbitalVelOverLifetime[pro]) {
-                uniformValues["uOrb".concat(pro.toUpperCase(), "ByLifetimeValue")] = orbitalVelOverLifetime[pro].toUniform(vertexKeyFrameMeta);
-                defO = 1;
-                shaderCacheId |= 1 << (10 + i);
-                useOrbitalVel = true;
-                orbitalVelOverLifetime.enabled = true;
+            else {
+                this.insertNode(current, node);
+                if (current === this.last) {
+                    this.last = node;
+                }
+                return node;
             }
-            marcos.push(["ORB_VEL_".concat(pro.toUpperCase()), defO]);
-        });
-        if (linearVelOverLifetime === null || linearVelOverLifetime === void 0 ? void 0 : linearVelOverLifetime.asMovement) {
-            marcos.push(['AS_LINEAR_MOVEMENT', true]);
-            shaderCacheId |= 1 << 5;
         }
-        if (useOrbitalVel) {
-            if (orbitalVelOverLifetime === null || orbitalVelOverLifetime === void 0 ? void 0 : orbitalVelOverLifetime.asRotation) {
-                marcos.push(['AS_ORBITAL_MOVEMENT', true]);
-                shaderCacheId |= 1 << 6;
+    };
+    Link.prototype.removeNode = function (node) {
+        var current = this.first;
+        this.length--;
+        if (current === node) {
+            // @ts-expect-error
+            var a = this.first = current.next;
+            if (a) {
+                a.pre = null;
             }
-            uniformValues.uOrbCenter = new Float32Array((orbitalVelOverLifetime === null || orbitalVelOverLifetime === void 0 ? void 0 : orbitalVelOverLifetime.center) || [0, 0, 0]);
-        }
-        uniformValues.uSizeByLifetimeValue = sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.x.toUniform(vertexKeyFrameMeta);
-        if (sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.separateAxes) {
-            marcos.push(['SIZE_Y_BY_LIFE', 1]);
-            shaderCacheId |= 1 << 14;
-            uniformValues.uSizeYByLifetimeValue = (_d = sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.y) === null || _d === void 0 ? void 0 : _d.toUniform(vertexKeyFrameMeta);
-        }
-        if (rotationOverLifetime === null || rotationOverLifetime === void 0 ? void 0 : rotationOverLifetime.z) {
-            uniformValues.uRZByLifeTimeValue = rotationOverLifetime.z.toUniform(vertexKeyFrameMeta);
-            shaderCacheId |= 1 << 15;
-            marcos.push(['ROT_Z_LIFETIME', 1]);
-        }
-        if (rotationOverLifetime === null || rotationOverLifetime === void 0 ? void 0 : rotationOverLifetime.x) {
-            uniformValues.uRXByLifeTimeValue = rotationOverLifetime.x.toUniform(vertexKeyFrameMeta);
-            shaderCacheId |= 1 << 16;
-            marcos.push(['ROT_X_LIFETIME', 1]);
-        }
-        if (rotationOverLifetime === null || rotationOverLifetime === void 0 ? void 0 : rotationOverLifetime.y) {
-            uniformValues.uRYByLifeTimeValue = rotationOverLifetime.y.toUniform(vertexKeyFrameMeta);
-            shaderCacheId |= 1 << 17;
-            marcos.push(['ROT_Y_LIFETIME', 1]);
-        }
-        if (rotationOverLifetime === null || rotationOverLifetime === void 0 ? void 0 : rotationOverLifetime.asRotation) {
-            marcos.push(['ROT_LIFETIME_AS_MOVEMENT', 1]);
-            shaderCacheId |= 1 << 18;
-        }
-        uniformValues.uGravityModifierValue = gravityModifier.toUniform(vertexKeyFrameMeta);
-        if (forceTarget) {
-            marcos.push(['FINAL_TARGET', true]);
-            shaderCacheId |= 1 << 19;
-            uniformValues.uFinalTarget = new Float32Array(forceTarget.target || [0, 0, 0]);
-            uniformValues.uForceCurve = forceTarget.curve.toUniform(vertexKeyFrameMeta);
-        }
-        if (halfFloatTexture && fragmentKeyFrameMeta.max) {
-            shaderCacheId |= 1 << 20;
-            uniformValues.uFCurveValueTexture = generateHalfFloatTexture(engine, CurveValue.getAllData(fragmentKeyFrameMeta, true), fragmentKeyFrameMeta.index, 1);
-        }
-        else {
-            uniformValues.uFCurveValues = CurveValue.getAllData(fragmentKeyFrameMeta);
         }
-        var vertexCurveTexture = vertexKeyFrameMeta.max + vertexKeyFrameMeta.curves.length - 32 > maxVertexUniforms;
-        // if (getConfig(RENDER_PREFER_LOOKUP_TEXTURE)) {
-        //   vertexCurveTexture = true;
-        // }
-        if (level === 2) {
-            vertexKeyFrameMeta.max = -1;
-            vertexKeyFrameMeta.index = meshSlots ? meshSlots[0] : getSlot(vertexKeyFrameMeta.index);
-            if (fragmentKeyFrameMeta.index > 0) {
-                fragmentKeyFrameMeta.max = -1;
-                fragmentKeyFrameMeta.index = meshSlots ? meshSlots[1] : getSlot(fragmentKeyFrameMeta.index);
+        else if ((current = this.last) === node) {
+            // @ts-expect-error
+            var a = this.last = current.pre;
+            if (a) {
+                a.next = null;
             }
         }
-        if (vertexCurveTexture && halfFloatTexture && enableVertexTexture) {
-            var tex = generateHalfFloatTexture(engine, CurveValue.getAllData(vertexKeyFrameMeta, true), vertexKeyFrameMeta.index, 1);
-            uniformValues.uVCurveValueTexture = tex;
-            vertex_lookup_texture = 1;
+        else if (node) {
+            var pre = node.pre;
+            var next = node.next;
+            // @ts-expect-error
+            pre.next = next;
+            if (next) {
+                next.pre = pre;
+            }
         }
-        else {
-            uniformValues.uVCurveValues = CurveValue.getAllData(vertexKeyFrameMeta);
+        node.pre = null;
+        node.next = null;
+    };
+    Link.prototype.forEach = function (func, thisObj) {
+        var node = this.first;
+        var i = 0;
+        if (node) {
+            do {
+                func.call(thisObj || this, node.content, i++);
+                // @ts-expect-error
+                // eslint-disable-next-line no-cond-assign
+            } while (node = node.next);
         }
-        var shaderCache = ['-p:', renderMode, shaderCacheId, vertexKeyFrameMeta.index, vertexKeyFrameMeta.max, fragmentKeyFrameMeta.index, fragmentKeyFrameMeta.max].join('+');
-        marcos.push(['VERT_CURVE_VALUE_COUNT', vertexKeyFrameMeta.index], ['FRAG_CURVE_VALUE_COUNT', fragmentKeyFrameMeta.index], ['VERT_MAX_KEY_FRAME_COUNT', vertexKeyFrameMeta.max], ['FRAG_MAX_KEY_FRAME_COUNT', fragmentKeyFrameMeta.max]);
-        var fragment = filter ? particleFrag.replace(/#pragma\s+FILTER_FRAG/, particleDefine.fragment) : particleFrag;
-        var originalVertex = "#define LOOKUP_TEXTURE_CURVE ".concat(vertex_lookup_texture, "\n").concat(particleVert);
-        var vertex = filter ? originalVertex.replace(/#pragma\s+FILTER_VERT/, particleDefine.vertex || 'void filterMain(float t){}\n') : originalVertex;
-        var shader = {
-            fragment: createShaderWithMarcos(marcos, fragment, exports.ShaderType.fragment, level),
-            vertex: createShaderWithMarcos(marcos, vertex, exports.ShaderType.vertex, level),
-            glslVersion: level === 1 ? exports.GLSLVersion.GLSL1 : exports.GLSLVersion.GLSL3,
-            shared: true,
-            cacheId: shaderCache,
-            marcos: marcos,
-            name: "particle#".concat(name),
-        };
-        if (filter) {
-            shader.cacheId += filter.name;
-        }
-        var mtlOptions = {
-            shader: shader,
-            uniformSemantics: {
-                effects_MatrixV: 'VIEW',
-                effects_MatrixVP: 'VIEWPROJECTION',
-                uEditorTransform: 'EDITOR_TRANSFORM',
-                effects_ObjectToWorld: 'MODEL',
-            },
-        };
-        var preMulAlpha = getPreMultiAlpha(blending);
-        uniformValues.uTexOffset = new Float32Array(diffuse ? [1 / diffuse.getWidth(), 1 / diffuse.getHeight()] : [0, 0]);
-        uniformValues.uMaskTex = diffuse;
-        uniformValues.uColorParams = new Float32Array([diffuse ? 1 : 0, +preMulAlpha, 0, +(!!occlusion && !transparentOcclusion)]);
-        uniformValues.uParams = [0, duration, 0, 0];
-        uniformValues.uAcceleration = [(gravity === null || gravity === void 0 ? void 0 : gravity[0]) || 0, (gravity === null || gravity === void 0 ? void 0 : gravity[1]) || 0, (gravity === null || gravity === void 0 ? void 0 : gravity[2]) || 0, 0];
-        // mtlOptions.uniformValues = uniformValues;
-        var material = Material.create(engine, mtlOptions);
-        material.blending = true;
-        material.depthTest = true;
-        material.depthMask = !!(occlusion);
-        material.stencilRef = mask ? [mask, mask] : undefined;
-        setMaskMode(material, maskMode);
-        setBlendMode(material, blending);
-        setSideMode(material, side);
-        var typeMap = {
-            'uSprite': 'vec4',
-            'uParams': 'vec4',
-            'uAcceleration': 'vec4',
-            'uGravityModifierValue': 'vec4',
-            'uOpacityOverLifetimeValue': 'vec4',
-            'uRXByLifeTimeValue': 'vec4',
-            'uRYByLifeTimeValue': 'vec4',
-            'uRZByLifeTimeValue': 'vec4',
-            'uLinearXByLifetimeValue': 'vec4',
-            'uLinearYByLifetimeValue': 'vec4',
-            'uLinearZByLifetimeValue': 'vec4',
-            'uSpeedLifetimeValue': 'vec4',
-            'uOrbXByLifetimeValue': 'vec4',
-            'uOrbYByLifetimeValue': 'vec4',
-            'uOrbZByLifetimeValue': 'vec4',
-            'uSizeByLifetimeValue': 'vec4',
-            'uSizeYByLifetimeValue': 'vec4',
-            'uColorParams': 'vec4',
-            'uFSprite': 'vec4',
-            'uPreviewColor': 'vec4',
-            'uVCurveValues': 'vec4Array',
-            'uFCurveValues': 'vec4',
-            'uFinalTarget': 'vec3',
-            'uForceCurve': 'vec4',
-            'uOrbCenter': 'vec3',
-            'uTexOffset': 'vec2',
-            'uPeriodValue': 'vec4',
-            'uMovementValue': 'vec4',
-            'uStrengthValue': 'vec4',
-            'uWaveParams': 'vec4',
-        };
-        Object.keys(uniformValues).map(function (name) {
-            var value = uniformValues[name];
-            if (value instanceof Texture) {
-                material.setTexture(name, value);
-                return;
-            }
-            var res = [];
-            switch (typeMap[name]) {
-                case 'vec4':
-                    material.setVector4(name, Vector4$1.fromArray(value));
-                    break;
-                case 'vec3':
-                    material.setVector3(name, Vector3.fromArray(value));
-                    break;
-                case 'vec2':
-                    material.setVector2(name, Vector2.fromArray(value));
-                    break;
-                case 'vec4Array':
-                    for (var i = 0; i < value.length; i = i + 4) {
-                        var v = new Vector4$1(value[i], value[i + 1], value[i + 2], value[i + 3]);
-                        res.push(v);
-                    }
-                    material.setVector4Array(name, res);
-                    res.length = 0;
-                    break;
-                default:
-                    console.warn("uniform ".concat(name, "'s type not in typeMap"));
-            }
-        });
-        material.setVector3('emissionColor', new Vector3(0, 0, 0));
-        material.setFloat('emissionIntensity', 0.0);
-        var geometry = Geometry.create(engine, generateGeometryProps(maxCount * 4, this.useSprite, "particle#".concat(name)));
-        var mesh = Mesh.create(engine, {
-            name: "MParticle_".concat(name),
-            priority: listIndex,
-            material: material,
-            geometry: geometry,
-        });
-        this.anchor = anchor;
-        this.mesh = mesh;
-        this.geometry = mesh.firstGeometry();
-        this.forceTarget = forceTarget;
-        this.sizeOverLifetime = sizeOverLifetime;
-        this.speedOverLifetime = speedOverLifetime;
-        this.linearVelOverLifetime = linearVelOverLifetime;
-        this.orbitalVelOverLifetime = orbitalVelOverLifetime;
-        this.orbitalVelOverLifetime = orbitalVelOverLifetime;
-        this.gravityModifier = gravityModifier;
-        this.maxCount = maxCount;
-        this.duration = duration;
-        this.textureOffsets = textureFlip ? [0, 0, 1, 0, 0, 1, 1, 1] : [0, 1, 0, 0, 1, 1, 1, 0];
-    }
-    Object.defineProperty(ParticleMesh.prototype, "time", {
-        get: function () {
-            var value = this.mesh.material.getVector4('uParams');
-            return value.x;
-        },
-        set: function (v) {
-            this.mesh.material.setVector4('uParams', new Vector4$1(+v, this.duration, 0, 0));
-        },
-        enumerable: false,
-        configurable: true
-    });
-    ParticleMesh.prototype.getPointColor = function (index) {
-        var data = this.geometry.getAttributeData('aRot');
-        var i = index * 32 + 4;
-        return [data[i], data[i + 1], data[i + 2], data[i + 3]];
-    };
-    /**
-     * 待废弃
-     * @deprecated - 使用 `particle-system.getPointPosition` 替代
-     */
-    ParticleMesh.prototype.getPointPosition = function (index) {
-        var geo = this.geometry;
-        var posIndex = index * 48;
-        var posData = geo.getAttributeData('aPos');
-        var offsetData = geo.getAttributeData('aOffset');
-        var time = this.time - offsetData[index * 16 + 2];
-        var pointDur = offsetData[index * 16 + 3];
-        var mtl = this.mesh.material;
-        var acc = mtl.getVector4('uAcceleration').toVector3();
-        var pos = Vector3.fromArray(posData, posIndex);
-        var vel = Vector3.fromArray(posData, posIndex + 3);
-        var ret = calculateTranslation(new Vector3(), this, acc, time, pointDur, pos, vel);
-        if (this.forceTarget) {
-            var target = mtl.getVector3('uFinalTarget');
-            var life = this.forceTarget.curve.getValue(time / pointDur);
-            var dl = 1 - life;
-            ret.x = ret.x * dl + target.x * life;
-            ret.y = ret.y * dl + target.y * life;
-            ret.z = ret.z * dl + target.z * life;
-        }
-        return ret;
-    };
-    ParticleMesh.prototype.clearPoints = function () {
-        this.resetGeometryData(this.geometry);
-        this.particleCount = 0;
-        this.geometry.setDrawCount(0);
-        this.maxParticleBufferCount = 0;
-    };
-    ParticleMesh.prototype.resetGeometryData = function (geometry) {
-        var names = geometry.getAttributeNames();
-        var index = geometry.getIndexData();
-        for (var i = 0; i < names.length; i++) {
-            var name_1 = names[i];
-            var data = geometry.getAttributeData(name_1);
-            if (data) {
-                // @ts-expect-error
-                geometry.setAttributeData(name_1, new data.constructor(0));
-            }
-        }
-        // @ts-expect-error
-        geometry.setIndexData(new index.constructor(0));
-    };
-    ParticleMesh.prototype.minusTime = function (time) {
-        var data = this.geometry.getAttributeData('aOffset');
-        for (var i = 0; i < data.length; i += 4) {
-            data[i + 2] -= time;
-        }
-        this.geometry.setAttributeData('aOffset', data);
-        this.time -= time;
-    };
-    ParticleMesh.prototype.removePoint = function (index) {
-        if (index < this.particleCount) {
-            this.geometry.setAttributeSubData('aOffset', index * 16, new Float32Array(16));
-        }
-    };
-    ParticleMesh.prototype.setPoint = function (point, index) {
-        var maxCount = this.maxCount;
-        if (index < maxCount) {
-            var particleCount = index + 1;
-            var vertexCount_1 = particleCount * 4;
-            var geometry_1 = this.geometry;
-            var increaseBuffer_1 = particleCount > this.maxParticleBufferCount;
-            var inc_1 = 1;
-            if (this.particleCount > 300) {
-                inc_1 = (this.particleCount + 100) / this.particleCount;
-            }
-            else if (this.particleCount > 100) {
-                inc_1 = 1.4;
-            }
-            else if (this.particleCount > 0) {
-                inc_1 = 2;
-            }
-            var pointData_1 = {
-                aPos: new Float32Array(48),
-                aRot: new Float32Array(32),
-                aOffset: new Float32Array(16),
-            };
-            var useSprite = this.useSprite;
-            if (useSprite) {
-                pointData_1.aSprite = new Float32Array(12);
-            }
-            var tempPos = new Vector3();
-            var tempQuat = new Quaternion();
-            var scale = new Vector3(1, 1, 1);
-            point.transform.assignWorldTRS(tempPos, tempQuat, scale);
-            var tempEuler = Transform.getRotation(tempQuat, new Euler());
-            var position = tempPos.toArray();
-            var rotation = tempEuler.toArray();
-            var offsets = this.textureOffsets;
-            var off = [0, 0, point.delay, point.lifetime];
-            var wholeUV = [0, 0, 1, 1];
-            var vel = point.vel;
-            var color = point.color;
-            var sizeOffsets = [-.5, .5, -.5, -.5, .5, .5, .5, -.5];
-            var seed = Math.random();
-            var sprite = void 0;
-            if (useSprite) {
-                sprite = point.sprite;
-            }
-            for (var j = 0; j < 4; j++) {
-                var offset = j * 2;
-                var j3 = j * 3;
-                var j4 = j * 4;
-                var j12 = j * 12;
-                var j8 = j * 8;
-                pointData_1.aPos.set(position, j12);
-                vel.fill(pointData_1.aPos, j12 + 3);
-                pointData_1.aRot.set(rotation, j8);
-                pointData_1.aRot[j8 + 3] = seed;
-                pointData_1.aRot.set(color, j8 + 4);
-                if (useSprite) {
-                    // @ts-expect-error
-                    pointData_1.aSprite.set(sprite, j3);
-                }
-                var uv = point.uv || wholeUV;
-                if (uv) {
-                    var uvy = useSprite ? (1 - offsets[offset + 1]) : offsets[offset + 1];
-                    off[0] = uv[0] + offsets[offset] * uv[2];
-                    off[1] = uv[1] + uvy * uv[3];
-                }
-                pointData_1.aOffset.set(off, j4);
-                var ji = (j + j);
-                var sx = (sizeOffsets[ji] - this.anchor.x) * scale.x;
-                var sy = (sizeOffsets[ji + 1] - this.anchor.y) * scale.y;
-                for (var k = 0; k < 3; k++) {
-                    pointData_1.aPos[j12 + 6 + k] = point.dirX.getElement(k) * sx;
-                    pointData_1.aPos[j12 + 9 + k] = point.dirY.getElement(k) * sy;
-                }
-            }
-            var indexData = new Uint16Array([0, 1, 2, 2, 1, 3].map(function (x) { return x + index * 4; }));
-            if (increaseBuffer_1) {
-                var baseIndexData = geometry_1.getIndexData();
-                var idx = enlargeBuffer(baseIndexData, particleCount * 6, inc_1, maxCount * 6);
-                idx.set(indexData, index * 6);
-                geometry_1.setIndexData(idx);
-                this.maxParticleBufferCount = idx.length / 6;
-            }
-            else {
-                geometry_1.setIndexSubData(index * 6, indexData);
-            }
-            Object.keys(pointData_1).forEach(function (name) {
-                var data = pointData_1[name];
-                var attrSize = geometry_1.getAttributeStride(name) / Float32Array.BYTES_PER_ELEMENT;
-                if (increaseBuffer_1) {
-                    var baseData = geometry_1.getAttributeData(name);
-                    var geoData = enlargeBuffer(baseData, vertexCount_1 * attrSize, inc_1, maxCount * 4 * attrSize);
-                    geoData.set(data, data.length * index);
-                    geometry_1.setAttributeData(name, geoData);
-                }
-                else {
-                    geometry_1.setAttributeSubData(name, data.length * index, data);
-                }
-            });
-            this.particleCount = Math.max(particleCount, this.particleCount);
-            geometry_1.setDrawCount(this.particleCount * 6);
-        }
-    };
-    return ParticleMesh;
-}());
-var gl2UniformSlots = [10, 32, 64, 160];
-function getSlot(count) {
-    for (var w = 0; w < gl2UniformSlots.length; w++) {
-        var slot = gl2UniformSlots[w];
-        if (slot > count) {
-            return slot;
-        }
-    }
-    return count || gl2UniformSlots[0];
-}
-function generateGeometryProps(maxVertex, useSprite, name) {
-    var bpe = Float32Array.BYTES_PER_ELEMENT;
-    var j12 = bpe * 12;
-    var attributes = {
-        aPos: { size: 3, offset: 0, stride: j12, data: new Float32Array(0) },
-        aVel: { size: 3, offset: 3 * bpe, stride: j12, dataSource: 'aPos' },
-        aDirX: { size: 3, offset: 6 * bpe, stride: j12, dataSource: 'aPos' },
-        aDirY: { size: 3, offset: 9 * bpe, stride: j12, dataSource: 'aPos' },
-        //
-        aRot: { size: 3, offset: 0, stride: 8 * bpe, data: new Float32Array(0) },
-        aSeed: { size: 1, offset: 3 * bpe, stride: 8 * bpe, dataSource: 'aRot' },
-        aColor: { size: 4, offset: 4 * bpe, stride: 8 * bpe, dataSource: 'aRot' },
-        //
-        aOffset: { size: 4, stride: 4 * bpe, data: new Float32Array(0) },
-    };
-    if (useSprite) {
-        attributes['aSprite'] = { size: 3, data: new Float32Array(0) };
-    }
-    return { attributes: attributes, indices: { data: new Uint16Array(0) }, name: name, maxVertex: maxVertex };
-}
-function getParticleMeshShader(item, env, gpuCapability) {
-    var _a, _b, _c, _d, _e;
-    if (env === void 0) { env = ''; }
-    var props = item.content;
-    var renderMode = +(((_a = props.renderer) === null || _a === void 0 ? void 0 : _a.renderMode) || 0);
-    var marcos = [
-        ['RENDER_MODE', renderMode],
-        ['PRE_MULTIPLY_ALPHA', false],
-        ['ENV_EDITOR', env === PLAYER_OPTIONS_ENV_EDITOR],
-    ];
-    var level = gpuCapability.level, detail = gpuCapability.detail;
-    var vertexKeyFrameMeta = createKeyFrameMeta();
-    var fragmentKeyFrameMeta = createKeyFrameMeta();
-    var enableVertexTexture = detail.maxVertexUniforms > 0;
-    var speedOverLifetime = ((_b = props.positionOverLifetime) !== null && _b !== void 0 ? _b : {}).speedOverLifetime;
-    var vertex_lookup_texture = 0;
-    var shaderCacheId = 0;
-    if (enableVertexTexture) {
-        marcos.push(['ENABLE_VERTEX_TEXTURE', true]);
-    }
-    if (speedOverLifetime) {
-        marcos.push(['SPEED_OVER_LIFETIME', true]);
-        shaderCacheId |= 1 << 1;
-        getKeyFrameMetaByRawValue(vertexKeyFrameMeta, speedOverLifetime);
-    }
-    var sprite = props.textureSheetAnimation;
-    if (sprite && sprite.animate) {
-        marcos.push(['USE_SPRITE', true]);
-        shaderCacheId |= 1 << 2;
-    }
-    var filter = undefined;
-    if (props.filter && props.filter.name !== FILTER_NAME_NONE) {
-        marcos.push(['USE_FILTER', true]);
-        shaderCacheId |= 1 << 3;
-        var f = createFilterShaders(props.filter).find(function (f) { return f.isParticle; });
-        if (!f) {
-            throw Error("particle filter ".concat(props.filter.name, " not implement"));
-        }
-        filter = f;
-        (_c = f.uniforms) === null || _c === void 0 ? void 0 : _c.forEach(function (val) { return getKeyFrameMetaByRawValue(vertexKeyFrameMeta, val); });
-        // filter = processFilter(props.filter, fragmentKeyFrameMeta, vertexKeyFrameMeta, options);
-    }
-    var colorOverLifetime = props.colorOverLifetime;
-    if (colorOverLifetime && colorOverLifetime.color) {
-        marcos.push(['COLOR_OVER_LIFETIME', true]);
-        shaderCacheId |= 1 << 4;
-    }
-    var opacity = colorOverLifetime && colorOverLifetime.opacity;
-    if (opacity) {
-        getKeyFrameMetaByRawValue(vertexKeyFrameMeta, opacity);
-    }
-    var positionOverLifetime = props.positionOverLifetime;
-    var useOrbitalVel;
-    ['x', 'y', 'z'].forEach(function (pro, i) {
-        var defL = 0;
-        var linearPro = 'linear' + pro.toUpperCase();
-        var orbitalPro = 'orbital' + pro.toUpperCase();
-        if (positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime[linearPro]) {
-            getKeyFrameMetaByRawValue(vertexKeyFrameMeta, positionOverLifetime[linearPro]);
-            defL = 1;
-            shaderCacheId |= 1 << (7 + i);
-        }
-        marcos.push(["LINEAR_VEL_".concat(pro.toUpperCase()), defL]);
-        var defO = 0;
-        if (positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime[orbitalPro]) {
-            getKeyFrameMetaByRawValue(vertexKeyFrameMeta, positionOverLifetime[orbitalPro]);
-            defO = 1;
-            shaderCacheId |= 1 << (10 + i);
-            useOrbitalVel = true;
-        }
-        marcos.push(["ORB_VEL_".concat(pro.toUpperCase()), defO]);
-    });
-    if (positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime.asMovement) {
-        marcos.push(['AS_LINEAR_MOVEMENT', true]);
-        shaderCacheId |= 1 << 5;
-    }
-    if (useOrbitalVel) {
-        if (positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime.asRotation) {
-            marcos.push(['AS_ORBITAL_MOVEMENT', true]);
-            shaderCacheId |= 1 << 6;
-        }
-    }
-    var sizeOverLifetime = props.sizeOverLifetime;
-    getKeyFrameMetaByRawValue(vertexKeyFrameMeta, sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.x);
-    if (sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.separateAxes) {
-        marcos.push(['SIZE_Y_BY_LIFE', 1]);
-        shaderCacheId |= 1 << 14;
-        getKeyFrameMetaByRawValue(vertexKeyFrameMeta, sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.y);
-    }
-    var rot = props.rotationOverLifetime;
-    if (rot === null || rot === void 0 ? void 0 : rot.z) {
-        getKeyFrameMetaByRawValue(vertexKeyFrameMeta, rot === null || rot === void 0 ? void 0 : rot.z);
-        shaderCacheId |= 1 << 15;
-        marcos.push(['ROT_Z_LIFETIME', 1]);
-    }
-    if (rot === null || rot === void 0 ? void 0 : rot.separateAxes) {
-        if (rot.x) {
-            getKeyFrameMetaByRawValue(vertexKeyFrameMeta, rot.x);
-            shaderCacheId |= 1 << 16;
-            marcos.push(['ROT_X_LIFETIME', 1]);
-        }
-        if (rot.y) {
-            getKeyFrameMetaByRawValue(vertexKeyFrameMeta, rot.y);
-            shaderCacheId |= 1 << 17;
-            marcos.push(['ROT_Y_LIFETIME', 1]);
-        }
-    }
-    if (rot === null || rot === void 0 ? void 0 : rot.asRotation) {
-        marcos.push(['ROT_LIFETIME_AS_MOVEMENT', 1]);
-        shaderCacheId |= 1 << 18;
-    }
-    getKeyFrameMetaByRawValue(vertexKeyFrameMeta, positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime.gravityOverLifetime);
-    var forceOpt = positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime.forceTarget;
-    if (forceOpt) {
-        marcos.push(['FINAL_TARGET', true]);
-        shaderCacheId |= 1 << 19;
-        getKeyFrameMetaByRawValue(vertexKeyFrameMeta, positionOverLifetime.forceCurve);
-    }
-    var HALF_FLOAT = detail.halfFloatTexture;
-    if (HALF_FLOAT && fragmentKeyFrameMeta.max) {
-        shaderCacheId |= 1 << 20;
-    }
-    var maxVertexUniforms = detail.maxVertexUniforms;
-    var vertexCurveTexture = vertexKeyFrameMeta.max + vertexKeyFrameMeta.curves.length - 32 > maxVertexUniforms;
-    if (getConfig(RENDER_PREFER_LOOKUP_TEXTURE)) {
-        vertexCurveTexture = true;
-    }
-    if (level === 2) {
-        vertexKeyFrameMeta.max = -1;
-        // vertexKeyFrameMeta.index = getSlot(vertexKeyFrameMeta.index);
-        if (fragmentKeyFrameMeta.index > 0) {
-            fragmentKeyFrameMeta.max = -1;
-            // fragmentKeyFrameMeta.index = getSlot(fragmentKeyFrameMeta.index);
-        }
-    }
-    if (vertexCurveTexture && HALF_FLOAT && enableVertexTexture) {
-        vertex_lookup_texture = 1;
-    }
-    var shaderCache = ['-p:', renderMode, shaderCacheId, vertexKeyFrameMeta.index, vertexKeyFrameMeta.max, fragmentKeyFrameMeta.index, fragmentKeyFrameMeta.max].join('+');
-    var shader = {
-        fragment: particleFrag,
-        vertex: "#define LOOKUP_TEXTURE_CURVE ".concat(vertex_lookup_texture, "\n").concat(particleVert),
-        shared: true,
-        cacheId: shaderCache,
-        marcos: marcos,
-        name: "particle#".concat(item.name),
-    };
-    if (filter) {
-        shader.fragment = shader.fragment.replace(/#pragma\s+FILTER_FRAG/, (_d = filter.fragment) !== null && _d !== void 0 ? _d : '');
-        shader.vertex = shader.vertex.replace(/#pragma\s+FILTER_VERT/, filter.vertex || 'void filterMain(float t){}\n');
-        shader.cacheId += '+' + ((_e = props.filter) === null || _e === void 0 ? void 0 : _e.name);
-    }
-    marcos.push(['VERT_CURVE_VALUE_COUNT', vertexKeyFrameMeta.index], ['FRAG_CURVE_VALUE_COUNT', fragmentKeyFrameMeta.index], ['VERT_MAX_KEY_FRAME_COUNT', vertexKeyFrameMeta.max], ['FRAG_MAX_KEY_FRAME_COUNT', fragmentKeyFrameMeta.max]);
-    return { shader: shader, vertex: vertexKeyFrameMeta.index, fragment: fragmentKeyFrameMeta.index };
-}
-function modifyMaxKeyframeShader(shader, maxVertex, maxFrag) {
-    var _a;
-    var shaderIds = (_a = shader.cacheId) === null || _a === void 0 ? void 0 : _a.split('+');
-    shaderIds[3] = maxVertex;
-    shaderIds[5] = maxFrag;
-    shader.cacheId = shaderIds.join('+');
-    if (!shader.marcos) {
-        return;
-    }
-    for (var i = 0; i < shader.marcos.length; i++) {
-        var marco = shader.marcos[i];
-        if (marco[0] === 'VERT_CURVE_VALUE_COUNT') {
-            marco[1] = maxVertex;
-        }
-        else if (marco[0] === 'FRAG_CURVE_VALUE_COUNT') {
-            marco[1] = maxFrag;
-            break;
-        }
-    }
-}
-
-var LinkNode = /** @class */ (function () {
-    function LinkNode(content) {
-        this.content = content;
-    }
-    return LinkNode;
-}());
-var Link = /** @class */ (function () {
-    function Link(sort) {
-        this.sort = sort;
-        this.length = 0;
-    }
-    Link.prototype.findNodeByContent = function (filter) {
-        var node = this.first;
-        if (node) {
-            do {
-                if (filter(node.content)) {
-                    return node;
-                }
-                // @ts-expect-error
-                // eslint-disable-next-line no-cond-assign
-            } while (node = node.next);
-        }
-    };
-    Link.prototype.insertNode = function (a, next) {
-        var b = a.next;
-        a.next = next;
-        next.pre = a;
-        next.next = b;
-        if (b) {
-            b.pre = next;
-        }
-        // a -> next -> b
-    };
-    Link.prototype.shiftNode = function (content) {
-        var node = new LinkNode(content);
-        this.length++;
-        if (this.length === 1) {
-            return this.first = this.last = node;
-        }
-        var current = this.first;
-        while (current) {
-            if (this.sort(current.content, node.content) <= 0) {
-                if (current.next) {
-                    current = current.next;
-                }
-                else {
-                    this.insertNode(current, node);
-                    return this.last = node;
-                }
-            }
-            else {
-                if (current.pre) {
-                    this.insertNode(current.pre, node);
-                }
-                else {
-                    this.first = node;
-                    node.next = current;
-                    current.pre = node;
-                }
-                return node;
-            }
-        }
-    };
-    Link.prototype.pushNode = function (content) {
-        var node = new LinkNode(content);
-        this.length++;
-        if (this.length === 1) {
-            return this.last = this.first = node;
-        }
-        var current = this.last;
-        while (current) {
-            if (this.sort(node.content, current.content) <= 0) {
-                if (this.first === current) {
-                    current.pre = node;
-                    node.next = current;
-                    return this.first = node;
-                }
-                else {
-                    // @ts-expect-error
-                    current = current.pre;
-                }
-            }
-            else {
-                this.insertNode(current, node);
-                if (current === this.last) {
-                    this.last = node;
-                }
-                return node;
-            }
-        }
-    };
-    Link.prototype.removeNode = function (node) {
-        var current = this.first;
-        this.length--;
-        if (current === node) {
-            // @ts-expect-error
-            var a = this.first = current.next;
-            if (a) {
-                a.pre = null;
-            }
-        }
-        else if ((current = this.last) === node) {
-            // @ts-expect-error
-            var a = this.last = current.pre;
-            if (a) {
-                a.next = null;
-            }
-        }
-        else if (node) {
-            var pre = node.pre;
-            var next = node.next;
-            // @ts-expect-error
-            pre.next = next;
-            if (next) {
-                next.pre = pre;
-            }
-        }
-        node.pre = null;
-        node.next = null;
-    };
-    Link.prototype.forEach = function (func, thisObj) {
-        var node = this.first;
-        var i = 0;
-        if (node) {
-            do {
-                func.call(thisObj || this, node.content, i++);
-                // @ts-expect-error
-                // eslint-disable-next-line no-cond-assign
-            } while (node = node.next);
-        }
-    };
-    Link.prototype.forEachReverse = function (func, thisObj) {
-        var node = this.last;
-        var i = this.length - 1;
-        if (node) {
-            do {
-                func.call(thisObj || this, node.content, i--);
-                // @ts-expect-error
-                // eslint-disable-next-line no-cond-assign
-            } while (node = node.pre);
+    };
+    Link.prototype.forEachReverse = function (func, thisObj) {
+        var node = this.last;
+        var i = this.length - 1;
+        if (node) {
+            do {
+                func.call(thisObj || this, node.content, i--);
+                // @ts-expect-error
+                // eslint-disable-next-line no-cond-assign
+            } while (node = node.pre);
         }
     };
     return Link;
@@ -17045,11 +16813,11 @@ var TrailMesh = /** @class */ (function () {
         var uWidthOverTrail = widthOverTrail.toUniform(keyFrameMeta);
         marcos.push(['VERT_CURVE_VALUE_COUNT', keyFrameMeta.index], ['VERT_MAX_KEY_FRAME_COUNT', keyFrameMeta.max]);
         if (enableVertexTexture && lookUpTexture) {
-            var tex = generateHalfFloatTexture(engine, CurveValue.getAllData(keyFrameMeta, true), keyFrameMeta.index, 1);
+            var tex = generateHalfFloatTexture(engine, ValueGetter.getAllData(keyFrameMeta, true), keyFrameMeta.index, 1);
             uniformValues.uVCurveValueTexture = tex;
         }
         else {
-            uniformValues.uVCurveValues = CurveValue.getAllData(keyFrameMeta);
+            uniformValues.uVCurveValues = ValueGetter.getAllData(keyFrameMeta);
         }
         var vertex = createShaderWithMarcos(marcos, trailVert, exports.ShaderType.vertex, level);
         var fragment = createShaderWithMarcos(marcos, particleFrag, exports.ShaderType.fragment, level);
@@ -17128,8 +16896,10 @@ var TrailMesh = /** @class */ (function () {
             }
             else if (name === 'uVCurveValues') {
                 var array = [];
-                array.push(new Vector4$1(value[0], value[1], value[2], value[3]));
-                array.push(new Vector4$1(value[4], value[5], value[6], value[7]));
+                for (var i = 0; i < value.length; i = i + 4) {
+                    var v = new Vector4$1(value[i], value[i + 1], value[i + 2], value[i + 3]);
+                    array.push(v);
+                }
                 material.setVector4Array(name, array);
             }
             else {
@@ -17877,456 +17647,1129 @@ var ParticleSystem = /** @class */ (function () {
                     this.onIterate(this);
                 }
                 else {
-                    this.ended = true;
-                    this.onEnd(this);
-                    var endBehavior = options.endBehavior;
-                    if (endBehavior === END_BEHAVIOR_FREEZE$1) {
-                        this.frozen = true;
-                    }
+                    this.ended = true;
+                    this.onEnd(this);
+                    var endBehavior = options.endBehavior;
+                    if (endBehavior === END_BEHAVIOR_FREEZE$1) {
+                        this.frozen = true;
+                    }
+                }
+            }
+            else if (!options.looping) {
+                if (this.reusable) ;
+                else if (END_BEHAVIOR_DESTROY$1 === options.endBehavior) {
+                    var node = link_1.last;
+                    if (node && (node.content[0] - loopStartTime_1) < timePassed_1) {
+                        this.onUpdate = function () { return _this.onDestroy(); };
+                    }
+                }
+            }
+            updateTrail();
+        }
+    };
+    ParticleSystem.prototype.onDestroy = function () {
+    };
+    ParticleSystem.prototype.getParticleBoxes = function () {
+        var link = this.particleLink;
+        var mesh = this.particleMesh;
+        var res = [];
+        var maxCount = this.particleCount;
+        var counter = 0;
+        if (!(link && mesh)) {
+            return res;
+        }
+        var node = link.last;
+        var finish = false;
+        while (!finish) {
+            var currentTime = node.content[0];
+            var point = node.content[3];
+            if (currentTime > this.timePassed) {
+                var pos = this.getPointPosition(point);
+                res.push({
+                    center: pos,
+                    size: point.transform.scale,
+                });
+                if (node.pre) {
+                    node = node.pre;
+                }
+                else {
+                    finish = true;
+                }
+            }
+            counter++;
+            if (counter > maxCount) {
+                finish = true;
+            }
+        }
+        return res;
+    };
+    ParticleSystem.prototype.raycast = function (options) {
+        var link = this.particleLink;
+        var mesh = this.particleMesh;
+        if (!(link && mesh)) {
+            return;
+        }
+        var node = link.last;
+        var hitPositions = [];
+        var temp = new Vector3();
+        var finish = false;
+        if (node && node.content) {
+            do {
+                var _a = __read$3(node.content, 4), currentTime = _a[0], pointIndex = _a[1]; _a[2]; var point = _a[3];
+                if (currentTime > this.timePassed) {
+                    var pos = this.getPointPosition(point);
+                    var ray = options.ray;
+                    var pass = false;
+                    if (ray) {
+                        pass = !!ray.intersectSphere({
+                            center: pos,
+                            radius: options.radius,
+                        }, temp);
+                    }
+                    if (pass) {
+                        if (options.removeParticle) {
+                            mesh.removePoint(pointIndex);
+                            this.clearPointTrail(pointIndex);
+                            node.content[0] = 0;
+                        }
+                        hitPositions.push(pos);
+                        if (!options.multiple) {
+                            finish = true;
+                        }
+                    }
+                }
+                else {
+                    break;
+                }
+                // @ts-expect-error
+            } while ((node = node.pre) && !finish);
+        }
+        return hitPositions;
+    };
+    ParticleSystem.prototype.clearPointTrail = function (pointIndex) {
+        var _a;
+        if (this.trails && this.trails.dieWithParticles) {
+            (_a = this.trailMesh) === null || _a === void 0 ? void 0 : _a.clearTrail(pointIndex);
+        }
+    };
+    ParticleSystem.prototype.updatePointTrail = function (pointIndex, emitterLifetime, point, startTime) {
+        if (!this.trailMesh) {
+            return;
+        }
+        var trails = this.trails;
+        var particleMesh = this.particleMesh;
+        var position = this.getPointPosition(point);
+        var color = trails.inheritParticleColor ? particleMesh.getPointColor(pointIndex) : [1, 1, 1, 1];
+        var size = point.transform.getWorldScale().toArray();
+        var width = 1;
+        var lifetime = trails.lifetime.getValue(emitterLifetime);
+        if (trails.sizeAffectsWidth) {
+            width *= size[0];
+        }
+        if (trails.sizeAffectsLifetime) {
+            lifetime *= size[0];
+        }
+        if (trails.parentAffectsPosition && this.transform.parentTransform) {
+            position.add(this.transform.parentTransform.position);
+            var pos = this.trailMesh.getPointStartPos(pointIndex);
+            if (pos) {
+                position.subtract(pos);
+            }
+        }
+        this.trailMesh.addPoint(pointIndex, position, {
+            color: color,
+            lifetime: lifetime,
+            size: width,
+            time: startTime,
+        });
+    };
+    ParticleSystem.prototype.getPointPosition = function (point) {
+        var transform = point.transform, vel = point.vel, lifetime = point.lifetime, delay = point.delay, _a = point.gravity, gravity = _a === void 0 ? [] : _a;
+        var forceTarget = this.options.forceTarget;
+        var time = this.lastUpdate - delay;
+        var tempPos = new Vector3();
+        var acc = Vector3.fromArray(gravity);
+        transform.assignWorldTRS(tempPos);
+        var ret = calculateTranslation(new Vector3(), this.options, acc, time, lifetime, tempPos, vel);
+        if (forceTarget) {
+            var target = forceTarget.target || [0, 0, 0];
+            var life = forceTarget.curve.getValue(time / lifetime);
+            var dl = 1 - life;
+            ret.x = ret.x * dl + target[0] * life;
+            ret.y = ret.y * dl + target[1] * life;
+            ret.z = ret.z * dl + target[2] * life;
+        }
+        return ret;
+    };
+    ParticleSystem.prototype.onEnd = function (particle) {
+    };
+    ParticleSystem.prototype.onIterate = function (particle) {
+    };
+    ParticleSystem.prototype.initPoint = function (data) {
+        var options = this.options;
+        var lifetime = this.lifetime;
+        var shape = this.shape;
+        var speed = options.startSpeed.getValue(lifetime);
+        var matrix4 = options.particleFollowParent ? this.transform.getMatrix() : this.transform.getWorldMatrix();
+        // 粒子的位置受发射器的位置影响，自身的旋转和缩放不受影响
+        var position = matrix4.transformPoint(data.position, new Vector3());
+        var transform = new Transform({
+            position: position,
+            valid: true,
+        });
+        var direction = data.direction;
+        direction = matrix4.transformNormal(direction, tempDir).normalize();
+        if (options.startTurbulence && options.turbulence) {
+            for (var i = 0; i < 3; i++) {
+                tempVec3.setElement(i, options.turbulence[i].getValue(lifetime));
+            }
+            tempEuler.setFromVector3(tempVec3.negate());
+            var mat4 = tempMat4.setFromEuler(tempEuler);
+            mat4.transformNormal(direction).normalize();
+        }
+        var dirX = tmpDirX;
+        var dirY = tmpDirY;
+        if (shape.alignSpeedDirection) {
+            dirY.copyFrom(direction);
+            if (!this.upDirectionWorld) {
+                if (shape.upDirection) {
+                    this.upDirectionWorld = shape.upDirection.clone();
+                }
+                else {
+                    this.upDirectionWorld = Vector3.Z.clone();
                 }
+                matrix4.transformNormal(this.upDirectionWorld);
             }
-            else if (!options.looping) {
-                if (this.reusable) ;
-                else if (END_BEHAVIOR_DESTROY$1 === options.endBehavior) {
-                    var node = link_1.last;
-                    if (node && (node.content[0] - loopStartTime_1) < timePassed_1) {
-                        this.onUpdate = function () { return _this.onDestroy(); };
-                    }
-                }
+            dirX.crossVectors(dirY, this.upDirectionWorld).normalize();
+            // FIXME: 原先因为有精度问题，这里dirX不是0向量
+            if (dirX.isZero()) {
+                dirX.set(1, 0, 0);
             }
-            updateTrail();
         }
+        else {
+            dirX.set(1, 0, 0);
+            dirY.set(0, 1, 0);
+        }
+        var sprite;
+        var tsa = this.textureSheetAnimation;
+        if (tsa && tsa.animate) {
+            sprite = tempSprite;
+            sprite[0] = tsa.animationDelay.getValue(lifetime);
+            sprite[1] = tsa.animationDuration.getValue(lifetime);
+            sprite[2] = tsa.cycles.getValue(lifetime);
+        }
+        var rot = tempRot;
+        if (options.start3DRotation) {
+            // @ts-expect-error
+            rot.set(options.startRotationX.getValue(lifetime), options.startRotationY.getValue(lifetime), options.startRotationZ.getValue(lifetime));
+        }
+        else if (options.startRotation) {
+            rot.set(0, 0, options.startRotation.getValue(lifetime));
+        }
+        else {
+            rot.set(0, 0, 0);
+        }
+        transform.setRotation(rot.x, rot.y, rot.z);
+        var color = options.startColor.getValue(lifetime);
+        if (color.length === 3) {
+            color[3] = 1;
+        }
+        var size = tempSize;
+        if (options.start3DSize) {
+            size.x = options.startSizeX.getValue(lifetime);
+            size.y = options.startSizeY.getValue(lifetime);
+        }
+        else {
+            var n = options.startSize.getValue(lifetime);
+            var aspect = options.sizeAspect.getValue(lifetime);
+            size.x = n;
+            // 兼容aspect为0的情况
+            size.y = aspect === 0 ? 0 : n / aspect;
+            // size[1] = n / aspect;
+        }
+        var vel = direction.clone();
+        vel.multiply(speed);
+        // 粒子的大小受发射器父节点的影响
+        if (!options.particleFollowParent) {
+            var tempScale = new Vector3();
+            this.transform.assignWorldTRS(undefined, undefined, tempScale);
+            size.x *= tempScale.x;
+            size.y *= tempScale.y;
+        }
+        transform.setScale(size.x, size.y, 1);
+        return {
+            size: size,
+            vel: vel,
+            color: color,
+            delay: options.startDelay.getValue(lifetime),
+            lifetime: options.startLifetime.getValue(lifetime),
+            uv: randomArrItem(this.uvs, true),
+            gravity: options.gravity,
+            sprite: sprite,
+            dirY: dirY,
+            dirX: dirX,
+            transform: transform,
+        };
     };
-    ParticleSystem.prototype.onDestroy = function () {
+    ParticleSystem.prototype.addBurst = function (burst, offsets) {
+        var willAdd = false;
+        if (!this.emission.bursts.includes(burst)) {
+            this.emission.bursts.push(burst);
+            willAdd = true;
+        }
+        if (willAdd && offsets instanceof Array) {
+            var index = this.emission.bursts.indexOf(burst);
+            this.emission.burstOffsets[index] = offsets;
+            return index;
+        }
+        return -1;
     };
-    ParticleSystem.prototype.getParticleBoxes = function () {
-        var link = this.particleLink;
-        var mesh = this.particleMesh;
-        var res = [];
-        var maxCount = this.particleCount;
-        var counter = 0;
-        if (!(link && mesh)) {
-            return res;
+    ParticleSystem.prototype.removeBurst = function (index) {
+        if (index < this.emission.bursts.length) {
+            this.emission.burstOffsets[index] = null;
+            this.emission.bursts.splice(index, 1);
         }
-        var node = link.last;
-        var finish = false;
-        while (!finish) {
-            var currentTime = node.content[0];
-            var point = node.content[3];
-            if (currentTime > this.timePassed) {
-                var pos = this.getPointPosition(point);
-                res.push({
-                    center: pos,
-                    size: point.transform.scale,
-                });
-                if (node.pre) {
-                    node = node.pre;
-                }
-                else {
-                    finish = true;
-                }
+    };
+    ParticleSystem.prototype.createPoint = function (lifetime) {
+        var generator = {
+            total: this.emission.rateOverTime.getValue(lifetime),
+            index: this.generatedCount,
+            burstIndex: 0,
+            burstCount: 0,
+        };
+        this.generatedCount++;
+        return this.initPoint(this.shape.generate(generator));
+    };
+    return ParticleSystem;
+}());
+// array performance better for small memory than Float32Array
+var tempDir = new Vector3();
+var tempSize = new Vector2();
+var tempRot = new Euler();
+var tmpDirX = new Vector3();
+var tmpDirY = new Vector3();
+var tempVec3 = new Vector3();
+var tempEuler = new Euler();
+var tempSprite = [0, 0, 0];
+var tempMat4 = new Matrix4$1();
+function getBurstOffsets(burstOffsets) {
+    var ret = {};
+    if (Array.isArray(burstOffsets)) {
+        burstOffsets.forEach(function (arr) {
+            var isArr = arr instanceof Array;
+            var index = isArr ? arr[0] : arr.index;
+            var offsets = ret[index];
+            if (!offsets) {
+                offsets = ret[index] = [];
             }
-            counter++;
-            if (counter > maxCount) {
-                finish = true;
+            if (isArr) {
+                offsets.push(arr.slice(1, 4));
             }
-        }
-        return res;
+            else {
+                offsets.push([+arr.x, +arr.y, +arr.z]);
+            }
+        });
+    }
+    return ret;
+}
+function randomArrItem(arr, keepArr) {
+    var index = Math.floor(Math.random() * arr.length);
+    var item = arr[index];
+    if (!keepArr) {
+        arr.splice(index, 1);
+    }
+    return item;
+}
+
+var ParticleVFXItem = /** @class */ (function (_super) {
+    __extends(ParticleVFXItem, _super);
+    function ParticleVFXItem() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.destroyed = false;
+        return _this;
+    }
+    Object.defineProperty(ParticleVFXItem.prototype, "type", {
+        get: function () {
+            return ItemType$1.particle;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ParticleVFXItem.prototype.onConstructed = function (props) {
+        this.particle = props.content;
     };
-    ParticleSystem.prototype.raycast = function (options) {
-        var link = this.particleLink;
-        var mesh = this.particleMesh;
-        if (!(link && mesh)) {
-            return;
+    ParticleVFXItem.prototype.onLifetimeBegin = function (composition, particleSystem) {
+        var _this = this;
+        if (particleSystem) {
+            particleSystem.name = this.name;
+            particleSystem.start();
+            particleSystem.onDestroy = function () {
+                _this.destroyed = true;
+            };
         }
-        var node = link.last;
-        var hitPositions = [];
-        var temp = new Vector3();
-        var finish = false;
-        if (node && node.content) {
-            do {
-                var _a = __read$3(node.content, 4), currentTime = _a[0], pointIndex = _a[1]; _a[2]; var point = _a[3];
-                if (currentTime > this.timePassed) {
-                    var pos = this.getPointPosition(point);
-                    var ray = options.ray;
-                    var pass = false;
-                    if (ray) {
-                        pass = !!ray.intersectSphere({
-                            center: pos,
-                            radius: options.radius,
-                        }, temp);
-                    }
-                    if (pass) {
-                        if (options.removeParticle) {
-                            mesh.removePoint(pointIndex);
-                            this.clearPointTrail(pointIndex);
-                            node.content[0] = 0;
-                        }
-                        hitPositions.push(pos);
-                        if (!options.multiple) {
-                            finish = true;
-                        }
+        return particleSystem;
+    };
+    ParticleVFXItem.prototype.onItemUpdate = function (dt, lifetime) {
+        var _a;
+        if (this.content) {
+            var hide = !this.visible;
+            var parentItem = this.parentId && ((_a = this.composition) === null || _a === void 0 ? void 0 : _a.getItemByID(this.parentId));
+            if (!hide && parentItem) {
+                var parentData = parentItem.getRenderData();
+                if (parentData) {
+                    if (!parentData.visible) {
+                        hide = false;
                     }
                 }
-                else {
-                    break;
-                }
-                // @ts-expect-error
-            } while ((node = node.pre) && !finish);
+            }
+            if (hide) {
+                this.content.setVisible(false);
+            }
+            else {
+                this.content.setVisible(true);
+                this.content.onUpdate(dt);
+            }
         }
-        return hitPositions;
     };
-    ParticleSystem.prototype.clearPointTrail = function (pointIndex) {
-        var _a;
-        if (this.trails && this.trails.dieWithParticles) {
-            (_a = this.trailMesh) === null || _a === void 0 ? void 0 : _a.clearTrail(pointIndex);
+    ParticleVFXItem.prototype.onItemRemoved = function (composition, content) {
+        if (content) {
+            composition.destroyTextures(content.getTextures());
+            content.meshes.forEach(function (mesh) { return mesh.dispose({ material: { textures: exports.DestroyOptions.keep } }); });
         }
     };
-    ParticleSystem.prototype.updatePointTrail = function (pointIndex, emitterLifetime, point, startTime) {
-        if (!this.trailMesh) {
-            return;
+    /**
+     * @internal
+     */
+    ParticleVFXItem.prototype.setColor = function (r, g, b, a) {
+        this.content.setColor(r, g, b, a);
+    };
+    ParticleVFXItem.prototype.setOpacity = function (opacity) {
+        this.content.setOpacity(opacity);
+    };
+    ParticleVFXItem.prototype.stopParticleEmission = function () {
+        if (this.content) {
+            this.content.emissionStopped = true;
         }
-        var trails = this.trails;
-        var particleMesh = this.particleMesh;
-        var position = this.getPointPosition(point);
-        var color = trails.inheritParticleColor ? particleMesh.getPointColor(pointIndex) : [1, 1, 1, 1];
-        var size = point.transform.getWorldScale().toArray();
-        var width = 1;
-        var lifetime = trails.lifetime.getValue(emitterLifetime);
-        if (trails.sizeAffectsWidth) {
-            width *= size[0];
+    };
+    ParticleVFXItem.prototype.resumeParticleEmission = function () {
+        if (this.content) {
+            this.content.emissionStopped = false;
         }
-        if (trails.sizeAffectsLifetime) {
-            lifetime *= size[0];
+    };
+    ParticleVFXItem.prototype.doCreateContent = function (composition) {
+        assertExist(this.particle);
+        return new ParticleSystem(this.particle, composition.getRendererOptions(), this);
+    };
+    ParticleVFXItem.prototype.isEnded = function (now) {
+        return _super.prototype.isEnded.call(this, now) && this.destroyed;
+    };
+    ParticleVFXItem.prototype.getBoundingBox = function () {
+        var pt = this.content;
+        if (!pt) {
+            return;
         }
-        if (trails.parentAffectsPosition && this.transform.parentTransform) {
-            position.add(this.transform.parentTransform.position);
-            var pos = this.trailMesh.getPointStartPos(pointIndex);
-            if (pos) {
-                position.subtract(pos);
-            }
+        else {
+            var area = pt.getParticleBoxes();
+            return {
+                type: exports.HitTestType.sphere,
+                area: area,
+            };
         }
-        this.trailMesh.addPoint(pointIndex, position, {
-            color: color,
-            lifetime: lifetime,
-            size: width,
-            time: startTime,
-        });
     };
-    ParticleSystem.prototype.getPointPosition = function (point) {
-        var transform = point.transform, vel = point.vel, lifetime = point.lifetime, delay = point.delay, _a = point.gravity, gravity = _a === void 0 ? [] : _a;
-        var forceTarget = this.options.forceTarget;
-        var time = this.lastUpdate - delay;
-        var tempPos = new Vector3();
-        var acc = Vector3.fromArray(gravity);
-        transform.assignWorldTRS(tempPos);
-        var ret = calculateTranslation(new Vector3(), this.options, acc, time, lifetime, tempPos, vel);
-        if (forceTarget) {
-            var target = forceTarget.target || [0, 0, 0];
-            var life = forceTarget.curve.getValue(time / lifetime);
-            var dl = 1 - life;
-            ret.x = ret.x * dl + target[0] * life;
-            ret.y = ret.y * dl + target[1] * life;
-            ret.z = ret.z * dl + target[2] * life;
+    ParticleVFXItem.prototype.getHitTestParams = function (force) {
+        var _this = this;
+        var _a;
+        var interactParams = (_a = this.content) === null || _a === void 0 ? void 0 : _a.interaction;
+        if (force || interactParams) {
+            return {
+                type: exports.HitTestType.custom,
+                collect: function (ray) {
+                    var _a;
+                    return (_a = _this.content) === null || _a === void 0 ? void 0 : _a.raycast({
+                        radius: (interactParams === null || interactParams === void 0 ? void 0 : interactParams.radius) || 0.4,
+                        multiple: !!(interactParams === null || interactParams === void 0 ? void 0 : interactParams.multiple),
+                        removeParticle: (interactParams === null || interactParams === void 0 ? void 0 : interactParams.behavior) === ParticleInteractionBehavior$1.removeParticle,
+                        ray: ray,
+                    });
+                },
+            };
         }
-        return ret;
     };
-    ParticleSystem.prototype.onEnd = function (particle) {
-    };
-    ParticleSystem.prototype.onIterate = function (particle) {
-    };
-    ParticleSystem.prototype.initPoint = function (data) {
-        var options = this.options;
-        var lifetime = this.lifetime;
-        var shape = this.shape;
-        var speed = options.startSpeed.getValue(lifetime);
-        var matrix4 = options.particleFollowParent ? this.transform.getMatrix() : this.transform.getWorldMatrix();
-        // 粒子的位置受发射器的位置影响，自身的旋转和缩放不受影响
-        var position = matrix4.transformPoint(data.position, new Vector3());
-        var transform = new Transform({
-            position: position,
-            valid: true,
-        });
-        var direction = data.direction;
-        direction = matrix4.transformNormal(direction, tempDir).normalize();
-        if (options.startTurbulence && options.turbulence) {
-            for (var i = 0; i < 3; i++) {
-                tempVec3.setElement(i, options.turbulence[i].getValue(lifetime));
-            }
-            tempEuler.setFromVector3(tempVec3.negate());
-            var mat4 = tempMat4.setFromEuler(tempEuler);
-            mat4.transformNormal(direction).normalize();
+    return ParticleVFXItem;
+}(VFXItem));
+var particleUniformTypeMap = {
+    'uSprite': 'vec4',
+    'uParams': 'vec4',
+    'uAcceleration': 'vec4',
+    'uGravityModifierValue': 'vec4',
+    'uOpacityOverLifetimeValue': 'vec4',
+    'uRXByLifeTimeValue': 'vec4',
+    'uRYByLifeTimeValue': 'vec4',
+    'uRZByLifeTimeValue': 'vec4',
+    'uLinearXByLifetimeValue': 'vec4',
+    'uLinearYByLifetimeValue': 'vec4',
+    'uLinearZByLifetimeValue': 'vec4',
+    'uSpeedLifetimeValue': 'vec4',
+    'uOrbXByLifetimeValue': 'vec4',
+    'uOrbYByLifetimeValue': 'vec4',
+    'uOrbZByLifetimeValue': 'vec4',
+    'uSizeByLifetimeValue': 'vec4',
+    'uSizeYByLifetimeValue': 'vec4',
+    'uColorParams': 'vec4',
+    'uFSprite': 'vec4',
+    'uPreviewColor': 'vec4',
+    'uVCurveValues': 'vec4Array',
+    'uFCurveValues': 'vec4',
+    'uFinalTarget': 'vec3',
+    'uForceCurve': 'vec4',
+    'uOrbCenter': 'vec3',
+    'uTexOffset': 'vec2',
+    'uPeriodValue': 'vec4',
+    'uMovementValue': 'vec4',
+    'uStrengthValue': 'vec4',
+    'uWaveParams': 'vec4',
+};
+
+var ParticleMesh = /** @class */ (function () {
+    function ParticleMesh(props, rendererOptions) {
+        var _a, _b, _c, _d;
+        this.particleCount = 0;
+        var engine = rendererOptions.composition.getEngine();
+        var env = ((_a = engine.renderer) !== null && _a !== void 0 ? _a : {}).env;
+        var speedOverLifetime = props.speedOverLifetime, colorOverLifetime = props.colorOverLifetime, linearVelOverLifetime = props.linearVelOverLifetime, orbitalVelOverLifetime = props.orbitalVelOverLifetime, sizeOverLifetime = props.sizeOverLifetime, rotationOverLifetime = props.rotationOverLifetime, sprite = props.sprite, gravityModifier = props.gravityModifier, maxCount = props.maxCount, duration = props.duration, textureFlip = props.textureFlip, useSprite = props.useSprite, name = props.name, filter = props.filter, gravity = props.gravity, forceTarget = props.forceTarget, side = props.side, occlusion = props.occlusion, anchor = props.anchor, blending = props.blending, maskMode = props.maskMode, mask = props.mask, transparentOcclusion = props.transparentOcclusion, listIndex = props.listIndex, meshSlots = props.meshSlots, _e = props.renderMode, renderMode = _e === void 0 ? 0 : _e, _f = props.diffuse, diffuse = _f === void 0 ? Texture.createWithData(engine) : _f;
+        var detail = engine.gpuCapability.detail;
+        var halfFloatTexture = detail.halfFloatTexture, maxVertexUniforms = detail.maxVertexUniforms;
+        var marcos = [
+            ['RENDER_MODE', +renderMode],
+            ['PRE_MULTIPLY_ALPHA', false],
+            ['ENV_EDITOR', env === PLAYER_OPTIONS_ENV_EDITOR],
+        ];
+        var level = engine.gpuCapability.level;
+        var vertexKeyFrameMeta = createKeyFrameMeta();
+        var fragmentKeyFrameMeta = createKeyFrameMeta();
+        var enableVertexTexture = maxVertexUniforms > 0;
+        var uniformValues = {};
+        var vertex_lookup_texture = 0;
+        var shaderCacheId = 0;
+        var particleDefine;
+        var useOrbitalVel;
+        this.useSprite = useSprite;
+        if (enableVertexTexture) {
+            marcos.push(['ENABLE_VERTEX_TEXTURE', true]);
         }
-        var dirX = tmpDirX;
-        var dirY = tmpDirY;
-        if (shape.alignSpeedDirection) {
-            dirY.copyFrom(direction);
-            if (!this.upDirectionWorld) {
-                if (shape.upDirection) {
-                    this.upDirectionWorld = shape.upDirection.clone();
+        if (speedOverLifetime) {
+            marcos.push(['SPEED_OVER_LIFETIME', true]);
+            shaderCacheId |= 1 << 1;
+            uniformValues.uSpeedLifetimeValue = speedOverLifetime.toUniform(vertexKeyFrameMeta);
+        }
+        if (sprite === null || sprite === void 0 ? void 0 : sprite.animate) {
+            marcos.push(['USE_SPRITE', true]);
+            shaderCacheId |= 1 << 2;
+            uniformValues.uFSprite = uniformValues.uSprite = new Float32Array([sprite.col, sprite.row, sprite.total, sprite.blend ? 1 : 0]);
+            this.useSprite = true;
+        }
+        if (filter && filter.name !== FILTER_NAME_NONE) {
+            marcos.push(['USE_FILTER', true]);
+            shaderCacheId |= 1 << 3;
+            var filterDefine = createFilter(filter, rendererOptions.composition);
+            if (!filterDefine.particle) {
+                throw new Error("particle filter ".concat(filter.name, " not implement"));
+            }
+            particleDefine = filterDefine.particle;
+            Object.keys((_b = particleDefine.uniforms) !== null && _b !== void 0 ? _b : {}).forEach(function (uName) {
+                var _a;
+                var getter = (_a = particleDefine.uniforms) === null || _a === void 0 ? void 0 : _a[uName];
+                if (uniformValues[uName]) {
+                    throw new Error('conflict uniform name:' + uName);
                 }
-                else {
-                    this.upDirectionWorld = Vector3.Z.clone();
+                uniformValues[uName] = getter === null || getter === void 0 ? void 0 : getter.toUniform(vertexKeyFrameMeta);
+            });
+            Object.keys((_c = particleDefine.uniformValues) !== null && _c !== void 0 ? _c : {}).forEach(function (uName) {
+                var _a;
+                var val = (_a = particleDefine.uniformValues) === null || _a === void 0 ? void 0 : _a[uName];
+                if (uniformValues[uName]) {
+                    throw new Error('conflict uniform name:' + uName);
                 }
-                matrix4.transformNormal(this.upDirectionWorld);
+                uniformValues[uName] = val;
+            });
+        }
+        if (colorOverLifetime === null || colorOverLifetime === void 0 ? void 0 : colorOverLifetime.color) {
+            marcos.push(['COLOR_OVER_LIFETIME', true]);
+            shaderCacheId |= 1 << 4;
+            uniformValues.uColorOverLifetime = colorOverLifetime.color instanceof Texture ? colorOverLifetime.color : Texture.createWithData(engine, imageDataFromGradient(colorOverLifetime.color));
+        }
+        if (colorOverLifetime === null || colorOverLifetime === void 0 ? void 0 : colorOverLifetime.opacity) {
+            uniformValues.uOpacityOverLifetimeValue = colorOverLifetime.opacity.toUniform(vertexKeyFrameMeta);
+        }
+        else {
+            uniformValues.uOpacityOverLifetimeValue = createValueGetter(1).toUniform(vertexKeyFrameMeta);
+        }
+        ['x', 'y', 'z'].forEach(function (pro, i) {
+            var defL = 0;
+            var defO = 0;
+            if (linearVelOverLifetime === null || linearVelOverLifetime === void 0 ? void 0 : linearVelOverLifetime[pro]) {
+                uniformValues["uLinear".concat(pro.toUpperCase(), "ByLifetimeValue")] = linearVelOverLifetime[pro].toUniform(vertexKeyFrameMeta);
+                defL = 1;
+                shaderCacheId |= 1 << (7 + i);
+                linearVelOverLifetime.enabled = true;
             }
-            dirX.crossVectors(dirY, this.upDirectionWorld).normalize();
-            // FIXME: 原先因为有精度问题，这里dirX不是0向量
-            if (dirX.isZero()) {
-                dirX.set(1, 0, 0);
+            marcos.push(["LINEAR_VEL_".concat(pro.toUpperCase()), defL]);
+            if (orbitalVelOverLifetime === null || orbitalVelOverLifetime === void 0 ? void 0 : orbitalVelOverLifetime[pro]) {
+                uniformValues["uOrb".concat(pro.toUpperCase(), "ByLifetimeValue")] = orbitalVelOverLifetime[pro].toUniform(vertexKeyFrameMeta);
+                defO = 1;
+                shaderCacheId |= 1 << (10 + i);
+                useOrbitalVel = true;
+                orbitalVelOverLifetime.enabled = true;
+            }
+            marcos.push(["ORB_VEL_".concat(pro.toUpperCase()), defO]);
+        });
+        if (linearVelOverLifetime === null || linearVelOverLifetime === void 0 ? void 0 : linearVelOverLifetime.asMovement) {
+            marcos.push(['AS_LINEAR_MOVEMENT', true]);
+            shaderCacheId |= 1 << 5;
+        }
+        if (useOrbitalVel) {
+            if (orbitalVelOverLifetime === null || orbitalVelOverLifetime === void 0 ? void 0 : orbitalVelOverLifetime.asRotation) {
+                marcos.push(['AS_ORBITAL_MOVEMENT', true]);
+                shaderCacheId |= 1 << 6;
             }
+            uniformValues.uOrbCenter = new Float32Array((orbitalVelOverLifetime === null || orbitalVelOverLifetime === void 0 ? void 0 : orbitalVelOverLifetime.center) || [0, 0, 0]);
         }
-        else {
-            dirX.set(1, 0, 0);
-            dirY.set(0, 1, 0);
+        uniformValues.uSizeByLifetimeValue = sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.x.toUniform(vertexKeyFrameMeta);
+        if (sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.separateAxes) {
+            marcos.push(['SIZE_Y_BY_LIFE', 1]);
+            shaderCacheId |= 1 << 14;
+            uniformValues.uSizeYByLifetimeValue = (_d = sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.y) === null || _d === void 0 ? void 0 : _d.toUniform(vertexKeyFrameMeta);
         }
-        var sprite;
-        var tsa = this.textureSheetAnimation;
-        if (tsa && tsa.animate) {
-            sprite = tempSprite;
-            sprite[0] = tsa.animationDelay.getValue(lifetime);
-            sprite[1] = tsa.animationDuration.getValue(lifetime);
-            sprite[2] = tsa.cycles.getValue(lifetime);
+        if (rotationOverLifetime === null || rotationOverLifetime === void 0 ? void 0 : rotationOverLifetime.z) {
+            uniformValues.uRZByLifeTimeValue = rotationOverLifetime.z.toUniform(vertexKeyFrameMeta);
+            shaderCacheId |= 1 << 15;
+            marcos.push(['ROT_Z_LIFETIME', 1]);
         }
-        var rot = tempRot;
-        if (options.start3DRotation) {
-            // @ts-expect-error
-            rot.set(options.startRotationX.getValue(lifetime), options.startRotationY.getValue(lifetime), options.startRotationZ.getValue(lifetime));
+        if (rotationOverLifetime === null || rotationOverLifetime === void 0 ? void 0 : rotationOverLifetime.x) {
+            uniformValues.uRXByLifeTimeValue = rotationOverLifetime.x.toUniform(vertexKeyFrameMeta);
+            shaderCacheId |= 1 << 16;
+            marcos.push(['ROT_X_LIFETIME', 1]);
         }
-        else if (options.startRotation) {
-            rot.set(0, 0, options.startRotation.getValue(lifetime));
+        if (rotationOverLifetime === null || rotationOverLifetime === void 0 ? void 0 : rotationOverLifetime.y) {
+            uniformValues.uRYByLifeTimeValue = rotationOverLifetime.y.toUniform(vertexKeyFrameMeta);
+            shaderCacheId |= 1 << 17;
+            marcos.push(['ROT_Y_LIFETIME', 1]);
         }
-        else {
-            rot.set(0, 0, 0);
+        if (rotationOverLifetime === null || rotationOverLifetime === void 0 ? void 0 : rotationOverLifetime.asRotation) {
+            marcos.push(['ROT_LIFETIME_AS_MOVEMENT', 1]);
+            shaderCacheId |= 1 << 18;
         }
-        transform.setRotation(rot.x, rot.y, rot.z);
-        var color = options.startColor.getValue(lifetime);
-        if (color.length === 3) {
-            color[3] = 1;
+        uniformValues.uGravityModifierValue = gravityModifier.toUniform(vertexKeyFrameMeta);
+        if (forceTarget) {
+            marcos.push(['FINAL_TARGET', true]);
+            shaderCacheId |= 1 << 19;
+            uniformValues.uFinalTarget = new Float32Array(forceTarget.target || [0, 0, 0]);
+            uniformValues.uForceCurve = forceTarget.curve.toUniform(vertexKeyFrameMeta);
         }
-        var size = tempSize;
-        if (options.start3DSize) {
-            size.x = options.startSizeX.getValue(lifetime);
-            size.y = options.startSizeY.getValue(lifetime);
+        if (halfFloatTexture && fragmentKeyFrameMeta.max) {
+            shaderCacheId |= 1 << 20;
+            uniformValues.uFCurveValueTexture = generateHalfFloatTexture(engine, ValueGetter.getAllData(fragmentKeyFrameMeta, true), fragmentKeyFrameMeta.index, 1);
         }
         else {
-            var n = options.startSize.getValue(lifetime);
-            var aspect = options.sizeAspect.getValue(lifetime);
-            size.x = n;
-            // 兼容aspect为0的情况
-            size.y = aspect === 0 ? 0 : n / aspect;
-            // size[1] = n / aspect;
+            uniformValues.uFCurveValues = ValueGetter.getAllData(fragmentKeyFrameMeta);
         }
-        var vel = direction.clone();
-        vel.multiply(speed);
-        // 粒子的大小受发射器父节点的影响
-        if (!options.particleFollowParent) {
-            var tempScale = new Vector3();
-            this.transform.assignWorldTRS(undefined, undefined, tempScale);
-            size.x *= tempScale.x;
-            size.y *= tempScale.y;
+        var vertexCurveTexture = vertexKeyFrameMeta.max + vertexKeyFrameMeta.curves.length - 32 > maxVertexUniforms;
+        // if (getConfig(RENDER_PREFER_LOOKUP_TEXTURE)) {
+        //   vertexCurveTexture = true;
+        // }
+        if (level === 2) {
+            vertexKeyFrameMeta.max = -1;
+            vertexKeyFrameMeta.index = meshSlots ? meshSlots[0] : getSlot(vertexKeyFrameMeta.index);
+            if (fragmentKeyFrameMeta.index > 0) {
+                fragmentKeyFrameMeta.max = -1;
+                fragmentKeyFrameMeta.index = meshSlots ? meshSlots[1] : getSlot(fragmentKeyFrameMeta.index);
+            }
         }
-        transform.setScale(size.x, size.y, 1);
-        return {
-            size: size,
-            vel: vel,
-            color: color,
-            delay: options.startDelay.getValue(lifetime),
-            lifetime: options.startLifetime.getValue(lifetime),
-            uv: randomArrItem(this.uvs, true),
-            gravity: options.gravity,
-            sprite: sprite,
-            dirY: dirY,
-            dirX: dirX,
-            transform: transform,
-        };
-    };
-    ParticleSystem.prototype.addBurst = function (burst, offsets) {
-        var willAdd = false;
-        if (!this.emission.bursts.includes(burst)) {
-            this.emission.bursts.push(burst);
-            willAdd = true;
+        if (vertexCurveTexture && halfFloatTexture && enableVertexTexture) {
+            var tex = generateHalfFloatTexture(engine, ValueGetter.getAllData(vertexKeyFrameMeta, true), vertexKeyFrameMeta.index, 1);
+            uniformValues.uVCurveValueTexture = tex;
+            vertex_lookup_texture = 1;
         }
-        if (willAdd && offsets instanceof Array) {
-            var index = this.emission.bursts.indexOf(burst);
-            this.emission.burstOffsets[index] = offsets;
-            return index;
+        else {
+            uniformValues.uVCurveValues = ValueGetter.getAllData(vertexKeyFrameMeta);
         }
-        return -1;
-    };
-    ParticleSystem.prototype.removeBurst = function (index) {
-        if (index < this.emission.bursts.length) {
-            this.emission.burstOffsets[index] = null;
-            this.emission.bursts.splice(index, 1);
+        var shaderCache = ['-p:', renderMode, shaderCacheId, vertexKeyFrameMeta.index, vertexKeyFrameMeta.max, fragmentKeyFrameMeta.index, fragmentKeyFrameMeta.max].join('+');
+        marcos.push(['VERT_CURVE_VALUE_COUNT', vertexKeyFrameMeta.index], ['FRAG_CURVE_VALUE_COUNT', fragmentKeyFrameMeta.index], ['VERT_MAX_KEY_FRAME_COUNT', vertexKeyFrameMeta.max], ['FRAG_MAX_KEY_FRAME_COUNT', fragmentKeyFrameMeta.max]);
+        var fragment = filter ? particleFrag.replace(/#pragma\s+FILTER_FRAG/, particleDefine.fragment) : particleFrag;
+        var originalVertex = "#define LOOKUP_TEXTURE_CURVE ".concat(vertex_lookup_texture, "\n").concat(particleVert);
+        var vertex = filter ? originalVertex.replace(/#pragma\s+FILTER_VERT/, particleDefine.vertex || 'void filterMain(float t){}\n') : originalVertex;
+        var shader = {
+            fragment: createShaderWithMarcos(marcos, fragment, exports.ShaderType.fragment, level),
+            vertex: createShaderWithMarcos(marcos, vertex, exports.ShaderType.vertex, level),
+            glslVersion: level === 1 ? exports.GLSLVersion.GLSL1 : exports.GLSLVersion.GLSL3,
+            shared: true,
+            cacheId: shaderCache,
+            marcos: marcos,
+            name: "particle#".concat(name),
+        };
+        if (filter) {
+            shader.cacheId += filter.name;
         }
-    };
-    ParticleSystem.prototype.createPoint = function (lifetime) {
-        var generator = {
-            total: this.emission.rateOverTime.getValue(lifetime),
-            index: this.generatedCount,
-            burstIndex: 0,
-            burstCount: 0,
+        var mtlOptions = {
+            shader: shader,
+            uniformSemantics: {
+                effects_MatrixV: 'VIEW',
+                effects_MatrixVP: 'VIEWPROJECTION',
+                uEditorTransform: 'EDITOR_TRANSFORM',
+                effects_ObjectToWorld: 'MODEL',
+            },
         };
-        this.generatedCount++;
-        return this.initPoint(this.shape.generate(generator));
-    };
-    return ParticleSystem;
-}());
-// array performance better for small memory than Float32Array
-var tempDir = new Vector3();
-var tempSize = new Vector2();
-var tempRot = new Euler();
-var tmpDirX = new Vector3();
-var tmpDirY = new Vector3();
-var tempVec3 = new Vector3();
-var tempEuler = new Euler();
-var tempSprite = [0, 0, 0];
-var tempMat4 = new Matrix4$1();
-function getBurstOffsets(burstOffsets) {
-    var ret = {};
-    if (Array.isArray(burstOffsets)) {
-        burstOffsets.forEach(function (arr) {
-            var isArr = arr instanceof Array;
-            var index = isArr ? arr[0] : arr.index;
-            var offsets = ret[index];
-            if (!offsets) {
-                offsets = ret[index] = [];
-            }
-            if (isArr) {
-                offsets.push(arr.slice(1, 4));
+        var preMulAlpha = getPreMultiAlpha(blending);
+        uniformValues.uTexOffset = new Float32Array(diffuse ? [1 / diffuse.getWidth(), 1 / diffuse.getHeight()] : [0, 0]);
+        uniformValues.uMaskTex = diffuse;
+        uniformValues.uColorParams = new Float32Array([diffuse ? 1 : 0, +preMulAlpha, 0, +(!!occlusion && !transparentOcclusion)]);
+        uniformValues.uParams = [0, duration, 0, 0];
+        uniformValues.uAcceleration = [(gravity === null || gravity === void 0 ? void 0 : gravity[0]) || 0, (gravity === null || gravity === void 0 ? void 0 : gravity[1]) || 0, (gravity === null || gravity === void 0 ? void 0 : gravity[2]) || 0, 0];
+        // mtlOptions.uniformValues = uniformValues;
+        var material = Material.create(engine, mtlOptions);
+        material.blending = true;
+        material.depthTest = true;
+        material.depthMask = !!(occlusion);
+        material.stencilRef = mask ? [mask, mask] : undefined;
+        setMaskMode(material, maskMode);
+        setBlendMode(material, blending);
+        setSideMode(material, side);
+        Object.keys(uniformValues).map(function (name) {
+            var value = uniformValues[name];
+            if (value instanceof Texture) {
+                material.setTexture(name, value);
+                return;
             }
-            else {
-                offsets.push([+arr.x, +arr.y, +arr.z]);
+            var res = [];
+            switch (particleUniformTypeMap[name]) {
+                case 'vec4':
+                    material.setVector4(name, Vector4$1.fromArray(value));
+                    break;
+                case 'vec3':
+                    material.setVector3(name, Vector3.fromArray(value));
+                    break;
+                case 'vec2':
+                    material.setVector2(name, Vector2.fromArray(value));
+                    break;
+                case 'vec4Array':
+                    for (var i = 0; i < value.length; i = i + 4) {
+                        var v = new Vector4$1(value[i], value[i + 1], value[i + 2], value[i + 3]);
+                        res.push(v);
+                    }
+                    material.setVector4Array(name, res);
+                    res.length = 0;
+                    break;
+                default:
+                    console.warn("uniform ".concat(name, "'s type not in typeMap"));
             }
         });
+        material.setVector3('emissionColor', new Vector3(0, 0, 0));
+        material.setFloat('emissionIntensity', 0.0);
+        var geometry = Geometry.create(engine, generateGeometryProps(maxCount * 4, this.useSprite, "particle#".concat(name)));
+        var mesh = Mesh.create(engine, {
+            name: "MParticle_".concat(name),
+            priority: listIndex,
+            material: material,
+            geometry: geometry,
+        });
+        this.anchor = anchor;
+        this.mesh = mesh;
+        this.geometry = mesh.firstGeometry();
+        this.forceTarget = forceTarget;
+        this.sizeOverLifetime = sizeOverLifetime;
+        this.speedOverLifetime = speedOverLifetime;
+        this.linearVelOverLifetime = linearVelOverLifetime;
+        this.orbitalVelOverLifetime = orbitalVelOverLifetime;
+        this.orbitalVelOverLifetime = orbitalVelOverLifetime;
+        this.gravityModifier = gravityModifier;
+        this.maxCount = maxCount;
+        this.duration = duration;
+        this.textureOffsets = textureFlip ? [0, 0, 1, 0, 0, 1, 1, 1] : [0, 1, 0, 0, 1, 1, 1, 0];
     }
-    return ret;
-}
-function randomArrItem(arr, keepArr) {
-    var index = Math.floor(Math.random() * arr.length);
-    var item = arr[index];
-    if (!keepArr) {
-        arr.splice(index, 1);
-    }
-    return item;
-}
-
-var ParticleVFXItem = /** @class */ (function (_super) {
-    __extends(ParticleVFXItem, _super);
-    function ParticleVFXItem() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.destroyed = false;
-        return _this;
-    }
-    Object.defineProperty(ParticleVFXItem.prototype, "type", {
+    Object.defineProperty(ParticleMesh.prototype, "time", {
         get: function () {
-            return ItemType$1.particle;
+            var value = this.mesh.material.getVector4('uParams');
+            return value.x;
+        },
+        set: function (v) {
+            this.mesh.material.setVector4('uParams', new Vector4$1(+v, this.duration, 0, 0));
         },
         enumerable: false,
         configurable: true
     });
-    ParticleVFXItem.prototype.onConstructed = function (props) {
-        this.particle = props.content;
+    ParticleMesh.prototype.getPointColor = function (index) {
+        var data = this.geometry.getAttributeData('aRot');
+        var i = index * 32 + 4;
+        return [data[i], data[i + 1], data[i + 2], data[i + 3]];
     };
-    ParticleVFXItem.prototype.onLifetimeBegin = function (composition, particleSystem) {
-        var _this = this;
-        if (particleSystem) {
-            particleSystem.name = this.name;
-            particleSystem.start();
-            particleSystem.onDestroy = function () {
-                _this.destroyed = true;
-            };
+    /**
+     * 待废弃
+     * @deprecated - 使用 `particle-system.getPointPosition` 替代
+     */
+    ParticleMesh.prototype.getPointPosition = function (index) {
+        var geo = this.geometry;
+        var posIndex = index * 48;
+        var posData = geo.getAttributeData('aPos');
+        var offsetData = geo.getAttributeData('aOffset');
+        var time = this.time - offsetData[index * 16 + 2];
+        var pointDur = offsetData[index * 16 + 3];
+        var mtl = this.mesh.material;
+        var acc = mtl.getVector4('uAcceleration').toVector3();
+        var pos = Vector3.fromArray(posData, posIndex);
+        var vel = Vector3.fromArray(posData, posIndex + 3);
+        var ret = calculateTranslation(new Vector3(), this, acc, time, pointDur, pos, vel);
+        if (this.forceTarget) {
+            var target = mtl.getVector3('uFinalTarget');
+            var life = this.forceTarget.curve.getValue(time / pointDur);
+            var dl = 1 - life;
+            ret.x = ret.x * dl + target.x * life;
+            ret.y = ret.y * dl + target.y * life;
+            ret.z = ret.z * dl + target.z * life;
         }
-        return particleSystem;
+        return ret;
     };
-    ParticleVFXItem.prototype.onItemUpdate = function (dt, lifetime) {
-        var _a;
-        if (this.content) {
-            var hide = !this.visible;
-            var parentItem = this.parentId && ((_a = this.composition) === null || _a === void 0 ? void 0 : _a.getItemByID(this.parentId));
-            if (!hide && parentItem) {
-                var parentData = parentItem.getRenderData();
-                if (parentData) {
-                    if (!parentData.visible) {
-                        hide = false;
-                    }
+    ParticleMesh.prototype.clearPoints = function () {
+        this.resetGeometryData(this.geometry);
+        this.particleCount = 0;
+        this.geometry.setDrawCount(0);
+        this.maxParticleBufferCount = 0;
+    };
+    ParticleMesh.prototype.resetGeometryData = function (geometry) {
+        var names = geometry.getAttributeNames();
+        var index = geometry.getIndexData();
+        for (var i = 0; i < names.length; i++) {
+            var name_1 = names[i];
+            var data = geometry.getAttributeData(name_1);
+            if (data) {
+                // @ts-expect-error
+                geometry.setAttributeData(name_1, new data.constructor(0));
+            }
+        }
+        // @ts-expect-error
+        geometry.setIndexData(new index.constructor(0));
+    };
+    ParticleMesh.prototype.minusTime = function (time) {
+        var data = this.geometry.getAttributeData('aOffset');
+        for (var i = 0; i < data.length; i += 4) {
+            data[i + 2] -= time;
+        }
+        this.geometry.setAttributeData('aOffset', data);
+        this.time -= time;
+    };
+    ParticleMesh.prototype.removePoint = function (index) {
+        if (index < this.particleCount) {
+            this.geometry.setAttributeSubData('aOffset', index * 16, new Float32Array(16));
+        }
+    };
+    ParticleMesh.prototype.setPoint = function (point, index) {
+        var maxCount = this.maxCount;
+        if (index < maxCount) {
+            var particleCount = index + 1;
+            var vertexCount_1 = particleCount * 4;
+            var geometry_1 = this.geometry;
+            var increaseBuffer_1 = particleCount > this.maxParticleBufferCount;
+            var inc_1 = 1;
+            if (this.particleCount > 300) {
+                inc_1 = (this.particleCount + 100) / this.particleCount;
+            }
+            else if (this.particleCount > 100) {
+                inc_1 = 1.4;
+            }
+            else if (this.particleCount > 0) {
+                inc_1 = 2;
+            }
+            var pointData_1 = {
+                aPos: new Float32Array(48),
+                aRot: new Float32Array(32),
+                aOffset: new Float32Array(16),
+            };
+            var useSprite = this.useSprite;
+            if (useSprite) {
+                pointData_1.aSprite = new Float32Array(12);
+            }
+            var tempPos = new Vector3();
+            var tempQuat = new Quaternion();
+            var scale = new Vector3(1, 1, 1);
+            point.transform.assignWorldTRS(tempPos, tempQuat, scale);
+            var tempEuler = Transform.getRotation(tempQuat, new Euler());
+            var position = tempPos.toArray();
+            var rotation = tempEuler.toArray();
+            var offsets = this.textureOffsets;
+            var off = [0, 0, point.delay, point.lifetime];
+            var wholeUV = [0, 0, 1, 1];
+            var vel = point.vel;
+            var color = point.color;
+            var sizeOffsets = [-.5, .5, -.5, -.5, .5, .5, .5, -.5];
+            var seed = Math.random();
+            var sprite = void 0;
+            if (useSprite) {
+                sprite = point.sprite;
+            }
+            for (var j = 0; j < 4; j++) {
+                var offset = j * 2;
+                var j3 = j * 3;
+                var j4 = j * 4;
+                var j12 = j * 12;
+                var j8 = j * 8;
+                pointData_1.aPos.set(position, j12);
+                vel.fill(pointData_1.aPos, j12 + 3);
+                pointData_1.aRot.set(rotation, j8);
+                pointData_1.aRot[j8 + 3] = seed;
+                pointData_1.aRot.set(color, j8 + 4);
+                if (useSprite) {
+                    // @ts-expect-error
+                    pointData_1.aSprite.set(sprite, j3);
+                }
+                var uv = point.uv || wholeUV;
+                if (uv) {
+                    var uvy = useSprite ? (1 - offsets[offset + 1]) : offsets[offset + 1];
+                    off[0] = uv[0] + offsets[offset] * uv[2];
+                    off[1] = uv[1] + uvy * uv[3];
+                }
+                pointData_1.aOffset.set(off, j4);
+                var ji = (j + j);
+                var sx = (sizeOffsets[ji] - this.anchor.x) * scale.x;
+                var sy = (sizeOffsets[ji + 1] - this.anchor.y) * scale.y;
+                for (var k = 0; k < 3; k++) {
+                    pointData_1.aPos[j12 + 6 + k] = point.dirX.getElement(k) * sx;
+                    pointData_1.aPos[j12 + 9 + k] = point.dirY.getElement(k) * sy;
                 }
             }
-            if (hide) {
-                this.content.setVisible(false);
+            var indexData = new Uint16Array([0, 1, 2, 2, 1, 3].map(function (x) { return x + index * 4; }));
+            if (increaseBuffer_1) {
+                var baseIndexData = geometry_1.getIndexData();
+                var idx = enlargeBuffer(baseIndexData, particleCount * 6, inc_1, maxCount * 6);
+                idx.set(indexData, index * 6);
+                geometry_1.setIndexData(idx);
+                this.maxParticleBufferCount = idx.length / 6;
             }
             else {
-                this.content.setVisible(true);
-                this.content.onUpdate(dt);
+                geometry_1.setIndexSubData(index * 6, indexData);
             }
+            Object.keys(pointData_1).forEach(function (name) {
+                var data = pointData_1[name];
+                var attrSize = geometry_1.getAttributeStride(name) / Float32Array.BYTES_PER_ELEMENT;
+                if (increaseBuffer_1) {
+                    var baseData = geometry_1.getAttributeData(name);
+                    var geoData = enlargeBuffer(baseData, vertexCount_1 * attrSize, inc_1, maxCount * 4 * attrSize);
+                    geoData.set(data, data.length * index);
+                    geometry_1.setAttributeData(name, geoData);
+                }
+                else {
+                    geometry_1.setAttributeSubData(name, data.length * index, data);
+                }
+            });
+            this.particleCount = Math.max(particleCount, this.particleCount);
+            geometry_1.setDrawCount(this.particleCount * 6);
+        }
+    };
+    return ParticleMesh;
+}());
+var gl2UniformSlots = [10, 32, 64, 160];
+function getSlot(count) {
+    for (var w = 0; w < gl2UniformSlots.length; w++) {
+        var slot = gl2UniformSlots[w];
+        if (slot > count) {
+            return slot;
+        }
+    }
+    return count || gl2UniformSlots[0];
+}
+function generateGeometryProps(maxVertex, useSprite, name) {
+    var bpe = Float32Array.BYTES_PER_ELEMENT;
+    var j12 = bpe * 12;
+    var attributes = {
+        aPos: { size: 3, offset: 0, stride: j12, data: new Float32Array(0) },
+        aVel: { size: 3, offset: 3 * bpe, stride: j12, dataSource: 'aPos' },
+        aDirX: { size: 3, offset: 6 * bpe, stride: j12, dataSource: 'aPos' },
+        aDirY: { size: 3, offset: 9 * bpe, stride: j12, dataSource: 'aPos' },
+        //
+        aRot: { size: 3, offset: 0, stride: 8 * bpe, data: new Float32Array(0) },
+        aSeed: { size: 1, offset: 3 * bpe, stride: 8 * bpe, dataSource: 'aRot' },
+        aColor: { size: 4, offset: 4 * bpe, stride: 8 * bpe, dataSource: 'aRot' },
+        //
+        aOffset: { size: 4, stride: 4 * bpe, data: new Float32Array(0) },
+    };
+    if (useSprite) {
+        attributes['aSprite'] = { size: 3, data: new Float32Array(0) };
+    }
+    return { attributes: attributes, indices: { data: new Uint16Array(0) }, name: name, maxVertex: maxVertex };
+}
+function getParticleMeshShader(item, env, gpuCapability) {
+    var _a, _b, _c, _d, _e;
+    if (env === void 0) { env = ''; }
+    var props = item.content;
+    var renderMode = +(((_a = props.renderer) === null || _a === void 0 ? void 0 : _a.renderMode) || 0);
+    var marcos = [
+        ['RENDER_MODE', renderMode],
+        ['PRE_MULTIPLY_ALPHA', false],
+        ['ENV_EDITOR', env === PLAYER_OPTIONS_ENV_EDITOR],
+    ];
+    var level = gpuCapability.level, detail = gpuCapability.detail;
+    var vertexKeyFrameMeta = createKeyFrameMeta();
+    var fragmentKeyFrameMeta = createKeyFrameMeta();
+    var enableVertexTexture = detail.maxVertexUniforms > 0;
+    var speedOverLifetime = ((_b = props.positionOverLifetime) !== null && _b !== void 0 ? _b : {}).speedOverLifetime;
+    var vertex_lookup_texture = 0;
+    var shaderCacheId = 0;
+    if (enableVertexTexture) {
+        marcos.push(['ENABLE_VERTEX_TEXTURE', true]);
+    }
+    if (speedOverLifetime) {
+        marcos.push(['SPEED_OVER_LIFETIME', true]);
+        shaderCacheId |= 1 << 1;
+        getKeyFrameMetaByRawValue(vertexKeyFrameMeta, speedOverLifetime);
+    }
+    var sprite = props.textureSheetAnimation;
+    if (sprite && sprite.animate) {
+        marcos.push(['USE_SPRITE', true]);
+        shaderCacheId |= 1 << 2;
+    }
+    var filter = undefined;
+    if (props.filter && props.filter.name !== FILTER_NAME_NONE) {
+        marcos.push(['USE_FILTER', true]);
+        shaderCacheId |= 1 << 3;
+        var f = createFilterShaders(props.filter).find(function (f) { return f.isParticle; });
+        if (!f) {
+            throw Error("particle filter ".concat(props.filter.name, " not implement"));
         }
-    };
-    ParticleVFXItem.prototype.onItemRemoved = function (composition, content) {
-        if (content) {
-            composition.destroyTextures(content.getTextures());
-            content.meshes.forEach(function (mesh) { return mesh.dispose({ material: { textures: exports.DestroyOptions.keep } }); });
+        filter = f;
+        (_c = f.uniforms) === null || _c === void 0 ? void 0 : _c.forEach(function (val) { return getKeyFrameMetaByRawValue(vertexKeyFrameMeta, val); });
+        // filter = processFilter(props.filter, fragmentKeyFrameMeta, vertexKeyFrameMeta, options);
+    }
+    var colorOverLifetime = props.colorOverLifetime;
+    if (colorOverLifetime && colorOverLifetime.color) {
+        marcos.push(['COLOR_OVER_LIFETIME', true]);
+        shaderCacheId |= 1 << 4;
+    }
+    var opacity = colorOverLifetime && colorOverLifetime.opacity;
+    if (opacity) {
+        getKeyFrameMetaByRawValue(vertexKeyFrameMeta, opacity);
+    }
+    var positionOverLifetime = props.positionOverLifetime;
+    var useOrbitalVel;
+    ['x', 'y', 'z'].forEach(function (pro, i) {
+        var defL = 0;
+        var linearPro = 'linear' + pro.toUpperCase();
+        var orbitalPro = 'orbital' + pro.toUpperCase();
+        if (positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime[linearPro]) {
+            getKeyFrameMetaByRawValue(vertexKeyFrameMeta, positionOverLifetime[linearPro]);
+            defL = 1;
+            shaderCacheId |= 1 << (7 + i);
         }
-    };
-    /**
-     * @internal
-     */
-    ParticleVFXItem.prototype.setColor = function (r, g, b, a) {
-        this.content.setColor(r, g, b, a);
-    };
-    ParticleVFXItem.prototype.setOpacity = function (opacity) {
-        this.content.setOpacity(opacity);
-    };
-    ParticleVFXItem.prototype.stopParticleEmission = function () {
-        if (this.content) {
-            this.content.emissionStopped = true;
+        marcos.push(["LINEAR_VEL_".concat(pro.toUpperCase()), defL]);
+        var defO = 0;
+        if (positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime[orbitalPro]) {
+            getKeyFrameMetaByRawValue(vertexKeyFrameMeta, positionOverLifetime[orbitalPro]);
+            defO = 1;
+            shaderCacheId |= 1 << (10 + i);
+            useOrbitalVel = true;
         }
-    };
-    ParticleVFXItem.prototype.resumeParticleEmission = function () {
-        if (this.content) {
-            this.content.emissionStopped = false;
+        marcos.push(["ORB_VEL_".concat(pro.toUpperCase()), defO]);
+    });
+    if (positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime.asMovement) {
+        marcos.push(['AS_LINEAR_MOVEMENT', true]);
+        shaderCacheId |= 1 << 5;
+    }
+    if (useOrbitalVel) {
+        if (positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime.asRotation) {
+            marcos.push(['AS_ORBITAL_MOVEMENT', true]);
+            shaderCacheId |= 1 << 6;
         }
-    };
-    ParticleVFXItem.prototype.doCreateContent = function (composition) {
-        assertExist(this.particle);
-        return new ParticleSystem(this.particle, composition.getRendererOptions(), this);
-    };
-    ParticleVFXItem.prototype.isEnded = function (now) {
-        return _super.prototype.isEnded.call(this, now) && this.destroyed;
-    };
-    ParticleVFXItem.prototype.getBoundingBox = function () {
-        var pt = this.content;
-        if (!pt) {
-            return;
+    }
+    var sizeOverLifetime = props.sizeOverLifetime;
+    getKeyFrameMetaByRawValue(vertexKeyFrameMeta, sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.x);
+    if (sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.separateAxes) {
+        marcos.push(['SIZE_Y_BY_LIFE', 1]);
+        shaderCacheId |= 1 << 14;
+        getKeyFrameMetaByRawValue(vertexKeyFrameMeta, sizeOverLifetime === null || sizeOverLifetime === void 0 ? void 0 : sizeOverLifetime.y);
+    }
+    var rot = props.rotationOverLifetime;
+    if (rot === null || rot === void 0 ? void 0 : rot.z) {
+        getKeyFrameMetaByRawValue(vertexKeyFrameMeta, rot === null || rot === void 0 ? void 0 : rot.z);
+        shaderCacheId |= 1 << 15;
+        marcos.push(['ROT_Z_LIFETIME', 1]);
+    }
+    if (rot === null || rot === void 0 ? void 0 : rot.separateAxes) {
+        if (rot.x) {
+            getKeyFrameMetaByRawValue(vertexKeyFrameMeta, rot.x);
+            shaderCacheId |= 1 << 16;
+            marcos.push(['ROT_X_LIFETIME', 1]);
         }
-        else {
-            var area = pt.getParticleBoxes();
-            return {
-                type: exports.HitTestType.sphere,
-                area: area,
-            };
+        if (rot.y) {
+            getKeyFrameMetaByRawValue(vertexKeyFrameMeta, rot.y);
+            shaderCacheId |= 1 << 17;
+            marcos.push(['ROT_Y_LIFETIME', 1]);
         }
-    };
-    ParticleVFXItem.prototype.getHitTestParams = function (force) {
-        var _this = this;
-        var _a;
-        var interactParams = (_a = this.content) === null || _a === void 0 ? void 0 : _a.interaction;
-        if (force || interactParams) {
-            return {
-                type: exports.HitTestType.custom,
-                collect: function (ray) {
-                    var _a;
-                    return (_a = _this.content) === null || _a === void 0 ? void 0 : _a.raycast({
-                        radius: (interactParams === null || interactParams === void 0 ? void 0 : interactParams.radius) || 0.4,
-                        multiple: !!(interactParams === null || interactParams === void 0 ? void 0 : interactParams.multiple),
-                        removeParticle: (interactParams === null || interactParams === void 0 ? void 0 : interactParams.behavior) === ParticleInteractionBehavior$1.removeParticle,
-                        ray: ray,
-                    });
-                },
-            };
+    }
+    if (rot === null || rot === void 0 ? void 0 : rot.asRotation) {
+        marcos.push(['ROT_LIFETIME_AS_MOVEMENT', 1]);
+        shaderCacheId |= 1 << 18;
+    }
+    getKeyFrameMetaByRawValue(vertexKeyFrameMeta, positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime.gravityOverLifetime);
+    var forceOpt = positionOverLifetime === null || positionOverLifetime === void 0 ? void 0 : positionOverLifetime.forceTarget;
+    if (forceOpt) {
+        marcos.push(['FINAL_TARGET', true]);
+        shaderCacheId |= 1 << 19;
+        getKeyFrameMetaByRawValue(vertexKeyFrameMeta, positionOverLifetime.forceCurve);
+    }
+    var HALF_FLOAT = detail.halfFloatTexture;
+    if (HALF_FLOAT && fragmentKeyFrameMeta.max) {
+        shaderCacheId |= 1 << 20;
+    }
+    var maxVertexUniforms = detail.maxVertexUniforms;
+    var vertexCurveTexture = vertexKeyFrameMeta.max + vertexKeyFrameMeta.curves.length - 32 > maxVertexUniforms;
+    if (getConfig(RENDER_PREFER_LOOKUP_TEXTURE)) {
+        vertexCurveTexture = true;
+    }
+    if (level === 2) {
+        vertexKeyFrameMeta.max = -1;
+        // vertexKeyFrameMeta.index = getSlot(vertexKeyFrameMeta.index);
+        if (fragmentKeyFrameMeta.index > 0) {
+            fragmentKeyFrameMeta.max = -1;
+            // fragmentKeyFrameMeta.index = getSlot(fragmentKeyFrameMeta.index);
         }
+    }
+    if (vertexCurveTexture && HALF_FLOAT && enableVertexTexture) {
+        vertex_lookup_texture = 1;
+    }
+    var shaderCache = ['-p:', renderMode, shaderCacheId, vertexKeyFrameMeta.index, vertexKeyFrameMeta.max, fragmentKeyFrameMeta.index, fragmentKeyFrameMeta.max].join('+');
+    var shader = {
+        fragment: particleFrag,
+        vertex: "#define LOOKUP_TEXTURE_CURVE ".concat(vertex_lookup_texture, "\n").concat(particleVert),
+        shared: true,
+        cacheId: shaderCache,
+        marcos: marcos,
+        name: "particle#".concat(item.name),
     };
-    return ParticleVFXItem;
-}(VFXItem));
+    if (filter) {
+        shader.fragment = shader.fragment.replace(/#pragma\s+FILTER_FRAG/, (_d = filter.fragment) !== null && _d !== void 0 ? _d : '');
+        shader.vertex = shader.vertex.replace(/#pragma\s+FILTER_VERT/, filter.vertex || 'void filterMain(float t){}\n');
+        shader.cacheId += '+' + ((_e = props.filter) === null || _e === void 0 ? void 0 : _e.name);
+    }
+    marcos.push(['VERT_CURVE_VALUE_COUNT', vertexKeyFrameMeta.index], ['FRAG_CURVE_VALUE_COUNT', fragmentKeyFrameMeta.index], ['VERT_MAX_KEY_FRAME_COUNT', vertexKeyFrameMeta.max], ['FRAG_MAX_KEY_FRAME_COUNT', fragmentKeyFrameMeta.max]);
+    return { shader: shader, vertex: vertexKeyFrameMeta.index, fragment: fragmentKeyFrameMeta.index };
+}
+function modifyMaxKeyframeShader(shader, maxVertex, maxFrag) {
+    var _a;
+    var shaderIds = (_a = shader.cacheId) === null || _a === void 0 ? void 0 : _a.split('+');
+    shaderIds[3] = maxVertex;
+    shaderIds[5] = maxFrag;
+    shader.cacheId = shaderIds.join('+');
+    if (!shader.marcos) {
+        return;
+    }
+    for (var i = 0; i < shader.marcos.length; i++) {
+        var marco = shader.marcos[i];
+        if (marco[0] === 'VERT_CURVE_VALUE_COUNT') {
+            marco[1] = maxVertex;
+        }
+        else if (marco[0] === 'FRAG_CURVE_VALUE_COUNT') {
+            marco[1] = maxFrag;
+            break;
+        }
+    }
+}
 
 var ParticleLoader = /** @class */ (function (_super) {
     __extends(ParticleLoader, _super);
@@ -21577,7 +22020,7 @@ var filters = {
  * Name: @galacean/effects-specification
  * Description: Galacean Effects JSON Specification
  * Author: Ant Group CO., Ltd.
- * Version: v1.1.0
+ * Version: v1.2.0-beta.0
  */
 
 /*********************************************/
@@ -22338,15 +22781,27 @@ function ensureFixedNumber(a) {
         return [ValueType.CONSTANT, a];
     }
     if (a) {
-        if (a[0] === 'lines') {
+        var valueType = a[0];
+        var valueData = a[1];
+        if (Array.isArray(valueType)) {
+            // 没有数据类型的数据
+            return;
+        }
+        if (valueType === 'static' || valueType === ValueType.CONSTANT) {
+            return [ValueType.CONSTANT, a[1]];
+        }
+        if (valueType === 'lines') {
             return [ValueType.LINE, a[1]];
         }
-        if (a[0] === 'curve') {
-            return [ValueType.CURVE, a[1]];
+        if (valueType === ValueType.LINE) {
+            // @ts-expect-error
+            var keyframes = valueData.map(function (data) { return [BezierKeyframeType.LINE, data]; });
+            return [ValueType.BEZIER_CURVE, keyframes];
         }
-        if (a[0] === 'static') {
-            return [ValueType.CONSTANT, a[1]];
+        if (valueType === 'curve' || valueType === ValueType.CURVE) {
+            return [ValueType.BEZIER_CURVE, getBezierCurveFromHermiteInGE(valueData)];
         }
+        return a;
     }
 }
 function ensureFixedNumberWithRandom(a, p) {
@@ -22372,6 +22827,7 @@ function ensureColorExpression(a, normalized) {
         else if (a[0] === 'color') {
             return [ValueType.RGBA_COLOR, colorToArr(a[1], normalized)];
         }
+        return a;
     }
 }
 function ensureNumberExpression(a) {
@@ -22439,6 +22895,9 @@ function parsePercent(c) {
 }
 function getGradientColor(color, normalized) {
     if (Array.isArray(color)) {
+        if (color[0] === ValueType.GRADIENT_COLOR) {
+            return color;
+        }
         // @ts-expect-error
         return (color[0] === 'gradient' || color[0] === 'color') && ensureGradient(color[1], normalized);
     }
@@ -22451,12 +22910,36 @@ function ensureFixedVec3(a) {
         if (a.length === 3) {
             return [ValueType.CONSTANT_VEC3, a];
         }
-        if (a[0] === 'path') {
-            return [ValueType.LINEAR_PATH, a[1]];
-        }
-        if (a[0] === 'bezier') {
-            return [ValueType.BEZIER_PATH, a[1]];
+        var valueType = a[0];
+        if (valueType === 'path' ||
+            valueType === 'bezier' ||
+            valueType === ValueType.BEZIER_PATH ||
+            valueType === ValueType.LINEAR_PATH) {
+            var valueData = a[1];
+            var easing = valueData[0];
+            var points = valueData[1];
+            var controlPoints = valueData[2];
+            var bezierEasing = getBezierCurveFromHermiteInGE(easing);
+            // linear path没有controlPoints
+            if (!controlPoints) {
+                controlPoints = [];
+                for (var keyframeIndex = 0; keyframeIndex < points.length; keyframeIndex++) {
+                    var point = points[keyframeIndex].slice();
+                    if (keyframeIndex === 0) {
+                        controlPoints.push(point);
+                    }
+                    else if (keyframeIndex < points.length - 1) {
+                        controlPoints.push(point);
+                        controlPoints.push(point);
+                    }
+                    else {
+                        controlPoints.push(point);
+                    }
+                }
+            }
+            return [ValueType.BEZIER_CURVE_PATH, [bezierEasing, points, controlPoints]];
         }
+        return a;
     }
 }
 function objectValueToNumber(o) {
@@ -22546,6 +23029,50 @@ function rotationZYXFromQuat(out, quat) {
     }
     return out;
 }
+function getBezierCurveFromHermite(m0, m1, p0, p3) {
+    var xStart = p0[0];
+    var yStart = p0[1];
+    var xEnd = p3[0];
+    var yEnd = p3[1];
+    var dt = xEnd - xStart;
+    m0 = m0 * dt;
+    m1 = m1 * dt;
+    var bezierControlPoints = [[xStart + (xEnd - xStart) / 3, yStart + m0 / 3], [xEnd - (xEnd - xStart) / 3, yEnd - m1 / 3]];
+    return bezierControlPoints;
+}
+function getBezierCurveFromHermiteInGE(geHermiteCurves) {
+    var ymax = -1000000;
+    var ymin = 1000000;
+    for (var i = 0; i < geHermiteCurves.length; i++) {
+        ymax = Math.max(ymax, geHermiteCurves[i][1]);
+        ymin = Math.min(ymin, geHermiteCurves[i][1]);
+    }
+    var geBezierCurves = [[geHermiteCurves[0][0], geHermiteCurves[0][1]]];
+    for (var i = 0; i < geHermiteCurves.length - 1; i++) {
+        var m0 = geHermiteCurves[i][3] * (ymax - ymin);
+        var m1 = geHermiteCurves[i + 1][2] * (ymax - ymin);
+        var p0 = [geHermiteCurves[i][0], geHermiteCurves[i][1]];
+        var p3 = [geHermiteCurves[i + 1][0], geHermiteCurves[i + 1][1]];
+        if (p0[0] != p3[0]) {
+            var bezierControlPoints = getBezierCurveFromHermite(m0, m1, p0, p3);
+            var p1 = bezierControlPoints[0];
+            var p2 = bezierControlPoints[1];
+            geBezierCurves[geBezierCurves.length - 1].push(p1[0]);
+            geBezierCurves[geBezierCurves.length - 1].push(p1[1]);
+            geBezierCurves.push([p2[0], p2[1], p3[0], p3[1]]);
+        }
+        else {
+            geBezierCurves[geBezierCurves.length - 1].push(p3[0]);
+            geBezierCurves[geBezierCurves.length - 1].push(p3[1]);
+        }
+    }
+    // 添加关键帧类型
+    return geBezierCurves.map(function (curve, index) {
+        return index === 0 ? [BezierKeyframeType.EASE_OUT, curve]
+            : index === geBezierCurves.length - 1 ? [BezierKeyframeType.EASE_IN, curve]
+                : [BezierKeyframeType.EASE, curve];
+    });
+}
 
 function getStandardParticleContent(particle) {
     var _a;
@@ -22957,12 +23484,63 @@ function version22Migration(json) {
     });
     return json;
 }
+/**
+ * 2.5 以下版本 赫尔米特数据转换成贝塞尔数据
+ */
+function version24Migration(json) {
+    // 曲线转换成贝塞尔
+    json.compositions.map(function (comp) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(comp.items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var item = _c.value;
+                convertParam(item.content);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+    return json;
+}
+function convertParam(content) {
+    var e_2, _a;
+    try {
+        for (var _b = __values(Object.keys(content)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            var value = content[key];
+            var isArray = Array.isArray(value);
+            if (isArray && value.length === 2 && Array.isArray(value[1])) {
+                if (key === 'path') {
+                    content[key] = ensureFixedVec3(value);
+                }
+                else {
+                    content[key] = ensureFixedNumber(value);
+                }
+            }
+            else if (!isArray && typeof value === 'object') {
+                convertParam(value);
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+}
 
 var v0 = /^(\d+)\.(\d+)\.(\d+)(-(\w+)\.\d+)?$/;
 var standardVersion = /^(\d+)\.(\d+)$/;
 var reverseParticle = false;
 function getStandardJSON(json) {
-    var _a, _b;
+    var _a;
     if (!json || typeof json !== 'object') {
         throw Error('expect a json object');
     }
@@ -22972,9 +23550,14 @@ function getStandardJSON(json) {
         reverseParticle = ((_a = (/^(\d+)/).exec(json.version)) === null || _a === void 0 ? void 0 : _a[0]) === '0';
         return version21Migration(getStandardJSONFromV0(json));
     }
-    var mainVersion = (_b = standardVersion.exec(json.version)) === null || _b === void 0 ? void 0 : _b[1];
+    var vs = standardVersion.exec(json.version) || [];
+    var mainVersion = Number(vs[1]);
+    var minorVersion = Number(vs[2]);
     if (mainVersion) {
-        if (Number(mainVersion) < 2) {
+        if (mainVersion < 2 || (mainVersion === 2 && minorVersion < 4)) {
+            version24Migration(json);
+        }
+        if (mainVersion < 2) {
             return version21Migration(json);
         }
         return json;
@@ -30470,13 +31053,14 @@ Renderer.create = function (canvas, framework, renderOptions) {
 Engine.create = function (gl) {
     return new GLEngine(gl);
 };
-var version = "1.3.1";
+var version = "1.4.0-beta.0";
 logger.info('player version: ' + version);
 
 exports.AbstractPlugin = AbstractPlugin;
 exports.AssetManager = AssetManager;
 exports.BYTES_TYPE_MAP = BYTES_TYPE_MAP;
-exports.BezierSegments = BezierSegments;
+exports.BezierCurve = BezierCurve;
+exports.BezierCurvePath = BezierCurvePath;
 exports.COMPRESSED_TEXTURE = COMPRESSED_TEXTURE;
 exports.COPY_FRAGMENT_SHADER = COPY_FRAGMENT_SHADER;
 exports.COPY_MESH_SHADER_ID = COPY_MESH_SHADER_ID;
@@ -30490,7 +31074,6 @@ exports.CameraVFXItem = CameraVFXItem;
 exports.CameraVFXItemLoader = CameraVFXItemLoader;
 exports.Composition = Composition;
 exports.CompositionSourceManager = CompositionSourceManager;
-exports.CurveValue = CurveValue;
 exports.DEFAULT_FONTS = DEFAULT_FONTS;
 exports.Downloader = Downloader;
 exports.EFFECTS_COPY_MESH_NAME = EFFECTS_COPY_MESH_NAME;
@@ -30530,7 +31113,6 @@ exports.ParticleMesh = ParticleMesh;
 exports.ParticleSystem = ParticleSystem;
 exports.ParticleVFXItem = ParticleVFXItem;
 exports.PassTextureCache = PassTextureCache;
-exports.PathSegments = PathSegments;
 exports.Player = Player;
 exports.PluginSystem = PluginSystem;
 exports.QCanvasViewer = QCanvasViewer;
@@ -30609,6 +31191,7 @@ exports.createShaderWithMarcos = createShaderWithMarcos;
 exports.createShape = createShape;
 exports.createVFXItem = createVFXItem;
 exports.createValueGetter = createValueGetter;
+exports.decimalEqual = decimalEqual;
 exports.deepClone = deepClone;
 exports.defaultGlobalVolume = defaultGlobalVolume;
 exports.defaultPlugins = defaultPlugins;
@@ -30669,7 +31252,6 @@ exports.isString = isString;
 exports.isUniformStruct = isUniformStruct;
 exports.isUniformStructArray = isUniformStructArray;
 exports.isWebGL2 = isWebGL2;
-exports.itemDefine = item_define;
 exports.itemFrag = itemFrag;
 exports.itemFrameFrag = itemFrameFrag;
 exports.itemVert = itemVert;
@@ -30684,11 +31266,14 @@ exports.math = index;
 exports.modifyMaxKeyframeShader = modifyMaxKeyframeShader;
 exports.nearestPowerOfTwo = nearestPowerOfTwo;
 exports.noop = noop;
+exports.numberToFix = numberToFix;
 exports.parsePercent = parsePercent$1;
 exports.particleFrag = particleFrag;
 exports.particleOriginTranslateMap = particleOriginTranslateMap;
+exports.particleUniformTypeMap = particleUniformTypeMap;
 exports.particleVert = particleVert;
 exports.pluginLoaderMap = pluginLoaderMap;
+exports.pointOnLine = pointOnLine;
 exports.random = random;
 exports.registerFilter = registerFilter;
 exports.registerFilters = registerFilters;