l

src/2d/display/Container.ts

@@ -271,6 +271,13 @@ export default class Container extends DisplayObject {
         children.forEach((child: T) => { this.removeChild(child); })
         return children
     }
+    /**
+     * 移除所有子级
+     * @returns 返回移除的子级的数组
+     */
+    removeAllChildren<T extends DisplayObject>(): T[] {
+        return this.removeChildren()
+    }
     /**
      * 通过索引批量移除child
      * @param {number} [beginIndex=0]

src/2d/math/Rectangle.ts

@@ -190,10 +190,10 @@ export class Rectangle extends HashObject {
                 hy1 = y + h;
                 wx2 = arg[i].x + arg[i].width;
                 hy2 = arg[i].y + arg[i].height;
-                if (x > arg[i].x || wx1 == 0) {
+                if (x > arg[i].x /*|| wx1 == 0*/) {
                     x = arg[i].x;
                 }
-                if (y > arg[i].y || hy1 == 0) {
+                if (y > arg[i].y /*|| hy1 == 0*/) {
                     y = arg[i].y;
                 }
                 if (wx1 < wx2) {

src/2d/ui/forLottie/BezierEaser.ts

+export const getBezierEasing = (function () {
+    /**
+     * BezierEasing - use bezier curve for transition easing function
+     * by Gaëtan Renaudeau 2014 - 2015 – MIT License
+     *
+     * Credits: is based on Firefox's nsSMILKeySpline.cpp
+     * Usage:
+     * var spline = BezierEasing([ 0.25, 0.1, 0.25, 1.0 ])
+     * spline.get(x) => returns the easing value | x must be in [0, 1] range
+     *
+     */
+
+    var beziers = {};
+
+    function getBezierEasing(a, b, c, d, nm?) {
+        var str = nm || ('bez_' + a + '_' + b + '_' + c + '_' + d).replace(/\./g, 'p');
+        if (beziers[str]) {
+            return beziers[str];
+        }
+        var bezEasing = new BezierEasing([a, b, c, d]);
+        beziers[str] = bezEasing;
+        return bezEasing;
+    }
+
+    // These values are established by empiricism with tests (tradeoff: performance VS precision)
+    var NEWTON_ITERATIONS = 4;
+    var NEWTON_MIN_SLOPE = 0.001;
+    var SUBDIVISION_PRECISION = 0.0000001;
+    var SUBDIVISION_MAX_ITERATIONS = 10;
+
+    var kSplineTableSize = 11;
+    var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
+
+    var float32ArraySupported = typeof Float32Array === "function";
+
+    function A(aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }
+    function B(aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }
+    function C(aA1) { return 3.0 * aA1; }
+
+    // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
+    function calcBezier(aT, aA1, aA2) {
+        return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
+    }
+
+    // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
+    function getSlope(aT, aA1, aA2) {
+        return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
+    }
+
+    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;
+    }
+
+    /**
+     * points is an array of [ mX1, mY1, mX2, mY2 ]
+     */
+    function BezierEasing(points) {
+        this._p = points;
+        this._mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+        this._precomputed = false;
+
+        this.get = this.get.bind(this);
+    }
+
+    BezierEasing.prototype = {
+
+        get: function (x) {
+            var mX1 = this._p[0],
+                mY1 = this._p[1],
+                mX2 = this._p[2],
+                mY2 = this._p[3];
+            if (!this._precomputed) this._precompute();
+            if (mX1 === mY1 && mX2 === mY2) return x; // linear
+            // Because JavaScript number are imprecise, we should guarantee the extremes are right.
+            if (x === 0) return 0;
+            if (x === 1) return 1;
+            return calcBezier(this._getTForX(x), mY1, mY2);
+        },
+
+        // Private part
+
+        _precompute: function () {
+            var mX1 = this._p[0],
+                mY1 = this._p[1],
+                mX2 = this._p[2],
+                mY2 = this._p[3];
+            this._precomputed = true;
+            if (mX1 !== mY1 || mX2 !== mY2)
+                this._calcSampleValues();
+        },
+
+        _calcSampleValues: function () {
+            var mX1 = this._p[0],
+                mX2 = this._p[2];
+            for (var i = 0; i < kSplineTableSize; ++i) {
+                this._mSampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+            }
+        },
+
+        /**
+         * getTForX chose the fastest heuristic to determine the percentage value precisely from a given X projection.
+         */
+        _getTForX: function (aX) {
+            var mX1 = this._p[0],
+                mX2 = this._p[2],
+                mSampleValues = this._mSampleValues;
+
+            var intervalStart = 0.0;
+            var currentSample = 1;
+            var lastSample = kSplineTableSize - 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, mX1, mX2);
+            if (initialSlope >= NEWTON_MIN_SLOPE) {
+                return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
+            } else if (initialSlope === 0.0) {
+                return guessForT;
+            } else {
+                return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+            }
+        }
+    };
+
+    return getBezierEasing;
+
+}());
\ No newline at end of file

