新增renderablecomponent显示

优化返回值

source/src/ECS/Components/Physics/Colliders/Collider.ts

@@ -205,7 +205,7 @@ module es {
          * 检查这个形状是否与物理系统中的其他对撞机重叠
          * @param other
          */
-        public overlaps(other: Collider) {
+        public overlaps(other: Collider): boolean {
             return this.shape.overlaps(other.shape);
         }
 
@@ -213,20 +213,21 @@ module es {
          * 检查这个与运动应用的碰撞器(移动向量)是否与碰撞器碰撞。如果是这样，将返回true，并且结果将填充碰撞数据。
          * @param collider
          * @param motion
+         * @param result
          */
-        public collidesWith(collider: Collider, motion: Vector2) {
+        public collidesWith(collider: Collider, motion: Vector2, result: CollisionResult): boolean {
             // 改变形状的位置，使它在移动后的位置，这样我们可以检查重叠
             let oldPosition = this.entity.position;
-            this.entity.position = Vector2.add(this.entity.position, motion);
+            this.entity.position.add(motion);
 
-            let result = this.shape.collidesWithShape(collider.shape);
-            if (result)
+            let didCollide = this.shape.collidesWithShape(collider.shape, result);
+            if (didCollide)
                 result.collider = collider;
 
             // 将图形位置返回到检查前的位置
             this.entity.position = oldPosition;
 
-            return result;
+            return didCollide;
         }
 
         public clone(): Component{

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

@@ -16,12 +16,11 @@ module es {
         /**
          * 计算修改运动矢量的运动，以考虑移动时可能发生的碰撞
          * @param motion
+         * @param collisionResult
          */
-        public calculateMovement(motion: Vector2){
-            let collisionResult = new CollisionResult();
-
+        public calculateMovement(motion: Vector2, collisionResult: CollisionResult): boolean{
             if (!this.entity.getComponent(Collider) || !this._triggerHelper){
-                return null;
+                return false;
             }
 
             // 移动所有的非触发碰撞器并获得最近的碰撞
@@ -37,9 +36,7 @@ module es {
                 let bounds = collider.bounds;
                 bounds.x += motion.x;
                 bounds.y += motion.y;
-                let boxcastResult = Physics.boxcastBroadphaseExcludingSelf(collider, bounds, collider.collidesWithLayers);
-                bounds = boxcastResult.bounds;
-                let neighbors = boxcastResult.tempHashSet;
+                let neighbors = Physics.boxcastBroadphaseExcludingSelf(collider, bounds, collider.collidesWithLayers);
 
                 for (let j = 0; j < neighbors.length; j ++){
                     let neighbor = neighbors[j];
@@ -47,13 +44,13 @@ module es {
                     if (neighbor.isTrigger)
                         continue;
 
-                    let _internalcollisionResult = collider.collidesWith(neighbor, motion);
-                    if (_internalcollisionResult){
+                    let _internalcollisionResult: CollisionResult = new CollisionResult();
+                    if (collider.collidesWith(neighbor, motion, _internalcollisionResult)){
                         // 如果碰撞 则退回之前的移动量
-                        motion = Vector2.subtract(motion, _internalcollisionResult.minimumTranslationVector);
+                        motion.subtract(_internalcollisionResult.minimumTranslationVector);
 
                         // 如果我们碰到多个对象，为了简单起见，只取第一个。
-                        if (_internalcollisionResult.collider){
+                        if (_internalcollisionResult.collider != null){
                             collisionResult = _internalcollisionResult;
                         }
                     }
@@ -62,7 +59,7 @@ module es {
 
             ListPool.free(colliders);
 
-            return {collisionResult: collisionResult, motion: motion};
+            return collisionResult.collider != null;
         }
 
         /**
@@ -81,15 +78,12 @@ module es {
         /**
          * 通过调用calculateMovement和applyMovement来移动考虑碰撞的实体;
          * @param motion
+         * @param collisionResult
          */
-        public move(motion: Vector2){
-            let movementResult = this.calculateMovement(motion);
-            let collisionResult = movementResult.collisionResult;
-            motion = movementResult.motion;
-
+        public move(motion: Vector2, collisionResult: CollisionResult){
+            this.calculateMovement(motion, collisionResult);
             this.applyMovement(motion);
-
-            return collisionResult;
+            return collisionResult.collider != null;
         }
     }
 }

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

@@ -28,8 +28,8 @@ module es {
 
             // 获取任何可能在新位置发生碰撞的东西
             let neighbors = Physics.boxcastBroadphase(this._collider.bounds, this._collider.collidesWithLayers);
-            for (let i = 0; i < neighbors.colliders.length; i ++){
-                let neighbor = neighbors.colliders[i];
+            for (let i = 0; i < neighbors.length; i ++){
+                let neighbor = neighbors[i];
                 if (this._collider.overlaps(neighbor) && neighbor.enabled){
                     didCollide = true;
                     this.notifyTriggerListeners(this._collider, neighbor);