@leafer-in/motion-path 1.0.6-rc1

package/src/index.ts

@@ -0,0 +1,103 @@
+export { HighCurveHelper } from './HighCurveHelper'
+export { HighBezierHelper } from './HighBezierHelper'
+export { motionPathType } from './decorator'
+
+import { IMotionPathData, IUI, IUnitData, IRotationPointData } from '@leafer-ui/interface'
+import { isNull, MatrixHelper, Transition, UI, UnitConvert } from '@leafer-ui/draw'
+
+import { HighCurveHelper } from './HighCurveHelper'
+import { motionPathType } from './decorator'
+
+
+Transition.register('motion', function (from: any, to: any, t: number, target: IUI): number {
+    if (!from) from = 0
+    else if (typeof from === 'object') from = UnitConvert.number(from, target.getMotionTotal())
+    if (!to) to = 0
+    else if (typeof to === 'object') to = UnitConvert.number(to, target.getMotionTotal())
+    return Transition.number(from, to, t)
+})
+
+
+const ui = UI.prototype
+
+
+// addAttr
+motionPathType()(ui, 'motionPath')
+motionPathType()(ui, 'motion')
+motionPathType(true)(ui, 'motionRotation')
+
+
+ui.getMotionPathData = function (): IMotionPathData {
+    const { parent } = this
+
+    if (!this.motionPath && parent) {
+        const { children } = parent
+        for (let i = 0; i < children.length; i++) {
+            if (children[i].motionPath) return children[i].getMotionPathData()
+        }
+    }
+
+    const data = this.__
+    if (data.__pathForMotion) return data.__pathForMotion
+    return data.__pathForMotion = HighCurveHelper.getMotionPathData(this.getPath(true, true))
+}
+
+ui.getMotionPoint = function (motionDistance: number | IUnitData): IRotationPointData {
+    const data = this.getMotionPathData()
+    const point = HighCurveHelper.getDistancePoint(data, motionDistance)
+    MatrixHelper.toOuterPoint(this.localTransform, point)
+    return point
+}
+
+ui.getMotionTotal = function (): number {
+    return this.getMotionPathData().total
+}
+
+ui.__updateMotionPath = function (): void {
+    const data = this.__
+    if (this.__layout.resized && data.__pathForMotion) data.__pathForMotion = undefined
+
+    if (this.motionPath) {
+        let child: IUI
+        const { children } = this.parent
+        for (let i = 0; i < children.length; i++) {
+            child = children[i]
+            if (!isNull(child.motion)) updateMotion(child)
+        }
+    } else {
+        updateMotion(this)
+    }
+}
+
+function updateMotion(leaf: IUI): void {
+    const { motion, motionRotation } = leaf
+    if (isNull(motion)) return
+
+    if (leaf.motionPath) {
+
+        const data = leaf.getMotionPathData()
+        if (data.total) leaf.__.__pathForRender = HighCurveHelper.getDistancePath(data, motion) // 生长路径
+
+    } else {
+
+        let child: IUI
+        const { children } = leaf.parent
+        for (let i = 0; i < children.length; i++) {
+            child = children[i]
+            if (child.motionPath) {
+                const data = child.getMotionPathData()
+                if (!data.total) return
+                const point = child.getMotionPoint(motion)
+                if (motionRotation === false) delete point.rotation
+                else {
+                    point.rotation += child.rotation
+                    if (typeof motionRotation === 'number') point.rotation += motionRotation
+                }
+
+                leaf.set(point) // 动画路径
+                break
+            }
+        }
+
+    }
+}

package/types/index.d.ts

@@ -0,0 +1,20 @@
+import * as _leafer_ui_interface from '@leafer-ui/interface';
+import { IPathCommandData, IMatrixData, IMotionPathData, IUnitData, IRotationPointData, IValue } from '@leafer-ui/interface';
+
+declare const HighCurveHelper: {
+    transform(data: IPathCommandData, matrix: IMatrixData): void;
+    transformPoints(data: IPathCommandData, matrix: IMatrixData, start: number, pointCount: number): void;
+    getMotionPathData(data: IPathCommandData): IMotionPathData;
+    getDistancePoint(distanceData: IMotionPathData, motionDistance: number | IUnitData): IRotationPointData;
+    getDistancePath(distanceData: IMotionPathData, motionDistance: number | IUnitData): IPathCommandData;
+};
+
+declare const HighBezierHelper: {
+    getDistance(fromX: number, fromY: number, x1: number, y1: number, x2: number, y2: number, toX: number, toY: number): number;
+    getDerivative(t: number, fromV: number, v1: number, v2: number, toV: number): number;
+    cut(data: IPathCommandData, t: number, fromX: number, fromY: number, x1: number, y1: number, x2: number, y2: number, toX: number, toY: number): void;
+};
+
+declare function motionPathType(defaultValue?: IValue): (target: _leafer_ui_interface.ILeaf, key: string) => void;
+
+export { HighBezierHelper, HighCurveHelper, motionPathType };