src/2d/ui/forLottie/buildBezierProps.ts

+
+
+export function buildBezierProps(pt1, pt2, pt3, pt4, startIndex, endIndex, points, fnc, limit?: number) {
+    var bezierData = buildBezierData(pt1, pt2, pt3, pt4);
+    //处理完所有的点
+    for (var i = startIndex; i < endIndex; i++) {
+        if (limit) {
+            //小于0的不算了，浪费时间
+            if (i < 0) continue;
+            //超出的也不要了
+            if (i >= limit) break;//遇到那种
+        }
+        var perc = fnc((i - startIndex) / (endIndex - startIndex));
+        var distanceInLine = bezierData.segmentLength * perc;
+        if (perc == 0) {
+            points[i] = bezierData.points[0].point;
+            continue;
+        }
+        //找最近的点
+        points[i] = findNearest(distanceInLine, bezierData.points);
+    }
+}
+
+function findNearest(distanceInLine: number, bezierDataPoints: PointData[]) {
+    for (var i = 0; i < bezierDataPoints.length; i++) {
+        var preLength = bezierDataPoints[i].preLength;
+        if (distanceInLine < preLength) {//前一帧后当前帧做补间，且i肯定不会为0，因为distanceInLine不会小于0；
+            var segmentPerc = (distanceInLine - bezierDataPoints[i - 1].preLength) / bezierDataPoints[i].partialLength;
+            var kLen = bezierDataPoints[i - 1].point.length;
+            var newValue = [];
+            for (var k = 0; k < kLen; k += 1) {
+                newValue[k] = bezierDataPoints[i - 1].point[k] + (bezierDataPoints[i].point[k] - bezierDataPoints[i - 1].point[k]) * segmentPerc;
+            }
+            return newValue;//取补间
+        }
+    }
+    //没有返回最后一个
+    return bezierDataPoints[bezierDataPoints.length - 1].point;
+}
+
+var storedData = {};
+function buildBezierData(pt1, pt2, pt3, pt4): BezierData {
+    var bezierName = (pt1[0] + '_' + pt1[1] + '_' + pt2[0] + '_' + pt2[1] + '_' + pt3[0] + '_' + pt3[1] + '_' + pt4[0] + '_' + pt4[1]).replace(/\./g, 'p');
+    if (!storedData[bezierName]) {
+        var curveSegments = 150//defaultCurveSegments;
+        var k, i, len;
+        var ptCoord, perc, addedLength = 0;
+        var ptDistance;
+        var point, lastPoint = null;
+        if (pt1.length === 2 && (pt1[0] != pt2[0] || pt1[1] != pt2[1]) && pointOnLine2D(pt1[0], pt1[1], pt2[0], pt2[1], pt1[0] + pt3[0], pt1[1] + pt3[1]) && pointOnLine2D(pt1[0], pt1[1], pt2[0], pt2[1], pt2[0] + pt4[0], pt2[1] + pt4[1])) {
+            curveSegments = 2;
+            //这种情况只会生成两个点
+        }
+        var bezierData = {
+            segmentLength: 0,
+            points: new Array(curveSegments)
+        }
+        len = pt3.length;
+        for (k = 0; k < curveSegments; k += 1) {
+            point = new Array(len);
+            perc = k / (curveSegments - 1);
+            ptDistance = 0;
+            for (i = 0; i < len; i += 1) {
+                ptCoord = Math.pow(1 - perc, 3) * pt1[i] + 3 * Math.pow(1 - perc, 2) * perc * (pt1[i] + pt3[i]) + 3 * (1 - perc) * Math.pow(perc, 2) * (pt2[i] + pt4[i]) + Math.pow(perc, 3) * pt2[i];
+                point[i] = ptCoord;
+                if (lastPoint !== null) {
+                    ptDistance += Math.pow(point[i] - lastPoint[i], 2);
+                }
+            }
+            ptDistance = Math.sqrt(ptDistance);
+            addedLength += ptDistance;
+            bezierData.points[k] = {
+                partialLength: ptDistance,
+                preLength: addedLength,//记录一下前面所有的总长
+                point
+            }
+            lastPoint = point;
+        }
+        bezierData.segmentLength = addedLength;
+        storedData[bezierName] = bezierData;
+    }
+    return storedData[bezierName];
+}
+
+interface PointData {
+    point: number[],
+    partialLength: number,
+    preLength: number,
+}
+
+interface BezierData {
+    segmentLength: number,
+    points: PointData[]
+}
+
+function pointOnLine2D(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;
+}
\ No newline at end of file

