@galacean/effects 1.3.1 → 1.4.0-beta.0

package/dist/weapp.mjs

@@ -676,7 +676,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
  */
 
 /*********************************************/
@@ -7293,6 +7293,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';
@@ -7300,6 +7742,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);
     };
@@ -7321,6 +7772,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) {
@@ -7483,153 +7937,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() {
@@ -7731,77 +8038,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) {
@@ -7821,9 +8298,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);
     },
@@ -7839,11 +8313,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) {
@@ -7871,53 +8354,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];
@@ -7952,6 +8388,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() {
@@ -11682,21 +12125,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";
 
@@ -15132,819 +15573,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, ShaderType.fragment, level),
-            vertex: createShaderWithMarcos(marcos, vertex, ShaderType.vertex, level),
-            glslVersion: level === 1 ? GLSLVersion.GLSL1 : 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;
@@ -17035,11 +16803,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, ShaderType.vertex, level);
         var fragment = createShaderWithMarcos(marcos, particleFrag, ShaderType.fragment, level);
@@ -17118,8 +16886,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 {
@@ -17867,456 +17637,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: 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: 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: 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, ShaderType.fragment, level),
+            vertex: createShaderWithMarcos(marcos, vertex, ShaderType.vertex, level),
+            glslVersion: level === 1 ? GLSLVersion.GLSL1 : 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: 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: 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: 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);
@@ -21567,7 +22010,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
  */
 
 /*********************************************/
@@ -22328,15 +22771,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) {
@@ -22362,6 +22817,7 @@ function ensureColorExpression(a, normalized) {
         else if (a[0] === 'color') {
             return [ValueType.RGBA_COLOR, colorToArr(a[1], normalized)];
         }
+        return a;
     }
 }
 function ensureNumberExpression(a) {
@@ -22429,6 +22885,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);
     }
@@ -22441,12 +22900,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) {
@@ -22536,6 +23019,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;
@@ -22947,12 +23474,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');
     }
@@ -22962,9 +23540,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;
@@ -30460,8 +31043,8 @@ 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);
 
