@galacean/effects-threejs 2.5.0-alpha.6 → 2.5.0

package/dist/index.js

@@ -3,7 +3,7 @@
  * Description: Galacean Effects runtime threejs plugin for the web
  * Author: Ant Group CO., Ltd.
  * Contributors: 燃然,飂兮,十弦,云垣,茂安,意绮
- * Version: v2.5.0-alpha.6
+ * Version: v2.5.0
  */
 
 'use strict';
@@ -14192,40 +14192,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) {
@@ -14238,14 +14258,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;
 }();
@@ -14804,148 +14830,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() {
@@ -15299,6 +15183,292 @@ var Vector2Curve = /*#__PURE__*/ function(ValueGetter) {
     return Vector2Curve;
 }(ValueGetter);
 
+exports.TangentMode = void 0;
+(function(TangentMode) {
+    TangentMode[TangentMode["Cubic"] = 0] = "Cubic";
+    TangentMode[TangentMode["Linear"] = 1] = "Linear";
+    TangentMode[TangentMode["Constant"] = 2] = "Constant";
+})(exports.TangentMode || (exports.TangentMode = {}));
+exports.WeightedMode = void 0;
+(function(WeightedMode) {
+    WeightedMode[WeightedMode["None"] = 0] = "None";
+    WeightedMode[WeightedMode["In"] = 1] = "In";
+    WeightedMode[WeightedMode["Out"] = 2] = "Out";
+    WeightedMode[WeightedMode["Both"] = 3] = "Both";
+})(exports.WeightedMode || (exports.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$3;
 var map = (_obj$3 = {}, _obj$3[ValueType.RANDOM] = function(props) {
     if (_instanceof1(props[0], Array)) {
@@ -15335,7 +15505,8 @@ var map = (_obj$3 = {}, _obj$3[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$3[ValueType.BEZIER_CURVE_PATH] = function(props) {
     if (props[0].length === 1) {
         return new StaticValue(_construct(Vector3, [].concat(props[1][0])));
@@ -26230,10 +26401,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];
@@ -28422,7 +28597,7 @@ function getStandardSpriteContent(sprite, transform) {
     return ret;
 }
 
-var version$2 = "2.5.0-alpha.6";
+var version$2 = "2.5.0";
 var v0 = /^(\d+)\.(\d+)\.(\d+)(-(\w+)\.\d+)?$/;
 var standardVersion = /^(\d+)\.(\d+)$/;
 var reverseParticle = false;
@@ -31672,7 +31847,7 @@ registerPlugin("sprite", SpriteLoader, exports.VFXItem);
 registerPlugin("particle", ParticleLoader, exports.VFXItem);
 registerPlugin("cal", CalculateLoader, exports.VFXItem);
 registerPlugin("interact", InteractLoader, exports.VFXItem);
-var version$1 = "2.5.0-alpha.6";
+var version$1 = "2.5.0";
 logger.info("Core version: " + version$1 + ".");
 
 var _obj;
@@ -33274,7 +33449,7 @@ setMaxSpriteMeshItemCount(8);
  */ Mesh.create = function(engine, props) {
     return new ThreeMesh(engine, props);
 };
-var version = "2.5.0-alpha.6";
+var version = "2.5.0";
 logger.info("THREEJS plugin version: " + version + ".");
 
 exports.AbstractPlugin = AbstractPlugin;
@@ -33502,6 +33677,7 @@ exports.nearestPowerOfTwo = nearestPowerOfTwo;
 exports.noop = noop;
 exports.normalizeColor = normalizeColor;
 exports.numberToFix = numberToFix;
+exports.oldBezierKeyFramesToNew = oldBezierKeyFramesToNew;
 exports.parsePercent = parsePercent$1;
 exports.particleFrag = particleFrag;
 exports.particleOriginTranslateMap = particleOriginTranslateMap$1;