src/3D/Geometry.ts

@@ -243,10 +243,10 @@ function createNineTextures(imageUrl: string): Promise<FYGE.Texture[]> {
                     "y": ~~(i / 3) * h,
                     w, h, sw: w, sh: h, ox: 0, oy: 0, ro: false
                 };
-            FYGE.createTextureSheet(new FYGE.BaseTexture(image), obj);
+            var textures = FYGE.createTextureSheet(new FYGE.BaseTexture(image), obj);
             //取TextureCache里的
             var arr = [];
-            for (var i = 0; i < 9; i++)arr.push(FYGE.TextureCache[name + i])
+            for (var i = 0; i < 9; i++)arr.push(textures[name + i])
             resolve(arr)
         }
         image.onerror = function () {

src/3D/gltf/GLTFCubicSplineInterpolant.ts

+
+import { InterInterpolant } from "./Interpolant";
+
+// Spline Interpolation
+// Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation
+export class GLTFCubicSplineInterpolant extends InterInterpolant {
+
+    copySampleValue_(index: number) {
+        // Copies a sample value to the result buffer. See description of glTF
+        // CUBICSPLINE values layout in interpolate_() function below.
+
+        var result = this.resultBuffer,
+            values = this.sampleValues,
+            valueSize = this.valueSize,
+            offset = index * valueSize * 3 + valueSize;
+
+        for (var i = 0; i !== valueSize; i++) {
+
+            result[i] = values[offset + i];
+
+        }
+
+        return result;
+    }
+    beforeStart_ = this.copySampleValue_;
+    afterEnd_ = this.copySampleValue_;
+    interpolate_(i1: number, t0: number, t: number, t1: number) {
+
+        var result = this.resultBuffer;
+        var values = this.sampleValues;
+        var stride = this.valueSize;
+
+        var stride2 = stride * 2;
+        var stride3 = stride * 3;
+
+        var td = t1 - t0;
+
+        var p = (t - t0) / td;
+        var pp = p * p;
+        var ppp = pp * p;
+
+        var offset1 = i1 * stride3;
+        var offset0 = offset1 - stride3;
+
+        var s0 = 2 * ppp - 3 * pp + 1;
+        var s1 = ppp - 2 * pp + p;
+        var s2 = - 2 * ppp + 3 * pp;
+        var s3 = ppp - pp;
+
+        // Layout of keyframe output values for CUBICSPLINE animations:
+        //   [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
+        for (var i = 0; i !== stride; i++) {
+
+            var p0 = values[offset0 + i + stride]; // splineVertex_k
+            var m0 = values[offset0 + i + stride2] * td; // outTangent_k * (t_k+1 - t_k)
+            var p1 = values[offset1 + i + stride]; // splineVertex_k+1
+            var m1 = values[offset1 + i] * td; // inTangent_k+1 * (t_k+1 - t_k)
+
+            result[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
+
+        }
+
+        return result;
+
+    };
+}
+
+
+
+
+

src/3D/gltf/Interpolant.ts

+export class InterInterpolant {
+	parameterPositions: any;
+	_cachedIndex: number;
+	resultBuffer: any;
+	sampleValues: any;
+	valueSize: any;
+	constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+		this.parameterPositions = parameterPositions;
+		this._cachedIndex = 0;
+
+		this.resultBuffer = resultBuffer !== undefined ?
+			resultBuffer : new sampleValues.constructor(sampleSize);
+		this.sampleValues = sampleValues;
+		this.valueSize = sampleSize;
+	}
+	evaluate(t) {
+		var pp = this.parameterPositions,
+			i1 = this._cachedIndex,
+
+			t1 = pp[i1],
+			t0 = pp[i1 - 1];
+
+		validate_interval: {
+
+			seek: {
+
+				var right;
+
+				linear_scan: {
+
+					//- See http://jsperf.com/comparison-to-undefined/3
+					//- slower code:
+					//-
+					//- 				if ( t >= t1 || t1 === undefined ) {
+					forward_scan: if (!(t < t1)) {
+
+						for (var giveUpAt = i1 + 2; ;) {
+
+							if (t1 === undefined) {
+
+								if (t < t0) break forward_scan;
+
+								// after end
+
+								i1 = pp.length;
+								this._cachedIndex = i1;
+								return this.afterEnd_(i1 - 1/*, t, t0*/);
+
+							}
+
+							if (i1 === giveUpAt) break; // this loop
+
+							t0 = t1;
+							t1 = pp[++i1];
+
+							if (t < t1) {
+
+								// we have arrived at the sought interval
+								break seek;
+
+							}
+
+						}
+
+						// prepare binary search on the right side of the index
+						right = pp.length;
+						break linear_scan;
+
+					}
+
+					//- slower code:
+					//-					if ( t < t0 || t0 === undefined ) {
+					if (!(t >= t0)) {
+
+						// looping?
+
+						var t1global = pp[1];
+
+						if (t < t1global) {
+
+							i1 = 2; // + 1, using the scan for the details
+							t0 = t1global;
+
+						}
+
+						// linear reverse scan
+
+						for (var giveUpAt = i1 - 2; ;) {
+
+							if (t0 === undefined) {
+
+								// before start
+
+								this._cachedIndex = 0;
+								return this.beforeStart_(0/*, t, t1*/);
+
+							}
+
+							if (i1 === giveUpAt) break; // this loop
+
+							t1 = t0;
+							t0 = pp[--i1 - 1];
+
+							if (t >= t0) {
+
+								// we have arrived at the sought interval
+								break seek;
+
+							}
+
+						}
+
+						// prepare binary search on the left side of the index
+						right = i1;
+						i1 = 0;
+						break linear_scan;
+
+					}
+
+					// the interval is valid
+
+					break validate_interval;
+
+				} // linear scan
+
+				// binary search
+
+				while (i1 < right) {
+
+					var mid = (i1 + right) >>> 1;
+
+					if (t < pp[mid]) {
+
+						right = mid;
+
+					} else {
+
+						i1 = mid + 1;
+
+					}
+
+				}
+
+				t1 = pp[i1];
+				t0 = pp[i1 - 1];
+
+				// check boundary cases, again
+
+				if (t0 === undefined) {
+
+					this._cachedIndex = 0;
+					return this.beforeStart_(0/*, t, t1*/);
+
+				}
+
+				if (t1 === undefined) {
+
+					i1 = pp.length;
+					this._cachedIndex = i1;
+					return this.afterEnd_(i1 - 1/*, t0, t*/);
+
+				}
+
+			} // seek
+
+			this._cachedIndex = i1;
+
+			this.intervalChanged_(i1, t0, t1);
+
+		} // validate_interval
+
+		return this.interpolate_(i1, t0, t, t1);
+
+	}
+	settings = null;
+	DefaultSettings_ = {};
+	getSettings_() {
+
+		return this.settings || this.DefaultSettings_;
+
+	};
+
+	copySampleValue_(index) {
+
+		// copies a sample value to the result buffer
+
+		var result = this.resultBuffer,
+			values = this.sampleValues,
+			stride = this.valueSize,
+			offset = index * stride;
+
+		for (var i = 0; i !== stride; ++i) {
+
+			result[i] = values[offset + i];
+
+		}
+
+		return result;
+
+	};
+
+	// Template methods for derived classes:
+
+	interpolate_(i1, t0, t, t1) {
+
+		throw new Error('call to abstract method');
+		// implementations shall return this.resultBuffer
+
+	};
+
+	intervalChanged_(i1, t0, t1) {
+
+		// empty
+
+	}
+	beforeStart_ = this.copySampleValue_;
+
+	//( N-1, tN-1, t ), returns this.resultBuffer
+	afterEnd_ = this.copySampleValue_;
+}