@galacean/effects-core 2.5.0-alpha.5 → 2.5.0

package/dist/index.mjs

@@ -3,7 +3,7 @@
  * Description: Galacean Effects runtime core for the web
  * Author: Ant Group CO., Ltd.
  * Contributors: 燃然,飂兮,十弦,云垣,茂安,意绮
- * Version: v2.5.0-alpha.5
+ * Version: v2.5.0
  */
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
@@ -14166,40 +14166,60 @@ var BezierQuat = /*#__PURE__*/ function() {
     return BezierQuat;
 }();
 var BezierEasing = /*#__PURE__*/ function() {
-    function BezierEasing(mX1, mY1, mX2, mY2) {
-        this.mX1 = mX1;
-        this.mY1 = mY1;
-        this.mX2 = mX2;
-        this.mY2 = mY2;
+    function BezierEasing(control1YOrControl1X, control2YOrControl1Y, control2X, control2Y) {
         this.precomputed = false;
+        this.control1 = new Vector2();
+        this.control2 = new Vector2();
+        this.weighted = false;
+        this.isConstant = false;
         this.mSampleValues = new Array(kSplineTableSize);
+        if (control1YOrControl1X !== undefined && control2YOrControl1Y !== undefined && control2X !== undefined && control2Y !== undefined) {
+            this.control1.x = control1YOrControl1X;
+            this.control1.y = control2YOrControl1Y;
+            this.control2.x = control2X;
+            this.control2.y = control2Y;
+            this.weighted = true;
+        } else if (control1YOrControl1X !== undefined && control2YOrControl1Y !== undefined) {
+            this.control1.x = 1 / 3;
+            this.control1.y = control1YOrControl1X;
+            this.control2.x = 2 / 3;
+            this.control2.y = control2YOrControl1Y;
+        } else {
+            this.isConstant = true;
+        }
     }
     var _proto = BezierEasing.prototype;
-    _proto.precompute = function precompute() {
-        this.precomputed = true;
-        if (this.mX1 !== this.mY1 || this.mX2 !== this.mY2) {
-            this.calcSampleValues();
-        }
-    };
     _proto.getValue = function getValue(x) {
-        if (this.mX1 === this.mY1 && this.mX2 === this.mY2) {
-            return x;
-        }
-        if (isNaN(this.mY1) || isNaN(this.mY2)) {
+        if (this.isConstant) {
             return 0;
         }
+        if (this.control1.x === this.control1.y && this.control2.x === this.control2.y) {
+            return x;
+        }
         if (x === 0 || x === 1) {
             return x;
         }
+        if (!this.weighted) {
+            return this.bezierInterpolate(0, this.control1.y, this.control2.y, 1, x);
+        }
         if (!this.precomputed) {
             this.precompute();
         }
-        var value = calcBezier(this.getTForX(x), this.mY1, this.mY2);
+        var value = calcBezier(this.getTForX(x), this.control1.y, this.control2.y);
         return value;
     };
+    _proto.bezierInterpolate = function bezierInterpolate(pStart, pControl1, pControl2, pEnd, t) {
+        // Formula from Wikipedia article on Bezier curves
+        var omt = 1.0 - t;
+        var omt2 = omt * omt;
+        var omt3 = omt2 * omt;
+        var t2 = t * t;
+        var t3 = t2 * t;
+        return pStart * omt3 + pControl1 * omt2 * t * 3.0 + pControl2 * omt * t2 * 3.0 + pEnd * t3;
+    };
     _proto.calcSampleValues = function calcSampleValues() {
         for(var i = 0; i < kSplineTableSize; ++i){
-            this.mSampleValues[i] = calcBezier(i * kSampleStepSize, this.mX1, this.mX2);
+            this.mSampleValues[i] = calcBezier(i * kSampleStepSize, this.control1.x, this.control2.x);
         }
     };
     _proto.getTForX = function getTForX(aX) {
@@ -14212,14 +14232,20 @@ var BezierEasing = /*#__PURE__*/ function() {
         // 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);
+        var initialSlope = getSlope(guessForT, this.control1.x, this.control2.x);
         if (initialSlope >= NEWTON_MIN_SLOPE) {
-            return newtonRaphsonIterate(aX, guessForT, this.mX1, this.mX2);
+            return newtonRaphsonIterate(aX, guessForT, this.control1.x, this.control2.x);
         }
         if (initialSlope === 0.0) {
             return guessForT;
         }
-        return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, this.mX1, this.mX2);
+        return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, this.control1.x, this.control2.x);
+    };
+    _proto.precompute = function precompute() {
+        this.precomputed = true;
+        if (this.control1.x !== this.control1.y || this.control2.x !== this.control2.y) {
+            this.calcSampleValues();
+        }
     };
     return BezierEasing;
 }();
@@ -14778,148 +14804,6 @@ var LineSegments = /*#__PURE__*/ function(ValueGetter) {
     };
     return LineSegments;
 }(ValueGetter);