-export { AbstractPlugin, AssetManager, BYTES_TYPE_MAP, BezierSegments, COMPRESSED_TEXTURE, COPY_FRAGMENT_SHADER, COPY_MESH_SHADER_ID, COPY_VERTEX_SHADER, CalculateItem, CalculateLoader, CalculateVFXItem, Camera, CameraController, CameraVFXItem, CameraVFXItemLoader, Composition, CompositionSourceManager, CurveValue, DEFAULT_FONTS, DestroyOptions, Downloader, EFFECTS_COPY_MESH_NAME, EVENT_TYPE_CLICK, EVENT_TYPE_TOUCH_END, EVENT_TYPE_TOUCH_MOVE, EVENT_TYPE_TOUCH_START, Engine, EventSystem, FILTER_NAME_NONE, FilterMode, FilterSpriteVFXItem, Float16ArrayWrapper, FrameBuffer, GLEngine, GLGeometry, GLRenderer, GLSLVersion, GPUCapability, Geometry, GlobalUniforms, GradientValue, HELP_LINK$1 as HELP_LINK, HitTestType, InteractBehavior$1 as InteractBehavior, InteractItem, InteractLoader, InteractMesh, InteractVFXItem, Item, KTXTexture, LineSegments, LinearValue, Material, MaterialDataBlock, MaterialRenderType, Mesh, OrderType, PLAYER_OPTIONS_ENV_EDITOR, POST_PROCESS_SETTINGS, ParticleLoader, ParticleMesh, ParticleSystem, ParticleVFXItem, PassTextureCache, PathSegments, Player, PluginSystem, QCanvasViewer, QText, QTextWrapMode, RENDER_PASS_NAME_PREFIX, RENDER_PREFER_LOOKUP_TEXTURE, RUNTIME_ENV, RandomSetValue, RandomValue, RandomVectorValue, RenderBuffer, RenderFrame, RenderPass, RenderPassAttachmentStorageType, RenderPassDestroyAttachmentType, RenderPassPriorityNormal, RenderPassPriorityPostprocess, RenderPassPriorityPrepare, RenderTargetHandle, RenderTextureFormat, Renderer, SEMANTIC_MAIN_PRE_COLOR_ATTACHMENT_0, SEMANTIC_MAIN_PRE_COLOR_ATTACHMENT_SIZE_0, SEMANTIC_PRE_COLOR_ATTACHMENT_0, SEMANTIC_PRE_COLOR_ATTACHMENT_SIZE_0, SPRITE_VERTEX_STRIDE, SemanticMap, Shader, ShaderCompileResultStatus, ShaderType, SpriteItem, SpriteLoader, SpriteMesh, SpriteVFXItem, StaticValue, TEMPLATE_USE_OFFSCREEN_CANVAS, TextItem, TextLoader, TextMesh, TextVFXItem, Texture, TextureFactory, TextureLoadAction, TextureSourceType, TextureStoreAction, Ticker, TimelineComponent, Transform, VFXItem, ValueGetter, addByOrder, addItem, addItemWithOrder, alphaFrameFrag, alphaMaskFrag, assertExist, asserts, blend, bloomMixVert, bloomThresholdVert, calculateTranslation, cameraMove_frag as cameraMoveFrag, cameraMoveVert, canvasPool, colorGradingFrag, colorStopsFromGradient, colorToArr$1 as colorToArr, combineImageTemplate, combineImageTemplate1, combineImageTemplate1Async, combineImageTemplate2, combineImageTemplate2Async, combineImageTemplateAsync, compatible_frag as compatibleFrag, compatible_vert as compatibleVert, convertAnchor, copyFrag, createCopyShader, createFilter, createFilterShaders, createGLContext, createKeyFrameMeta, createShaderWithMarcos, createShape, createVFXItem, createValueGetter, deepClone, defaultGlobalVolume, defaultPlugins, delayFrag, deserializeMipmapTexture, disableAllPlayer, distortionFrag, distortionVert, earcut, enlargeBuffer, ensureVec3, filters, findPreviousRenderPass, gaussianDown_frag as gaussianDownFrag, gaussianDownHFrag, gaussianDownVFrag, gaussianUpFrag, generateEmptyTypedArray, generateHalfFloatTexture, getActivePlayers, getBackgroundImage, getColorFromGradientStops, getConfig, getDefaultTemplateCanvasPool, getDefaultTextureFactory, getGeometryByShape, getGeometryTriangles, getImageItemRenderInfo, getKTXTextureOptions, getKeyFrameMetaByRawValue, getParticleMeshShader, getPixelRatio, getPlayerByCanvas, getPreMultiAlpha, getStandardComposition, getStandardImage, getStandardItem, getStandardJSON, getTextureSize, glContext, gpuTimer, imageDataFromColor, imageDataFromGradient, initErrors, initGLContext, integrate, interpolateColor, isAndroid, isArray, isCanvasUsedByPlayer, isFunction, isIOS, isObject, isScene, isSceneWithOptions, isSimulatorCellPhone, isString, isUniformStruct, isUniformStructArray, isWebGL2, item_define as itemDefine, itemFrag, itemFrameFrag, itemVert, loadBinary, loadBlob, loadImage, loadMedia, loadVideo, loadWebPOptional, logger, index as math, maxSpriteMeshItemCount, maxSpriteTextureCount, modifyMaxKeyframeShader, nearestPowerOfTwo, noop, parsePercent$1 as parsePercent, particleFrag, particleOriginTranslateMap, particleVert, pluginLoaderMap, random, registerFilter, registerFilters, registerPlugin, removeItem, requestAsync, rotateVec2, screenMeshVert, setBlendMode, setConfig, setDefaultTextureFactory, setMaskMode, setMaxSpriteMeshItemCount, setRayFromCamera, setSideMode, setSpriteMeshMaxFragmentTextures, setSpriteMeshMaxItemCountByGPU, sortByOrder, index$1 as spec, spriteMeshShaderFromFilter, spriteMeshShaderFromRenderInfo, spriteMeshShaderIdFromRenderInfo, thresholdFrag, throwDestroyedError$1 as throwDestroyedError, trailVert, translatePoint, trianglesFromRect, unregisterPlugin, valIfUndefined, value, valueDefine, vecAssign, vecFill, vecMulCombine, vecNormalize, version };
+export { AbstractPlugin, AssetManager, BYTES_TYPE_MAP, BezierCurve, BezierCurvePath, COMPRESSED_TEXTURE, COPY_FRAGMENT_SHADER, COPY_MESH_SHADER_ID, COPY_VERTEX_SHADER, CalculateItem, CalculateLoader, CalculateVFXItem, Camera, CameraController, CameraVFXItem, CameraVFXItemLoader, Composition, CompositionSourceManager, DEFAULT_FONTS, DestroyOptions, Downloader, EFFECTS_COPY_MESH_NAME, EVENT_TYPE_CLICK, EVENT_TYPE_TOUCH_END, EVENT_TYPE_TOUCH_MOVE, EVENT_TYPE_TOUCH_START, Engine, EventSystem, FILTER_NAME_NONE, FilterMode, FilterSpriteVFXItem, Float16ArrayWrapper, FrameBuffer, GLEngine, GLGeometry, GLRenderer, GLSLVersion, GPUCapability, Geometry, GlobalUniforms, GradientValue, HELP_LINK$1 as HELP_LINK, HitTestType, InteractBehavior$1 as InteractBehavior, InteractItem, InteractLoader, InteractMesh, InteractVFXItem, Item, KTXTexture, LineSegments, LinearValue, Material, MaterialDataBlock, MaterialRenderType, Mesh, OrderType, PLAYER_OPTIONS_ENV_EDITOR, POST_PROCESS_SETTINGS, ParticleLoader, ParticleMesh, ParticleSystem, ParticleVFXItem, PassTextureCache, Player, PluginSystem, QCanvasViewer, QText, QTextWrapMode, RENDER_PASS_NAME_PREFIX, RENDER_PREFER_LOOKUP_TEXTURE, RUNTIME_ENV, RandomSetValue, RandomValue, RandomVectorValue, RenderBuffer, RenderFrame, RenderPass, RenderPassAttachmentStorageType, RenderPassDestroyAttachmentType, RenderPassPriorityNormal, RenderPassPriorityPostprocess, RenderPassPriorityPrepare, RenderTargetHandle, RenderTextureFormat, Renderer, SEMANTIC_MAIN_PRE_COLOR_ATTACHMENT_0, SEMANTIC_MAIN_PRE_COLOR_ATTACHMENT_SIZE_0, SEMANTIC_PRE_COLOR_ATTACHMENT_0, SEMANTIC_PRE_COLOR_ATTACHMENT_SIZE_0, SPRITE_VERTEX_STRIDE, SemanticMap, Shader, ShaderCompileResultStatus, ShaderType, SpriteItem, SpriteLoader, SpriteMesh, SpriteVFXItem, StaticValue, TEMPLATE_USE_OFFSCREEN_CANVAS, TextItem, TextLoader, TextMesh, TextVFXItem, Texture, TextureFactory, TextureLoadAction, TextureSourceType, TextureStoreAction, Ticker, TimelineComponent, Transform, VFXItem, ValueGetter, addByOrder, addItem, addItemWithOrder, alphaFrameFrag, alphaMaskFrag, assertExist, asserts, blend, bloomMixVert, bloomThresholdVert, calculateTranslation, cameraMove_frag as cameraMoveFrag, cameraMoveVert, canvasPool, colorGradingFrag, colorStopsFromGradient, colorToArr$1 as colorToArr, combineImageTemplate, combineImageTemplate1, combineImageTemplate1Async, combineImageTemplate2, combineImageTemplate2Async, combineImageTemplateAsync, compatible_frag as compatibleFrag, compatible_vert as compatibleVert, convertAnchor, copyFrag, createCopyShader, createFilter, createFilterShaders, createGLContext, createKeyFrameMeta, createShaderWithMarcos, createShape, createVFXItem, createValueGetter, decimalEqual, deepClone, defaultGlobalVolume, defaultPlugins, delayFrag, deserializeMipmapTexture, disableAllPlayer, distortionFrag, distortionVert, earcut, enlargeBuffer, ensureVec3, filters, findPreviousRenderPass, gaussianDown_frag as gaussianDownFrag, gaussianDownHFrag, gaussianDownVFrag, gaussianUpFrag, generateEmptyTypedArray, generateHalfFloatTexture, getActivePlayers, getBackgroundImage, getColorFromGradientStops, getConfig, getDefaultTemplateCanvasPool, getDefaultTextureFactory, getGeometryByShape, getGeometryTriangles, getImageItemRenderInfo, getKTXTextureOptions, getKeyFrameMetaByRawValue, getParticleMeshShader, getPixelRatio, getPlayerByCanvas, getPreMultiAlpha, getStandardComposition, getStandardImage, getStandardItem, getStandardJSON, getTextureSize, glContext, gpuTimer, imageDataFromColor, imageDataFromGradient, initErrors, initGLContext, integrate, interpolateColor, isAndroid, isArray, isCanvasUsedByPlayer, isFunction, isIOS, isObject, isScene, isSceneWithOptions, isSimulatorCellPhone, isString, isUniformStruct, isUniformStructArray, isWebGL2, itemFrag, itemFrameFrag, itemVert, loadBinary, loadBlob, loadImage, loadMedia, loadVideo, loadWebPOptional, logger, index as math, maxSpriteMeshItemCount, maxSpriteTextureCount, modifyMaxKeyframeShader, nearestPowerOfTwo, noop, numberToFix, parsePercent$1 as parsePercent, particleFrag, particleOriginTranslateMap, particleUniformTypeMap, particleVert, pluginLoaderMap, pointOnLine, random, registerFilter, registerFilters, registerPlugin, removeItem, requestAsync, rotateVec2, screenMeshVert, setBlendMode, setConfig, setDefaultTextureFactory, setMaskMode, setMaxSpriteMeshItemCount, setRayFromCamera, setSideMode, setSpriteMeshMaxFragmentTextures, setSpriteMeshMaxItemCountByGPU, sortByOrder, index$1 as spec, spriteMeshShaderFromFilter, spriteMeshShaderFromRenderInfo, spriteMeshShaderIdFromRenderInfo, thresholdFrag, throwDestroyedError$1 as throwDestroyedError, trailVert, translatePoint, trianglesFromRect, unregisterPlugin, valIfUndefined, value, valueDefine, vecAssign, vecFill, vecMulCombine, vecNormalize, version };
 //# sourceMappingURL=weapp.mjs.map