贝塞尔曲线

source/src/ECS/Components/Physics/Mover.ts

@@ -23,11 +23,12 @@ class Mover extends Component {
             return null;
         }
 
+        // 移动所有的非触发碰撞器并获得最近的碰撞
         let colliders: Collider[] = this.entity.getComponents(Collider);
         for (let i = 0; i < colliders.length; i ++){
             let collider = colliders[i];
 
-            // 不检测触发器
+            // 不检测触发器 在我们移动后会重新访问它
             if (collider.isTrigger)
                 continue;
 
@@ -63,13 +64,23 @@ class Mover extends Component {
         return {collisionResult: collisionResult, motion: motion};
     }
 
+    /**
+     *  将calculatemomovement应用到实体并更新triggerHelper
+     * @param motion 
+     */
     public applyMovement(motion: Vector2){
+        // 移动实体到它的新位置，如果我们有一个碰撞，否则移动全部数量。当碰撞发生时，运动被更新
         this.entity.position = Vector2.add(this.entity.position, motion);
 
+        // 对所有是触发器的碰撞器与所有宽相位碰撞器进行重叠检查。任何重叠都会导致触发事件。
         if (this._triggerHelper)
             this._triggerHelper.update();
     }
 
+    /**
+     * 通过调用calculateMovement和applyMovement来移动考虑碰撞的实体;
+     * @param motion 
+     */
     public move(motion: Vector2){
         let movementResult = this.calculateMovement(motion);
         let collisionResult = movementResult.collisionResult;

source/src/ECS/Components/Physics/ProjectileMover.ts

@@ -0,0 +1,56 @@
+/**
+ * 只向itriggerlistener报告冲突的移动器
+ * 该对象将始终移动完整的距离
+ */
+class ProjectileMover extends Component {
+    private _tempTriggerList: ITriggerListener[] = [];
+    private _collider: Collider;
+
+    public onAddedToEntity(){
+        this._collider = this.entity.getComponent<Collider>(Collider);
+        if (!this._collider)
+            console.warn("ProjectileMover has no Collider. ProjectilMover requires a Collider!");
+    }
+
+    /**
+     * 移动考虑碰撞的实体
+     * @param motion 
+     */
+    public move(motion: Vector2): boolean{
+        if (!this._collider)
+            return false;
+
+        let didCollide = false;
+
+        // 获取我们在新位置可能发生碰撞的任何东西
+        this.entity.position = Vector2.add(this.entity.position, motion);
+
+        // 获取任何可能在新位置发生碰撞的东西
+        let neighbors = Physics.boxcastBroadphase(this._collider.bounds, this._collider.collidesWithLayers);
+        for (let i = 0; i < neighbors.colliders.length; i ++){
+            let neighbor = neighbors.colliders[i];
+            if (this._collider.overlaps(neighbor)){
+                didCollide = true;
+                this.notifyTriggerListeners(this._collider, neighbor);
+            }
+        }
+
+        return didCollide;
+    }
+
+    private notifyTriggerListeners(self: Collider, other: Collider){
+        // 通知我们重叠的碰撞器实体上的任何侦听器
+        other.entity.getComponents("ITriggerListener", this._tempTriggerList);
+        for (let i = 0; i < this._tempTriggerList.length; i ++){
+            this._tempTriggerList[i].onTriggerEnter(self, other);
+        }
+        this._tempTriggerList.length = 0;
+
+        // 通知此实体上的任何侦听器
+        this.entity.getComponents("ITriggerListener", this._tempTriggerList);
+        for (let i = 0; i < this._tempTriggerList.length; i ++){
+            this._tempTriggerList[i].onTriggerEnter(other, self);
+        }
+        this._tempTriggerList.length = 0;
+    }
+}

source/src/Math/Bezier.ts

@@ -0,0 +1,121 @@
+/** 贝塞尔帮助类 */
+class Bezier {
+    /**
+     * 二次贝塞尔曲线
+     * @param p0 
+     * @param p1 
+     * @param p2 
+     * @param t 
+     */
+    public static getPoint(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2 {
+        t = MathHelper.clamp01(t);
+        let oneMinusT = 1 - t;
+        return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(oneMinusT * oneMinusT), p0),
+            Vector2.multiply(new Vector2(2 * oneMinusT * t), p1)), Vector2.multiply(new Vector2(t * t), p2));
+    }
+
+    /**
+     * 得到二次贝塞尔函数的一阶导数
+     * @param p0 
+     * @param p1 
+     * @param p2 
+     * @param t 
+     */
+    public static getFirstDerivative(p0: Vector2, p1: Vector2, p2: Vector2, t: number) {
+        return Vector2.add(Vector2.multiply(new Vector2(2 * (1 - t)), Vector2.subtract(p1, p0)),
+            Vector2.multiply(new Vector2(2 * t), Vector2.subtract(p2, p1)));
+    }
+
+    /**
+     * 得到一个三次贝塞尔函数的一阶导数
+     * @param start 
+     * @param firstControlPoint 
+     * @param secondControlPoint 
+     * @param end 
+     * @param t 
+     */
+    public static getFirstDerivativeThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2,
+        end: Vector2, t: number) {
+        t = MathHelper.clamp01(t);
+        let oneMunusT = 1 - t;
+        return Vector2.add(Vector2.add(Vector2.multiply(new Vector2(3 * oneMunusT * oneMunusT), Vector2.subtract(firstControlPoint, start)),
+            Vector2.multiply(new Vector2(6 * oneMunusT * t), Vector2.subtract(secondControlPoint, firstControlPoint))),
+            Vector2.multiply(new Vector2(3 * t * t), Vector2.subtract(end, secondControlPoint)));
+    }
+
+    /**
+     * 计算一个三次贝塞尔
+     * @param start 
+     * @param firstControlPoint 
+     * @param secondControlPoint 
+     * @param end 
+     * @param t 
+     */
+    public static getPointThree(start: Vector2, firstControlPoint: Vector2, secondControlPoint: Vector2,
+        end: Vector2, t: number) {
+        t = MathHelper.clamp01(t);
+        let oneMunusT = 1 - t;
+        return Vector2.add(Vector2.add(Vector2.add(Vector2.multiply(new Vector2(oneMunusT * oneMunusT * oneMunusT), start),
+            Vector2.multiply(new Vector2(3 * oneMunusT * oneMunusT * t), firstControlPoint)),
+            Vector2.multiply(new Vector2(3 * oneMunusT * t * t), secondControlPoint)),
+            Vector2.multiply(new Vector2(t * t * t), end));
+    }
+
+    /**
+     * 递归地细分bezier曲线，直到满足距离校正
+     * 在这种算法中，平面切片的点要比曲面切片少。返回完成后应返回到ListPool的合并列表。
+     * @param start 
+     * @param firstCtrlPoint 
+     * @param secondCtrlPoint 
+     * @param end 
+     * @param distanceTolerance 
+     */
+    public static getOptimizedDrawingPoints(start: Vector2, firstCtrlPoint: Vector2, secondCtrlPoint: Vector2,
+        end: Vector2, distanceTolerance: number = 1) {
+        let points = ListPool.obtain<Vector2>();
+        points.push(start);
+        this.recursiveGetOptimizedDrawingPoints(start, firstCtrlPoint, secondCtrlPoint, end, points, distanceTolerance);
+        points.push(end);
+
+        return points;
+    }
+
+    /**
+     * 递归地细分bezier曲线，直到满足距离校正。在这种算法中，平面切片的点要比曲面切片少。
+     * @param start 
+     * @param firstCtrlPoint 
+     * @param secondCtrlPoint 
+     * @param end 
+     * @param points 
+     * @param distanceTolerance 
+     */
+    private static recursiveGetOptimizedDrawingPoints(start: Vector2, firstCtrlPoint: Vector2, secondCtrlPoint: Vector2,
+        end: Vector2, points: Vector2[], distanceTolerance: number) {
+        // 计算线段的所有中点
+        let pt12 = Vector2.divide(Vector2.add(start, firstCtrlPoint), new Vector2(2));
+        let pt23 = Vector2.divide(Vector2.add(firstCtrlPoint, secondCtrlPoint), new Vector2(2));
+        let pt34 = Vector2.divide(Vector2.add(secondCtrlPoint, end), new Vector2(2));
+
+        // 计算新半直线的中点
+        let pt123 = Vector2.divide(Vector2.add(pt12, pt23), new Vector2(2));
+        let pt234 = Vector2.divide(Vector2.add(pt23, pt34), new Vector2(2));
+
+        // 最后再细分最后两个中点。如果我们满足我们的距离公差，这将是我们使用的最后一点。
+        let pt1234 = Vector2.divide(Vector2.add(pt123, pt234), new Vector2(2));
+
+        // 试着用一条直线来近似整个三次曲线
+        let deltaLine = Vector2.subtract(end, start);
+
+        let d2 = Math.abs(((firstCtrlPoint.x, end.x) * deltaLine.y - (firstCtrlPoint.y - end.y) * deltaLine.x));
+        let d3 = Math.abs(((secondCtrlPoint.x - end.x) * deltaLine.y - (secondCtrlPoint.y - end.y) * deltaLine.x));
+
+        if ((d2 + d3) * (d2 + d3) < distanceTolerance * (deltaLine.x * deltaLine.x + deltaLine.y * deltaLine.y)) {
+            points.push(pt1234);
+            return;
+        }
+
+        // 继续细分
+        this.recursiveGetOptimizedDrawingPoints(start, pt12, pt123, pt1234, points, distanceTolerance);
+        this.recursiveGetOptimizedDrawingPoints(pt1234, pt234, pt34, end, points, distanceTolerance);
+    }
+}

source/src/Math/MathHelper.ts

@@ -58,6 +58,20 @@ class MathHelper {
         return value % 2 == 0;
     }
 
+    /**
+     * 数值限定在0-1之间
+     * @param value 
+     */
+    public static clamp01(value: number){
+        if (value < 0)
+            return 0;
+
+        if (value > 1)
+            return 1;
+
+        return value;
+    }
+
     public static angleBetweenVectors(from: Vector2, to: Vector2){
         return Math.atan2(to.y - from.y, to.x - from.x);
     }