-var BezierCurve = /*#__PURE__*/ function(ValueGetter) {
-    _inherits(BezierCurve, ValueGetter);
-    function BezierCurve() {
-        return ValueGetter.apply(this, arguments);
-    }
-    var _proto = BezierCurve.prototype;
-    _proto.onCreate = function onCreate(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 _buildEasingCurve = buildEasingCurve(leftKeyframe, rightKeyframe), points = _buildEasingCurve.points, curve = _buildEasingCurve.curve, timeInterval = _buildEasingCurve.timeInterval, valueInterval = _buildEasingCurve.valueInterval;
-            var s = points[0];
-            var e = points[points.length - 1];
-            this.keys.push([].concat(s.toArray(), points[1].toArray()));
-            this.keys.push([].concat(e.toArray(), points[2].toArray()));
-            this.curveMap[s.x + "&" + e.x] = {
-                points: points,
-                timeInterval: timeInterval,
-                valueInterval: valueInterval,
-                curve: curve,
-                timeStart: Number(s.x),
-                timeEnd: Number(e.x)
-            };
-        }
-        this.startKeyframe = keyframes[0];
-        this.endKeyframe = keyframes[keyframes.length - 1];
-        this.keyTimeData = Object.keys(this.curveMap);
-    };
-    _proto.getValue = function getValue(time) {
-        var result = 0;
-        var keyTimeData = this.keyTimeData;
-        var keyTimeStart = this.curveMap[keyTimeData[0]].timeStart;
-        var keyTimeEnd = this.curveMap[keyTimeData[keyTimeData.length - 1]].timeEnd;
-        if (time <= keyTimeStart) {
-            keyframeInfo.getPointIndexInCurve(this.startKeyframe, keyframeInfo.pointIndexCache);
-            return this.startKeyframe[1][keyframeInfo.pointIndexCache.yIndex];
-        }
-        if (time >= keyTimeEnd) {
-            keyframeInfo.getPointIndexInCurve(this.endKeyframe, keyframeInfo.pointIndexCache);
-            return this.endKeyframe[1][keyframeInfo.pointIndexCache.yIndex];
-        }
-        for(var i = 0; i < keyTimeData.length; i++){
-            var xMin = this.curveMap[keyTimeData[i]].timeStart;
-            var xMax = this.curveMap[keyTimeData[i]].timeEnd;
-            // const [xMin, xMax] = keyTimeData[i].split('&');
-            if (time >= Number(xMin) && time < Number(xMax)) {
-                result = this.getCurveValue(keyTimeData[i], time);
-                break;
-            }
-        }
-        return result;
-    };
-    _proto.getIntegrateValue = function getIntegrateValue(t0, t1, ts) {
-        if (ts === void 0) ts = 1;
-        var time = (t1 - t0) / ts;
-        var result = 0;
-        var keyTimeData = Object.keys(this.curveMap);
-        var keyTimeStart = this.curveMap[keyTimeData[0]].timeStart;
-        if (time <= keyTimeStart) {
-            return 0;
-        }
-        for(var i = 0; i < keyTimeData.length; i++){
-            var xMin = this.curveMap[keyTimeData[i]].timeStart;
-            var xMax = this.curveMap[keyTimeData[i]].timeEnd;
-            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 result;
-    };
-    _proto.getIntegrateByTime = function getIntegrateByTime(t0, t1) {
-        return this.getIntegrateValue(0, t1) - this.getIntegrateValue(0, t0);
-    };
-    // 速度变化曲线面板移除后下线
-    _proto.getCurveIntegrateValue = function getCurveIntegrateValue(curveKey, time) {
-        var curveInfo = this.curveMap[curveKey];
-        var _curveInfo_points = curveInfo.points, p0 = _curveInfo_points[0];
-        var timeInterval = curveInfo.timeInterval;
-        var valueInterval = curveInfo.valueInterval;
-        var segments = 20;
-        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;
-            }
-        }
-        total *= h / 3;
-        return total;
-    };
-    _proto.getCurveValue = function getCurveValue(curveKey, time) {
-        var curveInfo = this.curveMap[curveKey];
-        var _curveInfo_points = curveInfo.points, p0 = _curveInfo_points[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;
-    };
-    _proto.toUniform = function toUniform(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
-        ]);
-    };
-    _proto.toData = function toData() {
-        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;
-    };
-    _proto.getMaxTime = function getMaxTime() {
-        var keyTimeData = this.keyTimeData;
-        return this.curveMap[keyTimeData[keyTimeData.length - 1]].timeEnd;
-    };
-    return BezierCurve;
-}(ValueGetter);
 var PathSegments = /*#__PURE__*/ function(ValueGetter) {
     _inherits(PathSegments, ValueGetter);
     function PathSegments() {
@@ -15273,6 +15157,292 @@ var Vector2Curve = /*#__PURE__*/ function(ValueGetter) {
     return Vector2Curve;
 }(ValueGetter);
 
+var TangentMode;
+(function(TangentMode) {
+    TangentMode[TangentMode["Cubic"] = 0] = "Cubic";
+    TangentMode[TangentMode["Linear"] = 1] = "Linear";
+    TangentMode[TangentMode["Constant"] = 2] = "Constant";
+})(TangentMode || (TangentMode = {}));
+var WeightedMode;
+(function(WeightedMode) {
+    WeightedMode[WeightedMode["None"] = 0] = "None";
+    WeightedMode[WeightedMode["In"] = 1] = "In";
+    WeightedMode[WeightedMode["Out"] = 2] = "Out";
+    WeightedMode[WeightedMode["Both"] = 3] = "Both";
+})(WeightedMode || (WeightedMode = {}));
+var BezierCurve = /*#__PURE__*/ function(ValueGetter) {
+    _inherits(BezierCurve, ValueGetter);
+    function BezierCurve() {
+        return ValueGetter.apply(this, arguments);
+    }
+    var _proto = BezierCurve.prototype;
+    _proto.onCreate = function onCreate(props) {
+        this.keyFrames = props;
+        var keyframes = this.keyFrames;
+        this.curveMap = {};
+        this.keys = [];
+        this.curveInfos = [];
+        for(var i = 0; i < keyframes.length - 1; i++){
+            var leftKeyframe = keyframes[i];
+            var rightKeyframe = keyframes[i + 1];
+            var _buildBezierEasing = buildBezierEasing(leftKeyframe, rightKeyframe), points = _buildBezierEasing.points, curve = _buildBezierEasing.curve, timeInterval = _buildBezierEasing.timeInterval, valueInterval = _buildBezierEasing.valueInterval;
+            var s = points[0];
+            var e = points[points.length - 1];
+            this.keys.push([].concat(s.toArray(), points[1].toArray()));
+            this.keys.push([].concat(e.toArray(), points[2].toArray()));
+            var curveInfo = {
+                points: points,
+                timeInterval: timeInterval,
+                valueInterval: valueInterval,
+                curve: curve,
+                timeStart: Number(s.x),
+                timeEnd: Number(e.x)
+            };
+            this.curveMap[s.x + "&" + e.x] = curveInfo;
+            this.curveInfos.push(curveInfo);
+        }
+    };
+    _proto.getValue = function getValue(time) {
+        var result = 0;
+        var keysNumber = this.keyFrames.length;
+        if (time <= this.keyFrames[0].time) {
+            result = this.keyFrames[0].value;
+        } else if (time < this.keyFrames[keysNumber - 1].time) {
+            for(var i = 0; i < this.keyFrames.length - 1; i++){
+                var xMin = this.keyFrames[i].time;
+                var xMax = this.keyFrames[i + 1].time;
+                if (time >= xMin && time < xMax) {
+                    var curveInfo = this.curveInfos[i];
+                    var p0 = curveInfo.points[0];
+                    var timeInterval = curveInfo.timeInterval;
+                    var valueInterval = curveInfo.valueInterval;
+                    var normalizeTime = (time - p0.x) / timeInterval;
+                    var value = curveInfo.curve.getValue(normalizeTime);
+                    result = p0.y + valueInterval * value;
+                    break;
+                }
+            }
+        } else if (time >= this.keyFrames[keysNumber - 1].time) {
+            result = this.keyFrames[keysNumber - 1].value;
+        }
+        return result;
+    };
+    _proto.getIntegrateValue = function getIntegrateValue(t0, t1, ts) {
+        if (ts === void 0) ts = 1;
+        var time = (t1 - t0) / ts;
+        var result = 0;
+        var keyTimeData = Object.keys(this.curveMap);
+        var keyTimeStart = this.curveMap[keyTimeData[0]].timeStart;
+        if (time <= keyTimeStart) {
+            return 0;
+        }
+        for(var i = 0; i < keyTimeData.length; i++){
+            var xMin = this.curveMap[keyTimeData[i]].timeStart;
+            var xMax = this.curveMap[keyTimeData[i]].timeEnd;
+            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 result;
+    };
+    _proto.getIntegrateByTime = function getIntegrateByTime(t0, t1) {
+        return this.getIntegrateValue(0, t1) - this.getIntegrateValue(0, t0);
+    };
+    // 速度变化曲线面板移除后下线
+    _proto.getCurveIntegrateValue = function getCurveIntegrateValue(curveKey, time) {
+        var curveInfo = this.curveMap[curveKey];
+        var _curveInfo_points = curveInfo.points, p0 = _curveInfo_points[0];
+        var timeInterval = curveInfo.timeInterval;
+        var valueInterval = curveInfo.valueInterval;
+        var segments = 20;
+        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;
+            }
+        }
+        total *= h / 3;
+        return total;
+    };
+    _proto.toUniform = function toUniform(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
+        ]);
+    };
+    _proto.toData = function toData() {
+        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;
+    };
+    _proto.getMaxTime = function getMaxTime() {
+        return this.keyFrames[this.keyFrames.length - 1].time;
+    };
+    return BezierCurve;
+}(ValueGetter);
+function buildBezierEasing(leftKeyframe, rightKeyframe) {
+    var p0 = new Vector2(leftKeyframe.time, leftKeyframe.value);
+    var p1 = new Vector2();
+    var p2 = new Vector2();
+    var p3 = new Vector2();
+    var isWeighted = leftKeyframe.weightedMode === 2 || leftKeyframe.weightedMode === 3 || rightKeyframe.weightedMode === 1 || rightKeyframe.weightedMode === 3;
+    var isConstant = leftKeyframe.tangentMode === 2;
+    var rightDeltaX = (isWeighted ? leftKeyframe.outWeight : 1) * (rightKeyframe.time - leftKeyframe.time) / 3;
+    p1.x = leftKeyframe.time + rightDeltaX;
+    p1.y = leftKeyframe.value + rightDeltaX * (isConstant ? 0 : leftKeyframe.outSlope);
+    var leftDeltaX = (isWeighted ? rightKeyframe.inWeight : 1) * (rightKeyframe.time - leftKeyframe.time) / 3;
+    p2.x = rightKeyframe.time - leftDeltaX;
+    p2.y = rightKeyframe.value - leftDeltaX * (isConstant ? 0 : rightKeyframe.inSlope);
+    p3.x = rightKeyframe.time;
+    p3.y = isConstant ? leftKeyframe.value : rightKeyframe.value;
+    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 {
+        if (decimalEqual(valueInterval, 0)) {
+            bezEasing = new BezierEasing();
+        } else if (isWeighted) {
+            bezEasing = new BezierEasing(x1, y1, x2, y2);
+        } else {
+            bezEasing = new BezierEasing(y1, y2);
+        }
+        BezierMap[str] = bezEasing;
+    }
+    return {
+        points: [
+            p0,
+            p1,
+            p2,
+            p3
+        ],
+        timeInterval: timeInterval,
+        valueInterval: valueInterval,
+        curve: bezEasing
+    };
+}
+function oldBezierKeyFramesToNew(props) {
+    var oldKeyframes = props;
+    var keyframes = [];
+    var keyDatas = [];
+    var lastControl = {
+        x: 0,
+        y: 0
+    };
+    for(var i = 0; i < oldKeyframes.length - 1; i++){
+        var leftKeyframe = oldKeyframes[i];
+        var rightKeyframe = oldKeyframes[i + 1];
+        var _getControlPoints = getControlPoints(leftKeyframe, rightKeyframe, true), p0 = _getControlPoints.p0, p1 = _getControlPoints.p1, p2 = _getControlPoints.p2, p3 = _getControlPoints.p3;
+        assertExist(p2);
+        assertExist(p3);
+        var keyData = {
+            leftControl: lastControl,
+            value: p0,
+            rightControl: p1,
+            tangentMode: 0
+        };
+        if (leftKeyframe[0] === BezierKeyframeType.HOLD) {
+            keyData.tangentMode = 2;
+        }
+        keyDatas.push(keyData);
+        lastControl = p2;
+        if (i === oldKeyframes.length - 2) {
+            var res = getControlPoints(rightKeyframe, rightKeyframe, true);
+            assertExist(res.p3);
+            keyDatas.push({
+                leftControl: p2,
+                value: res.p3,
+                rightControl: {
+                    x: 0,
+                    y: 0
+                },
+                tangentMode: rightKeyframe[0] === BezierKeyframeType.HOLD ? 2 : 0
+            });
+        }
+    }
+    var calculateSlop = function(p0, p1) {
+        return (p1.y - p0.y) / (p1.x - p0.x + NumberEpsilon);
+    };
+    for(var i1 = 0; i1 < keyDatas.length; i1++){
+        var leftControl = keyDatas[i1].leftControl;
+        var value = keyDatas[i1].value;
+        var rightControl = keyDatas[i1].rightControl;
+        var outSlop = calculateSlop(value, rightControl);
+        var inSlop = calculateSlop(leftControl, value);
+        var keyframe = {
+            time: value.x,
+            value: value.y,
+            inSlope: inSlop,
+            outSlope: outSlop,
+            inWeight: 0,
+            outWeight: 0,
+            tangentMode: keyDatas[i1].tangentMode,
+            weightedMode: 3
+        };
+        keyframes.push(keyframe);
+        if (i1 > 0) {
+            keyframe.inWeight = (value.x - leftControl.x) / ((value.x - keyDatas[i1 - 1].value.x) / 3);
+        }
+        if (i1 + 1 < keyDatas.length) {
+            keyframe.outWeight = (rightControl.x - value.x) / ((keyDatas[i1 + 1].value.x - value.x) / 3);
+        }
+    }
+    return keyframes;
+}
+
 var _obj$2;
 var map = (_obj$2 = {}, _obj$2[ValueType.RANDOM] = function(props) {
     if (_instanceof1(props[0], Array)) {
@@ -15309,7 +15479,8 @@ var map = (_obj$2 = {}, _obj$2[ValueType.RANDOM] = function(props) {
     if (props.length === 1) {
         return new StaticValue(props[0][1][1]);
     }
-    return new BezierCurve(props);
+    // TODO: Move to migration.
+    return new BezierCurve(oldBezierKeyFramesToNew(props));
 }, _obj$2[ValueType.BEZIER_CURVE_PATH] = function(props) {
     if (props[0].length === 1) {
         return new StaticValue(_construct(Vector3, [].concat(props[1][0])));
@@ -26204,10 +26375,14 @@ var TextComponentBase = /*#__PURE__*/ function() {
     _proto.getLineCount = function getLineCount(text, init) {
         var context = this.context;
         var _this_textLayout = this.textLayout, letterSpace = _this_textLayout.letterSpace, overflow = _this_textLayout.overflow;
-        var fontScale = init ? this.textStyle.fontSize / 10 : 1 / this.textStyle.fontScale;
+        var fontScale = init ? this.textStyle.fontSize / 10 : this.textStyle.fontScale;
         var width = this.textLayout.width + this.textStyle.fontOffset;
         var lineCount = 1;
         var x = 0;
+        //设置context.font的字号
+        if (context) {
+            context.font = this.getFontDesc(this.textStyle.fontSize);
+        }
         for(var i = 0; i < text.length; i++){
             var _context_measureText;
             var str = text[i];
@@ -28396,7 +28571,7 @@ function getStandardSpriteContent(sprite, transform) {
     return ret;
 }
 
-var version$1 = "2.5.0-alpha.5";
+var version$1 = "2.5.0";
 var v0 = /^(\d+)\.(\d+)\.(\d+)(-(\w+)\.\d+)?$/;
 var standardVersion = /^(\d+)\.(\d+)$/;
 var reverseParticle = false;
@@ -31646,8 +31821,8 @@ registerPlugin("sprite", SpriteLoader, VFXItem);
 registerPlugin("particle", ParticleLoader, VFXItem);
 registerPlugin("cal", CalculateLoader, VFXItem);
 registerPlugin("interact", InteractLoader, VFXItem);
-var version = "2.5.0-alpha.5";
+var version = "2.5.0";
 logger.info("Core version: " + version + ".");
 
-export { AbstractPlugin, ActivationPlayable, ActivationPlayableAsset, ActivationTrack, AnimationClip, AnimationClipPlayable, Asset, AssetLoader, AssetManager, AssetService, BYTES_TYPE_MAP, BaseRenderComponent, Behaviour, BezierCurve, BezierCurvePath, BezierCurveQuat, BinaryAsset, COMPRESSED_TEXTURE, COPY_FRAGMENT_SHADER, COPY_MESH_SHADER_ID, COPY_VERTEX_SHADER, CalculateLoader, Camera, CameraController, CameraVFXItemLoader, ColorCurve, ColorPropertyPlayableAsset, ColorPropertyTrack, Component, Composition, CompositionComponent, DEFAULT_FONTS, DEFAULT_FPS, Database, Deferred, DestroyOptions, Downloader, EFFECTS_COPY_MESH_NAME, EVENT_TYPE_CLICK, EVENT_TYPE_TOUCH_END, EVENT_TYPE_TOUCH_MOVE, EVENT_TYPE_TOUCH_START, EffectComponent, EffectsObject, EffectsPackage, Ellipse, Engine, EventEmitter, EventSystem, Fake3DAnimationMode, Fake3DComponent, FilterMode, Float16ArrayWrapper, FloatPropertyPlayableAsset, FloatPropertyTrack, Framebuffer, GLSLVersion, GPUCapability, Geometry, GlobalUniforms, GradientValue, GraphicsPath, HELP_LINK, HitTestType, InteractComponent, InteractLoader, InteractMesh, Item, KTXTexture, LineSegments, LinearValue, MaskMode, MaskProcessor, Material, MaterialDataBlock, MaterialRenderType, MaterialTrack, Mesh, MeshCollider, ObjectBindingTrack, OrderType, PLAYER_OPTIONS_ENV_EDITOR, POST_PROCESS_SETTINGS, ParticleBehaviourPlayable, ParticleBehaviourPlayableAsset, ParticleLoader, ParticleMesh, ParticleSystem, ParticleSystemRenderer, ParticleTrack, PassTextureCache, PathSegments, PluginSystem, PolyStar, Polygon, PostProcessVolume, PropertyTrack, RENDER_PASS_NAME_PREFIX, RENDER_PREFER_LOOKUP_TEXTURE, RUNTIME_ENV, RandomSetValue, RandomValue, RandomVectorValue, RenderFrame, RenderPass, RenderPassAttachmentStorageType, RenderPassDestroyAttachmentType, RenderPassPriorityNormal, RenderPassPriorityPostprocess, RenderPassPriorityPrepare, RenderTargetHandle, RenderTextureFormat, Renderbuffer, Renderer, RendererComponent, RuntimeClip, 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, Scene, SemanticMap, SerializationHelper, Shader, ShaderCompileResultStatus, ShaderFactory, ShaderType, ShaderVariant, ShapeComponent, ShapePath, SpriteColorPlayableAsset, SpriteColorTrack, SpriteComponent, SpriteLoader, StarType, StaticValue, SubCompositionPlayableAsset, SubCompositionTrack, TEMPLATE_USE_OFFSCREEN_CANVAS, TextComponent, TextComponentBase, TextLayout, TextLoader, TextStyle, Texture, TextureFactory, TextureLoadAction, TextureSourceType, TextureStoreAction, Ticker, TimelineAsset, TimelineClip, TimelinePlayable, TrackAsset, TrackSortWrapper, TrackType, Transform, TransformAnimationPlayable, TransformPlayableAsset, TransformTrack, VFXItem, ValueGetter, Vector2Curve, Vector2PropertyPlayableAsset, Vector2PropertyTrack, Vector4Curve, Vector4PropertyPlayableAsset, Vector4PropertyTrack, addByOrder, addItem, addItemWithOrder, applyMixins, assertExist, asserts, base64ToFile, blend, buildLine, calculateTranslation, canvasPool, closePointEps, colorGradingFrag, colorStopsFromGradient, colorToArr$1 as colorToArr, combineImageTemplate, createCopyShader, createGLContext, createKeyFrameMeta, createShape, createValueGetter, curveEps, decimalEqual, defaultPlugins, deserializeMipmapTexture, earcut, effectsClass, effectsClassStore, enlargeBuffer, ensureFixedNumber, ensureVec3, findPreviousRenderPass, gaussianDown_frag as gaussianDownFrag, gaussianDownHFrag, gaussianDownVFrag, gaussianUpFrag, generateEmptyTypedArray, generateGUID, generateHalfFloatTexture, generateTransparentTexture, generateWhiteTexture, getBackgroundImage, getColorFromGradientStops, getConfig, getDefaultTextureFactory, getGeometryByShape, getGeometryTriangles, getKTXTextureOptions, getKeyFrameMetaByRawValue, getMergedStore, getParticleMeshShader, getPixelRatio, getPreMultiAlpha, getStandardComposition, getStandardImage, getStandardItem, getStandardJSON, getTextureSize, glContext, glType2VertexFormatType, gpuTimer, imageDataFromColor, imageDataFromGradient, initErrors, initGLContext, integrate, interpolateColor, isAlipayMiniApp, isAndroid, isArray, isCanvas, isFunction, isIOS, isIOSByUA, isMiniProgram, isObject, isOpenHarmony, isSimulatorCellPhone, isString, isUniformStruct, isUniformStructArray, isValidFontFamily, isWebGL2, isWechatMiniApp, itemFrag, itemFrame_frag as itemFrameFrag, itemVert, loadAVIFOptional, loadBinary, loadBlob, loadImage, loadMedia, loadVideo, loadWebPOptional, logger, index as math, maxSpriteMeshItemCount, modifyMaxKeyframeShader, nearestPowerOfTwo, noop, normalizeColor, numberToFix, parsePercent$1 as parsePercent, particleFrag, particleOriginTranslateMap$1 as particleOriginTranslateMap, particleUniformTypeMap, particleVert, passRenderLevel, pluginLoaderMap, randomInRange, registerPlugin, removeItem, rotateVec2, screenMeshVert, serialize, setBlendMode, setConfig, setDefaultTextureFactory, setMaskMode, setMaxSpriteMeshItemCount, setRayFromCamera, setSideMode, setSpriteMeshMaxItemCountByGPU, sortByOrder, index$1 as spec, thresholdFrag, throwDestroyedError, trailVert, translatePoint, trianglesFromRect, unregisterPlugin, valIfUndefined, value, valueDefine, vecFill, vecMulCombine, version, vertexFormatType2GLType };
+export { AbstractPlugin, ActivationPlayable, ActivationPlayableAsset, ActivationTrack, AnimationClip, AnimationClipPlayable, Asset, AssetLoader, AssetManager, AssetService, BYTES_TYPE_MAP, BaseRenderComponent, Behaviour, BezierCurve, BezierCurvePath, BezierCurveQuat, BinaryAsset, COMPRESSED_TEXTURE, COPY_FRAGMENT_SHADER, COPY_MESH_SHADER_ID, COPY_VERTEX_SHADER, CalculateLoader, Camera, CameraController, CameraVFXItemLoader, ColorCurve, ColorPropertyPlayableAsset, ColorPropertyTrack, Component, Composition, CompositionComponent, DEFAULT_FONTS, DEFAULT_FPS, Database, Deferred, DestroyOptions, Downloader, EFFECTS_COPY_MESH_NAME, EVENT_TYPE_CLICK, EVENT_TYPE_TOUCH_END, EVENT_TYPE_TOUCH_MOVE, EVENT_TYPE_TOUCH_START, EffectComponent, EffectsObject, EffectsPackage, Ellipse, Engine, EventEmitter, EventSystem, Fake3DAnimationMode, Fake3DComponent, FilterMode, Float16ArrayWrapper, FloatPropertyPlayableAsset, FloatPropertyTrack, Framebuffer, GLSLVersion, GPUCapability, Geometry, GlobalUniforms, GradientValue, GraphicsPath, HELP_LINK, HitTestType, InteractComponent, InteractLoader, InteractMesh, Item, KTXTexture, LineSegments, LinearValue, MaskMode, MaskProcessor, Material, MaterialDataBlock, MaterialRenderType, MaterialTrack, Mesh, MeshCollider, ObjectBindingTrack, OrderType, PLAYER_OPTIONS_ENV_EDITOR, POST_PROCESS_SETTINGS, ParticleBehaviourPlayable, ParticleBehaviourPlayableAsset, ParticleLoader, ParticleMesh, ParticleSystem, ParticleSystemRenderer, ParticleTrack, PassTextureCache, PathSegments, PluginSystem, PolyStar, Polygon, PostProcessVolume, PropertyTrack, RENDER_PASS_NAME_PREFIX, RENDER_PREFER_LOOKUP_TEXTURE, RUNTIME_ENV, RandomSetValue, RandomValue, RandomVectorValue, RenderFrame, RenderPass, RenderPassAttachmentStorageType, RenderPassDestroyAttachmentType, RenderPassPriorityNormal, RenderPassPriorityPostprocess, RenderPassPriorityPrepare, RenderTargetHandle, RenderTextureFormat, Renderbuffer, Renderer, RendererComponent, RuntimeClip, 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, Scene, SemanticMap, SerializationHelper, Shader, ShaderCompileResultStatus, ShaderFactory, ShaderType, ShaderVariant, ShapeComponent, ShapePath, SpriteColorPlayableAsset, SpriteColorTrack, SpriteComponent, SpriteLoader, StarType, StaticValue, SubCompositionPlayableAsset, SubCompositionTrack, TEMPLATE_USE_OFFSCREEN_CANVAS, TangentMode, TextComponent, TextComponentBase, TextLayout, TextLoader, TextStyle, Texture, TextureFactory, TextureLoadAction, TextureSourceType, TextureStoreAction, Ticker, TimelineAsset, TimelineClip, TimelinePlayable, TrackAsset, TrackSortWrapper, TrackType, Transform, TransformAnimationPlayable, TransformPlayableAsset, TransformTrack, VFXItem, ValueGetter, Vector2Curve, Vector2PropertyPlayableAsset, Vector2PropertyTrack, Vector4Curve, Vector4PropertyPlayableAsset, Vector4PropertyTrack, WeightedMode, addByOrder, addItem, addItemWithOrder, applyMixins, assertExist, asserts, base64ToFile, blend, buildLine, calculateTranslation, canvasPool, closePointEps, colorGradingFrag, colorStopsFromGradient, colorToArr$1 as colorToArr, combineImageTemplate, createCopyShader, createGLContext, createKeyFrameMeta, createShape, createValueGetter, curveEps, decimalEqual, defaultPlugins, deserializeMipmapTexture, earcut, effectsClass, effectsClassStore, enlargeBuffer, ensureFixedNumber, ensureVec3, findPreviousRenderPass, gaussianDown_frag as gaussianDownFrag, gaussianDownHFrag, gaussianDownVFrag, gaussianUpFrag, generateEmptyTypedArray, generateGUID, generateHalfFloatTexture, generateTransparentTexture, generateWhiteTexture, getBackgroundImage, getColorFromGradientStops, getConfig, getDefaultTextureFactory, getGeometryByShape, getGeometryTriangles, getKTXTextureOptions, getKeyFrameMetaByRawValue, getMergedStore, getParticleMeshShader, getPixelRatio, getPreMultiAlpha, getStandardComposition, getStandardImage, getStandardItem, getStandardJSON, getTextureSize, glContext, glType2VertexFormatType, gpuTimer, imageDataFromColor, imageDataFromGradient, initErrors, initGLContext, integrate, interpolateColor, isAlipayMiniApp, isAndroid, isArray, isCanvas, isFunction, isIOS, isIOSByUA, isMiniProgram, isObject, isOpenHarmony, isSimulatorCellPhone, isString, isUniformStruct, isUniformStructArray, isValidFontFamily, isWebGL2, isWechatMiniApp, itemFrag, itemFrame_frag as itemFrameFrag, itemVert, loadAVIFOptional, loadBinary, loadBlob, loadImage, loadMedia, loadVideo, loadWebPOptional, logger, index as math, maxSpriteMeshItemCount, modifyMaxKeyframeShader, nearestPowerOfTwo, noop, normalizeColor, numberToFix, oldBezierKeyFramesToNew, parsePercent$1 as parsePercent, particleFrag, particleOriginTranslateMap$1 as particleOriginTranslateMap, particleUniformTypeMap, particleVert, passRenderLevel, pluginLoaderMap, randomInRange, registerPlugin, removeItem, rotateVec2, screenMeshVert, serialize, setBlendMode, setConfig, setDefaultTextureFactory, setMaskMode, setMaxSpriteMeshItemCount, setRayFromCamera, setSideMode, setSpriteMeshMaxItemCountByGPU, sortByOrder, index$1 as spec, thresholdFrag, throwDestroyedError, trailVert, translatePoint, trianglesFromRect, unregisterPlugin, valIfUndefined, value, valueDefine, vecFill, vecMulCombine, version, vertexFormatType2GLType };
 //# sourceMappingURL=index.mjs.map