Coroutine 类型从IEnumerable为Iterator

demo/index.html

@@ -31,7 +31,7 @@
          data-content-width="640"
          data-content-height="1136"
          data-multi-fingered="2"
-         data-show-fps="false" data-show-log="false"
+         data-show-fps="true" data-show-log="false"
          data-show-fps-style="x:0,y:0,size:12,textColor:0xffffff,bgAlpha:0.9">
     </div>
 <script>

demo/libs/framework/framework.d.ts

@@ -208,7 +208,7 @@ declare module es {
         static registerGlobalManager(manager: es.GlobalManager): void;
         static unregisterGlobalManager(manager: es.GlobalManager): void;
         static getGlobalManager<T extends es.GlobalManager>(type: any): T;
-        static startCoroutine(enumerator: IEnumerator): CoroutineImpl;
+        static startCoroutine(enumerator: Iterator<any>): CoroutineImpl;
         static schedule(timeInSeconds: number, repeats: boolean, context: any, onTime: (timer: ITimer) => void): Timer;
         onOrientationChanged(): void;
         draw(): Promise<void>;
@@ -580,6 +580,137 @@ declare module es {
         abstract reset(): any;
     }
 }
+declare module es {
+    class SceneComponent {
+        scene: Scene;
+        enabled: boolean;
+        updateOrder: number;
+        _enabled: boolean;
+        onEnabled(): void;
+        onDisabled(): void;
+        onRemovedFromScene(): void;
+        update(): void;
+        setEnabled(isEnabled: boolean): SceneComponent;
+        setUpdateOrder(updateOrder: number): this;
+        compareTo(other: SceneComponent): number;
+    }
+}
+declare module es {
+    class CollisionState {
+        right: boolean;
+        left: boolean;
+        above: boolean;
+        below: boolean;
+        becameGroundedThisFrame: boolean;
+        wasGroundedLastFrame: boolean;
+        isGroundedOnOnewayPlatform: boolean;
+        slopAngle: number;
+        readonly hasCollision: boolean;
+        _movementRemainderX: SubpixelNumber;
+        _movementRemainderY: SubpixelNumber;
+        reset(): void;
+        toString(): string;
+    }
+    class TiledMapMover extends Component {
+        colliderHorizontalInset: number;
+        colliderVerticalInset: number;
+        _boxColliderBounds: Rectangle;
+        constructor();
+        testCollisions(motion: Vector2, boxColliderBounds: Rectangle, collisionState: CollisionState): void;
+        testMapCollision(collisionRect: Rectangle, direction: Edge, collisionState: CollisionState, collisionResponse: number): void;
+        collisionRectForSide(side: Edge, motion: number): Rectangle;
+    }
+}
+declare module es {
+    interface ITriggerListener {
+        onTriggerEnter(other: Collider, local: Collider): any;
+        onTriggerExit(other: Collider, local: Collider): any;
+    }
+}
+declare module es {
+    class Mover extends Component {
+        private _triggerHelper;
+        onAddedToEntity(): void;
+        calculateMovement(motion: Vector2, collisionResult: CollisionResult): boolean;
+        applyMovement(motion: Vector2): void;
+        move(motion: Vector2, collisionResult: CollisionResult): boolean;
+    }
+}
+declare module es {
+    class ProjectileMover extends Component {
+        private _tempTriggerList;
+        private _collider;
+        onAddedToEntity(): void;
+        move(motion: Vector2): boolean;
+        private notifyTriggerListeners;
+    }
+}
+declare module es {
+    abstract class Collider extends Component {
+        shape: Shape;
+        isTrigger: boolean;
+        physicsLayer: Ref<number>;
+        collidesWithLayers: Ref<number>;
+        shouldColliderScaleAndRotateWithTransform: boolean;
+        registeredPhysicsBounds: Rectangle;
+        _localOffsetLength: number;
+        _isPositionDirty: boolean;
+        _isRotationDirty: boolean;
+        protected _colliderRequiresAutoSizing: any;
+        protected _isParentEntityAddedToScene: any;
+        protected _isColliderRegistered: any;
+        readonly absolutePosition: Vector2;
+        readonly rotation: number;
+        readonly bounds: Rectangle;
+        protected _localOffset: Vector2;
+        localOffset: Vector2;
+        setLocalOffset(offset: Vector2): Collider;
+        setShouldColliderScaleAndRotateWithTransform(shouldColliderScaleAndRotationWithTransform: boolean): Collider;
+        onAddedToEntity(): void;
+        onRemovedFromEntity(): void;
+        onEntityTransformChanged(comp: transform.Component): void;
+        onEnabled(): void;
+        onDisabled(): void;
+        registerColliderWithPhysicsSystem(): void;
+        unregisterColliderWithPhysicsSystem(): void;
+        overlaps(other: Collider): boolean;
+        collidesWith(collider: Collider, motion: Vector2, result: CollisionResult): boolean;
+    }
+}
+declare module es {
+    class BoxCollider extends Collider {
+        hollowShape: egret.Shape;
+        polygonShape: egret.Shape;
+        pixelShape1: egret.Shape;
+        pixelShape2: egret.Shape;
+        constructor(x?: number, y?: number, width?: number, height?: number);
+        width: number;
+        height: number;
+        setSize(width: number, height: number): this;
+        setWidth(width: number): BoxCollider;
+        setHeight(height: number): void;
+        debugRender(camera: Camera): void;
+        toString(): string;
+    }
+}
+declare module es {
+    class CircleCollider extends Collider {
+        private rectShape;
+        private circleShape;
+        private pixelShape1;
+        private pixelShape2;
+        constructor(radius?: number);
+        radius: number;
+        setRadius(radius: number): CircleCollider;
+        debugRender(camera: Camera): void;
+        toString(): string;
+    }
+}
+declare module es {
+    class PolygonCollider extends Collider {
+        constructor(points: Vector2[]);
+    }
+}
 declare module es {
     abstract class RenderableComponent extends Component implements IRenderable {
         displayObject: egret.DisplayObject;
@@ -613,18 +744,24 @@ declare module es {
     }
 }
 declare module es {
-    class SceneComponent {
+    class Mesh extends RenderableComponent {
-        scene: Scene;
+        displayObject: egret.Mesh;
-        enabled: boolean;
+        readonly bounds: Rectangle;
-        updateOrder: number;
+        _primitiveCount: number;
-        _enabled: boolean;
+        _topLeftVertPosition: Vector2;
-        onEnabled(): void;
+        _width: number;
-        onDisabled(): void;
+        _height: number;
-        onRemovedFromScene(): void;
+        _triangles: number[];
-        update(): void;
+        _verts: VertexPositionColorTexture[];
-        setEnabled(isEnabled: boolean): SceneComponent;
+        recalculateBounds(recalculateUVs: boolean): this;
-        setUpdateOrder(updateOrder: number): this;
+        setTexture(texture: egret.Texture): Mesh;
-        compareTo(other: SceneComponent): number;
+        setVertPositions(positions: Vector2[]): this;
+        setTriangles(triangles: number[]): this;
+        render(camera: es.Camera): void;
+    }
+    class VertexPositionColorTexture {
+        position: Vector2;
+        textureCoordinate: Vector2;
     }
 }
 declare module es {
@@ -730,32 +867,6 @@ declare module es {
         stop(): void;
     }
 }
-declare module es {
-    class CollisionState {
-        right: boolean;
-        left: boolean;
-        above: boolean;
-        below: boolean;
-        becameGroundedThisFrame: boolean;
-        wasGroundedLastFrame: boolean;
-        isGroundedOnOnewayPlatform: boolean;
-        slopAngle: number;
-        readonly hasCollision: boolean;
-        _movementRemainderX: SubpixelNumber;
-        _movementRemainderY: SubpixelNumber;
-        reset(): void;
-        toString(): string;
-    }
-    class TiledMapMover extends Component {
-        colliderHorizontalInset: number;
-        colliderVerticalInset: number;
-        _boxColliderBounds: Rectangle;
-        constructor();
-        testCollisions(motion: Vector2, boxColliderBounds: Rectangle, collisionState: CollisionState): void;
-        testMapCollision(collisionRect: Rectangle, direction: Edge, collisionState: CollisionState, collisionResponse: number): void;
-        collisionRectForSide(side: Edge, motion: number): Rectangle;
-    }
-}
 declare module es {
     class TiledMapRenderer extends RenderableComponent {
         tiledMap: TmxMap;
@@ -782,96 +893,6 @@ declare module es {
         removeColliders(): void;
     }
 }
-declare module es {
-    interface ITriggerListener {
-        onTriggerEnter(other: Collider, local: Collider): any;
-        onTriggerExit(other: Collider, local: Collider): any;
-    }
-}
-declare module es {
-    class Mover extends Component {
-        private _triggerHelper;
-        onAddedToEntity(): void;
-        calculateMovement(motion: Vector2, collisionResult: CollisionResult): boolean;
-        applyMovement(motion: Vector2): void;
-        move(motion: Vector2, collisionResult: CollisionResult): boolean;
-    }
-}
-declare module es {
-    class ProjectileMover extends Component {
-        private _tempTriggerList;
-        private _collider;
-        onAddedToEntity(): void;
-        move(motion: Vector2): boolean;
-        private notifyTriggerListeners;
-    }
-}
-declare module es {
-    abstract class Collider extends Component {
-        shape: Shape;
-        isTrigger: boolean;
-        physicsLayer: Ref<number>;
-        collidesWithLayers: Ref<number>;
-        shouldColliderScaleAndRotateWithTransform: boolean;
-        registeredPhysicsBounds: Rectangle;
-        _localOffsetLength: number;
-        _isPositionDirty: boolean;
-        _isRotationDirty: boolean;
-        protected _colliderRequiresAutoSizing: any;
-        protected _isParentEntityAddedToScene: any;
-        protected _isColliderRegistered: any;
-        readonly absolutePosition: Vector2;
-        readonly rotation: number;
-        readonly bounds: Rectangle;
-        protected _localOffset: Vector2;
-        localOffset: Vector2;
-        setLocalOffset(offset: Vector2): Collider;
-        setShouldColliderScaleAndRotateWithTransform(shouldColliderScaleAndRotationWithTransform: boolean): Collider;
-        onAddedToEntity(): void;
-        onRemovedFromEntity(): void;
-        onEntityTransformChanged(comp: transform.Component): void;
-        onEnabled(): void;
-        onDisabled(): void;
-        registerColliderWithPhysicsSystem(): void;
-        unregisterColliderWithPhysicsSystem(): void;
-        overlaps(other: Collider): boolean;
-        collidesWith(collider: Collider, motion: Vector2, result: CollisionResult): boolean;
-    }
-}
-declare module es {
-    class BoxCollider extends Collider {
-        hollowShape: egret.Shape;
-        polygonShape: egret.Shape;
-        pixelShape1: egret.Shape;
-        pixelShape2: egret.Shape;
-        constructor(x?: number, y?: number, width?: number, height?: number);
-        width: number;
-        height: number;
-        setSize(width: number, height: number): this;
-        setWidth(width: number): BoxCollider;
-        setHeight(height: number): void;
-        debugRender(camera: Camera): void;
-        toString(): string;
-    }
-}
-declare module es {
-    class CircleCollider extends Collider {
-        private rectShape;
-        private circleShape;
-        private pixelShape1;
-        private pixelShape2;
-        constructor(radius?: number);
-        radius: number;
-        setRadius(radius: number): CircleCollider;
-        debugRender(camera: Camera): void;
-        toString(): string;
-    }
-}
-declare module es {
-    class PolygonCollider extends Collider {
-        constructor(points: Vector2[]);
-    }
-}
 declare module es {
     class EntitySystem {
         private _entities;
@@ -1472,6 +1493,50 @@ declare module es {
         constructor(position: Vector2, end: Vector2);
     }
 }
+declare module es {
+    class SpatialHash {
+        gridBounds: Rectangle;
+        _raycastParser: RaycastResultParser;
+        _cellSize: number;
+        _inverseCellSize: number;
+        _overlapTestCircle: Circle;
+        _cellDict: NumberDictionary;
+        _tempHashSet: Collider[];
+        constructor(cellSize?: number);
+        register(collider: Collider): void;
+        remove(collider: Collider): void;
+        removeWithBruteForce(obj: Collider): void;
+        clear(): void;
+        debugDraw(secondsToDisplay: number, textScale?: number): void;
+        aabbBroadphase(bounds: Rectangle, excludeCollider: Collider, layerMask: number): Collider[];
+        linecast(start: Vector2, end: Vector2, hits: RaycastHit[], layerMask: number): number;
+        overlapCircle(circleCenter: Vector2, radius: number, results: Collider[], layerMask: any): number;
+        private cellCoords;
+        private cellAtPosition;
+        private debugDrawCellDetails;
+    }
+    class NumberDictionary {
+        _store: Map<string, Collider[]>;
+        add(x: number, y: number, list: Collider[]): void;
+        remove(obj: Collider): void;
+        tryGetValue(x: number, y: number): Collider[];
+        getKey(x: number, y: number): string;
+        clear(): void;
+    }
+    class RaycastResultParser {
+        hitCounter: number;
+        static compareRaycastHits: (a: RaycastHit, b: RaycastHit) => number;
+        _hits: RaycastHit[];
+        _tempHit: RaycastHit;
+        _checkedColliders: Collider[];
+        _cellHits: RaycastHit[];
+        _ray: Ray2D;
+        _layerMask: number;
+        start(ray: Ray2D, hits: RaycastHit[], layerMask: number): void;
+        checkRayIntersection(cellX: number, cellY: number, cell: Collider[]): boolean;
+        reset(): void;
+    }
+}
 declare module es {
     abstract class Shape {
         position: Vector2;
@@ -1579,47 +1644,60 @@ declare module es {
     }
 }
 declare module es {
-    class SpatialHash {
+    class Particle {
-        gridBounds: Rectangle;
+        position: Vector2;
-        _raycastParser: RaycastResultParser;
+        lastPosition: Vector2;
-        _cellSize: number;
+        mass: number;
-        _inverseCellSize: number;
+        radius: number;
-        _overlapTestCircle: Circle;
+        collidesWithColliders: boolean;
-        _cellDict: NumberDictionary;
+        isPinned: boolean;
-        _tempHashSet: Collider[];
+        acceleration: Vector2;
-        constructor(cellSize?: number);
+        pinnedPosition: Vector2;
-        register(collider: Collider): void;
+        applyForce(force: Vector2): void;
-        remove(collider: Collider): void;
-        removeWithBruteForce(obj: Collider): void;
-        clear(): void;
-        debugDraw(secondsToDisplay: number, textScale?: number): void;
-        aabbBroadphase(bounds: Rectangle, excludeCollider: Collider, layerMask: number): Collider[];
-        linecast(start: Vector2, end: Vector2, hits: RaycastHit[], layerMask: number): number;
-        overlapCircle(circleCenter: Vector2, radius: number, results: Collider[], layerMask: any): number;
-        private cellCoords;
-        private cellAtPosition;
-        private debugDrawCellDetails;
     }
-    class NumberDictionary {
+}
-        _store: Map<string, Collider[]>;
+declare module es {
-        add(x: number, y: number, list: Collider[]): void;
+    class VerletWorld {
-        remove(obj: Collider): void;
+        gravity: Vector2;
-        tryGetValue(x: number, y: number): Collider[];
+        constraintIterations: number;
-        getKey(x: number, y: number): string;
+        maximumStepIterations: number;
-        clear(): void;
+        simulationBounds?: Rectangle;
+        allowDragging: boolean;
+        _composites: Composite[];
+        static _colliders: Collider[];
+        _tempCircle: Circle;
+        _leftOverTime: number;
+        _fixedDeltaTime: number;
+        _iterationSteps: number;
+        _fixedDeltaTimeSq: number;
+        constructor(simulationBounds?: Rectangle);
+        update(): void;
+        handleCollisions(p: Particle, collidesWithLayers: number): void;
+        constrainParticleToBounds(p: Particle): void;
+        updateTiming(): void;
+        addComposite<T extends Composite>(composite: T): T;
+        removeComposite(composite: Composite): void;
+        handleDragging(): void;
+        debugRender(camera: Camera): void;
     }
-    class RaycastResultParser {
+}
-        hitCounter: number;
+declare module es {
-        static compareRaycastHits: (a: RaycastHit, b: RaycastHit) => number;
+    class Composite {
-        _hits: RaycastHit[];
+        friction: Vector2;
-        _tempHit: RaycastHit;
+        collidesWithLayers: number;
-        _checkedColliders: Collider[];
+        particles: Particle[];
-        _cellHits: RaycastHit[];
+        _constraints: Constraint[];
-        _ray: Ray2D;
+        solveConstraints(): void;
-        _layerMask: number;
+        updateParticles(deltaTimeSquared: number, gravity: Vector2): void;
-        start(ray: Ray2D, hits: RaycastHit[], layerMask: number): void;
+        handleConstraintCollisions(): void;
-        checkRayIntersection(cellX: number, cellY: number, cell: Collider[]): boolean;
+        debugRender(camera: Camera): void;
-        reset(): void;
+    }
+}
+declare module es {
+    abstract class Constraint {
+        collidesWithColliders: boolean;
+        abstract solve(): any;
+        handleCollisions(collidesWithLayers: number): void;
     }
 }
 declare module es {
@@ -2295,7 +2373,7 @@ declare module es {
 }
 declare module es {
     class CoroutineImpl implements ICoroutine, IPoolable {
-        enumerator: IEnumerator;
+        enumerator: Iterator<any>;
         waitTimer: number;
         isDone: boolean;
         waitForCoroutine: CoroutineImpl;
@@ -2305,16 +2383,11 @@ declare module es {
         prepareForuse(): void;
         reset(): void;
     }
-    interface IEnumerator {
-        current: any;
-        moveNext(): boolean;
-        reset(): any;
-    }
     class CoroutineManager extends GlobalManager {
         _isInUpdate: boolean;
         _unblockedCoroutines: CoroutineImpl[];
         _shouldRunNextFrame: CoroutineImpl[];
-        startCoroutine(enumerator: IEnumerator): CoroutineImpl;
+        startCoroutine(enumerator: Iterator<any>): CoroutineImpl;
         update(): void;
         tickCoroutine(coroutine: CoroutineImpl): boolean;
     }

demo/resource/default.res.json

@@ -1,7 +1,7 @@
 {
 	"groups": [
 		{
-			"keys": "bg_png,bgNorm_png,moon_png,orange_png,moonNorm_png,orangeNorm_png,tiledMap_json,orthogonal-outside_json,tilemap_json,plume_png",
+			"keys": "bg_png,bgNorm_png,moon_png,orange_png,moonNorm_png,orangeNorm_png,tiledMap_json,orthogonal-outside_json,tilemap_json,plume_png,cabbage_png",
 			"name": "preload"
 		},
 		{
@@ -116,6 +116,11 @@
 			"url": "preload/plume.png",
 			"type": "image",
 			"name": "plume_png"
+		},
+		{
+			"url": "preload/cabbage.png",
+			"type": "image",
+			"name": "cabbage_png"
 		}
 	]
 }

demo/src/Scenes/Empty Scene/BasicScene.ts

@@ -11,6 +11,7 @@ module samples {
 
                 this.camera.entity.addComponent(new es.FollowCamera(moonEntity));
             });
+
         }
     }
 }

demo/template/runtime/native_require.js

@@ -37,7 +37,7 @@ egret_native.egretStart = function () {
 		contentWidth: 640,
 		contentHeight: 1136,
 		showPaintRect: false,
-		showFPS: false,
+		showFPS: true,
 		fpsStyles: "x:0,y:0,size:12,textColor:0xffffff,bgAlpha:0.9",
 		showLog: false,
 		logFilter: "",

demo_fgui/.objs/metas/m4sln17a/k7mf0.info

@@ -0,0 +1 @@
+{}

demo_fgui/.objs/workspace.json

@@ -3,19 +3,21 @@
     "ui://m4sln17ak7mf0",
     "ui://m4sln17ajde15"
   ],
-  "libview.firstColumnWidth": 328,
-  "auxline1": true,
   "libview.iconScale": 0,
-  "backgroundColor": 6710886,
+  "auxline1": true,
   "doc.activeDoc": "ui://m4sln17ak7mf0",
-  "libview.currentGroup": "",
-  "canvasColor": 10066329,
-  "auxline2": true,
   "libview.twoColumn": false,
+  "libview.currentGroup": "",
+  "libview.firstColumnWidth": 459,
+  "auxline2": true,
+  "backgroundColor": 6710886,
+  "canvasColor": 10066329,
   "libview.expandedNodes": [
     "m4sln17a",
     "/",
     "m4sln17a",
+    "/资源/",
+    "m4sln17a",
     "/组件/"
   ]
 }

demo_fgui/assets/sc/package.xml

@@ -6,6 +6,7 @@
     <component id="jde13" name="combo_sc_item.xml" path="/组件/"/>
     <component id="jde14" name="combo_sc_popup.xml" path="/组件/"/>
     <component id="jde15" name="combo_sc.xml" path="/组件/" exported="true"/>
+    <image id="hn197" name="cabbage.png" path="/资源/"/>
   </resources>
   <publish name="" genCode="true"/>
 </packageDescription>

source/bin/framework.d.ts

@@ -208,7 +208,7 @@ declare module es {
         static registerGlobalManager(manager: es.GlobalManager): void;
         static unregisterGlobalManager(manager: es.GlobalManager): void;
         static getGlobalManager<T extends es.GlobalManager>(type: any): T;
-        static startCoroutine(enumerator: IEnumerator): CoroutineImpl;
+        static startCoroutine(enumerator: Iterator<any>): CoroutineImpl;
         static schedule(timeInSeconds: number, repeats: boolean, context: any, onTime: (timer: ITimer) => void): Timer;
         onOrientationChanged(): void;
         draw(): Promise<void>;
@@ -580,6 +580,137 @@ declare module es {
         abstract reset(): any;
     }
 }
+declare module es {
+    class SceneComponent {
+        scene: Scene;
+        enabled: boolean;
+        updateOrder: number;
+        _enabled: boolean;
+        onEnabled(): void;
+        onDisabled(): void;
+        onRemovedFromScene(): void;
+        update(): void;
+        setEnabled(isEnabled: boolean): SceneComponent;
+        setUpdateOrder(updateOrder: number): this;
+        compareTo(other: SceneComponent): number;
+    }
+}
+declare module es {
+    class CollisionState {
+        right: boolean;
+        left: boolean;
+        above: boolean;
+        below: boolean;
+        becameGroundedThisFrame: boolean;
+        wasGroundedLastFrame: boolean;
+        isGroundedOnOnewayPlatform: boolean;
+        slopAngle: number;
+        readonly hasCollision: boolean;
+        _movementRemainderX: SubpixelNumber;
+        _movementRemainderY: SubpixelNumber;
+        reset(): void;
+        toString(): string;
+    }
+    class TiledMapMover extends Component {
+        colliderHorizontalInset: number;
+        colliderVerticalInset: number;
+        _boxColliderBounds: Rectangle;
+        constructor();
+        testCollisions(motion: Vector2, boxColliderBounds: Rectangle, collisionState: CollisionState): void;
+        testMapCollision(collisionRect: Rectangle, direction: Edge, collisionState: CollisionState, collisionResponse: number): void;
+        collisionRectForSide(side: Edge, motion: number): Rectangle;
+    }
+}
+declare module es {
+    interface ITriggerListener {
+        onTriggerEnter(other: Collider, local: Collider): any;
+        onTriggerExit(other: Collider, local: Collider): any;
+    }
+}
+declare module es {
+    class Mover extends Component {
+        private _triggerHelper;
+        onAddedToEntity(): void;
+        calculateMovement(motion: Vector2, collisionResult: CollisionResult): boolean;
+        applyMovement(motion: Vector2): void;
+        move(motion: Vector2, collisionResult: CollisionResult): boolean;
+    }
+}
+declare module es {
+    class ProjectileMover extends Component {
+        private _tempTriggerList;
+        private _collider;
+        onAddedToEntity(): void;
+        move(motion: Vector2): boolean;
+        private notifyTriggerListeners;
+    }
+}
+declare module es {
+    abstract class Collider extends Component {
+        shape: Shape;
+        isTrigger: boolean;
+        physicsLayer: Ref<number>;
+        collidesWithLayers: Ref<number>;
+        shouldColliderScaleAndRotateWithTransform: boolean;
+        registeredPhysicsBounds: Rectangle;
+        _localOffsetLength: number;
+        _isPositionDirty: boolean;
+        _isRotationDirty: boolean;
+        protected _colliderRequiresAutoSizing: any;
+        protected _isParentEntityAddedToScene: any;
+        protected _isColliderRegistered: any;
+        readonly absolutePosition: Vector2;
+        readonly rotation: number;
+        readonly bounds: Rectangle;
+        protected _localOffset: Vector2;
+        localOffset: Vector2;
+        setLocalOffset(offset: Vector2): Collider;
+        setShouldColliderScaleAndRotateWithTransform(shouldColliderScaleAndRotationWithTransform: boolean): Collider;
+        onAddedToEntity(): void;
+        onRemovedFromEntity(): void;
+        onEntityTransformChanged(comp: transform.Component): void;
+        onEnabled(): void;
+        onDisabled(): void;
+        registerColliderWithPhysicsSystem(): void;
+        unregisterColliderWithPhysicsSystem(): void;
+        overlaps(other: Collider): boolean;
+        collidesWith(collider: Collider, motion: Vector2, result: CollisionResult): boolean;
+    }
+}
+declare module es {
+    class BoxCollider extends Collider {
+        hollowShape: egret.Shape;
+        polygonShape: egret.Shape;
+        pixelShape1: egret.Shape;
+        pixelShape2: egret.Shape;
+        constructor(x?: number, y?: number, width?: number, height?: number);
+        width: number;
+        height: number;
+        setSize(width: number, height: number): this;
+        setWidth(width: number): BoxCollider;
+        setHeight(height: number): void;
+        debugRender(camera: Camera): void;
+        toString(): string;
+    }
+}
+declare module es {
+    class CircleCollider extends Collider {
+        private rectShape;
+        private circleShape;
+        private pixelShape1;
+        private pixelShape2;
+        constructor(radius?: number);
+        radius: number;
+        setRadius(radius: number): CircleCollider;
+        debugRender(camera: Camera): void;
+        toString(): string;
+    }
+}
+declare module es {
+    class PolygonCollider extends Collider {
+        constructor(points: Vector2[]);
+    }
+}
 declare module es {
     abstract class RenderableComponent extends Component implements IRenderable {
         displayObject: egret.DisplayObject;
@@ -613,18 +744,24 @@ declare module es {
     }
 }
 declare module es {
-    class SceneComponent {
+    class Mesh extends RenderableComponent {
-        scene: Scene;
+        displayObject: egret.Mesh;
-        enabled: boolean;
+        readonly bounds: Rectangle;
-        updateOrder: number;
+        _primitiveCount: number;
-        _enabled: boolean;
+        _topLeftVertPosition: Vector2;
-        onEnabled(): void;
+        _width: number;
-        onDisabled(): void;
+        _height: number;
-        onRemovedFromScene(): void;
+        _triangles: number[];
-        update(): void;
+        _verts: VertexPositionColorTexture[];
-        setEnabled(isEnabled: boolean): SceneComponent;
+        recalculateBounds(recalculateUVs: boolean): this;
-        setUpdateOrder(updateOrder: number): this;
+        setTexture(texture: egret.Texture): Mesh;
-        compareTo(other: SceneComponent): number;
+        setVertPositions(positions: Vector2[]): this;
+        setTriangles(triangles: number[]): this;
+        render(camera: es.Camera): void;
+    }
+    class VertexPositionColorTexture {
+        position: Vector2;
+        textureCoordinate: Vector2;
     }
 }
 declare module es {
@@ -730,32 +867,6 @@ declare module es {
         stop(): void;
     }
 }
-declare module es {
-    class CollisionState {
-        right: boolean;
-        left: boolean;
-        above: boolean;
-        below: boolean;
-        becameGroundedThisFrame: boolean;
-        wasGroundedLastFrame: boolean;
-        isGroundedOnOnewayPlatform: boolean;
-        slopAngle: number;
-        readonly hasCollision: boolean;
-        _movementRemainderX: SubpixelNumber;
-        _movementRemainderY: SubpixelNumber;
-        reset(): void;
-        toString(): string;
-    }
-    class TiledMapMover extends Component {
-        colliderHorizontalInset: number;
-        colliderVerticalInset: number;
-        _boxColliderBounds: Rectangle;
-        constructor();
-        testCollisions(motion: Vector2, boxColliderBounds: Rectangle, collisionState: CollisionState): void;
-        testMapCollision(collisionRect: Rectangle, direction: Edge, collisionState: CollisionState, collisionResponse: number): void;
-        collisionRectForSide(side: Edge, motion: number): Rectangle;
-    }
-}
 declare module es {
     class TiledMapRenderer extends RenderableComponent {
         tiledMap: TmxMap;
@@ -782,96 +893,6 @@ declare module es {
         removeColliders(): void;
     }
 }
-declare module es {
-    interface ITriggerListener {
-        onTriggerEnter(other: Collider, local: Collider): any;
-        onTriggerExit(other: Collider, local: Collider): any;
-    }
-}
-declare module es {
-    class Mover extends Component {
-        private _triggerHelper;
-        onAddedToEntity(): void;
-        calculateMovement(motion: Vector2, collisionResult: CollisionResult): boolean;
-        applyMovement(motion: Vector2): void;
-        move(motion: Vector2, collisionResult: CollisionResult): boolean;
-    }
-}
-declare module es {
-    class ProjectileMover extends Component {
-        private _tempTriggerList;
-        private _collider;
-        onAddedToEntity(): void;
-        move(motion: Vector2): boolean;
-        private notifyTriggerListeners;
-    }
-}
-declare module es {
-    abstract class Collider extends Component {
-        shape: Shape;
-        isTrigger: boolean;
-        physicsLayer: Ref<number>;
-        collidesWithLayers: Ref<number>;
-        shouldColliderScaleAndRotateWithTransform: boolean;
-        registeredPhysicsBounds: Rectangle;
-        _localOffsetLength: number;
-        _isPositionDirty: boolean;
-        _isRotationDirty: boolean;
-        protected _colliderRequiresAutoSizing: any;
-        protected _isParentEntityAddedToScene: any;
-        protected _isColliderRegistered: any;
-        readonly absolutePosition: Vector2;
-        readonly rotation: number;
-        readonly bounds: Rectangle;
-        protected _localOffset: Vector2;
-        localOffset: Vector2;
-        setLocalOffset(offset: Vector2): Collider;
-        setShouldColliderScaleAndRotateWithTransform(shouldColliderScaleAndRotationWithTransform: boolean): Collider;
-        onAddedToEntity(): void;
-        onRemovedFromEntity(): void;
-        onEntityTransformChanged(comp: transform.Component): void;
-        onEnabled(): void;
-        onDisabled(): void;
-        registerColliderWithPhysicsSystem(): void;
-        unregisterColliderWithPhysicsSystem(): void;
-        overlaps(other: Collider): boolean;
-        collidesWith(collider: Collider, motion: Vector2, result: CollisionResult): boolean;
-    }
-}
-declare module es {
-    class BoxCollider extends Collider {
-        hollowShape: egret.Shape;
-        polygonShape: egret.Shape;
-        pixelShape1: egret.Shape;
-        pixelShape2: egret.Shape;
-        constructor(x?: number, y?: number, width?: number, height?: number);
-        width: number;
-        height: number;
-        setSize(width: number, height: number): this;
-        setWidth(width: number): BoxCollider;
-        setHeight(height: number): void;
-        debugRender(camera: Camera): void;
-        toString(): string;
-    }
-}
-declare module es {
-    class CircleCollider extends Collider {
-        private rectShape;
-        private circleShape;
-        private pixelShape1;
-        private pixelShape2;
-        constructor(radius?: number);
-        radius: number;
-        setRadius(radius: number): CircleCollider;
-        debugRender(camera: Camera): void;
-        toString(): string;
-    }
-}
-declare module es {
-    class PolygonCollider extends Collider {
-        constructor(points: Vector2[]);
-    }
-}
 declare module es {
     class EntitySystem {
         private _entities;
@@ -1472,6 +1493,50 @@ declare module es {
         constructor(position: Vector2, end: Vector2);
     }
 }
+declare module es {
+    class SpatialHash {
+        gridBounds: Rectangle;
+        _raycastParser: RaycastResultParser;
+        _cellSize: number;
+        _inverseCellSize: number;
+        _overlapTestCircle: Circle;
+        _cellDict: NumberDictionary;
+        _tempHashSet: Collider[];
+        constructor(cellSize?: number);
+        register(collider: Collider): void;
+        remove(collider: Collider): void;
+        removeWithBruteForce(obj: Collider): void;
+        clear(): void;
+        debugDraw(secondsToDisplay: number, textScale?: number): void;
+        aabbBroadphase(bounds: Rectangle, excludeCollider: Collider, layerMask: number): Collider[];
+        linecast(start: Vector2, end: Vector2, hits: RaycastHit[], layerMask: number): number;
+        overlapCircle(circleCenter: Vector2, radius: number, results: Collider[], layerMask: any): number;
+        private cellCoords;
+        private cellAtPosition;
+        private debugDrawCellDetails;
+    }
+    class NumberDictionary {
+        _store: Map<string, Collider[]>;
+        add(x: number, y: number, list: Collider[]): void;
+        remove(obj: Collider): void;
+        tryGetValue(x: number, y: number): Collider[];
+        getKey(x: number, y: number): string;
+        clear(): void;
+    }
+    class RaycastResultParser {
+        hitCounter: number;
+        static compareRaycastHits: (a: RaycastHit, b: RaycastHit) => number;
+        _hits: RaycastHit[];
+        _tempHit: RaycastHit;
+        _checkedColliders: Collider[];
+        _cellHits: RaycastHit[];
+        _ray: Ray2D;
+        _layerMask: number;
+        start(ray: Ray2D, hits: RaycastHit[], layerMask: number): void;
+        checkRayIntersection(cellX: number, cellY: number, cell: Collider[]): boolean;
+        reset(): void;
+    }
+}
 declare module es {
     abstract class Shape {
         position: Vector2;
@@ -1579,47 +1644,60 @@ declare module es {
     }
 }
 declare module es {
-    class SpatialHash {
+    class Particle {
-        gridBounds: Rectangle;
+        position: Vector2;
-        _raycastParser: RaycastResultParser;
+        lastPosition: Vector2;
-        _cellSize: number;
+        mass: number;
-        _inverseCellSize: number;
+        radius: number;
-        _overlapTestCircle: Circle;
+        collidesWithColliders: boolean;
-        _cellDict: NumberDictionary;
+        isPinned: boolean;
-        _tempHashSet: Collider[];
+        acceleration: Vector2;
-        constructor(cellSize?: number);
+        pinnedPosition: Vector2;
-        register(collider: Collider): void;
+        applyForce(force: Vector2): void;
-        remove(collider: Collider): void;
-        removeWithBruteForce(obj: Collider): void;
-        clear(): void;
-        debugDraw(secondsToDisplay: number, textScale?: number): void;
-        aabbBroadphase(bounds: Rectangle, excludeCollider: Collider, layerMask: number): Collider[];
-        linecast(start: Vector2, end: Vector2, hits: RaycastHit[], layerMask: number): number;
-        overlapCircle(circleCenter: Vector2, radius: number, results: Collider[], layerMask: any): number;
-        private cellCoords;
-        private cellAtPosition;
-        private debugDrawCellDetails;
     }
-    class NumberDictionary {
+}
-        _store: Map<string, Collider[]>;
+declare module es {
-        add(x: number, y: number, list: Collider[]): void;
+    class VerletWorld {
-        remove(obj: Collider): void;
+        gravity: Vector2;
-        tryGetValue(x: number, y: number): Collider[];
+        constraintIterations: number;
-        getKey(x: number, y: number): string;
+        maximumStepIterations: number;
-        clear(): void;
+        simulationBounds?: Rectangle;
+        allowDragging: boolean;
+        _composites: Composite[];
+        static _colliders: Collider[];
+        _tempCircle: Circle;
+        _leftOverTime: number;
+        _fixedDeltaTime: number;
+        _iterationSteps: number;
+        _fixedDeltaTimeSq: number;
+        constructor(simulationBounds?: Rectangle);
+        update(): void;
+        handleCollisions(p: Particle, collidesWithLayers: number): void;
+        constrainParticleToBounds(p: Particle): void;
+        updateTiming(): void;
+        addComposite<T extends Composite>(composite: T): T;
+        removeComposite(composite: Composite): void;
+        handleDragging(): void;
+        debugRender(camera: Camera): void;
     }
-    class RaycastResultParser {
+}
-        hitCounter: number;
+declare module es {
-        static compareRaycastHits: (a: RaycastHit, b: RaycastHit) => number;
+    class Composite {
-        _hits: RaycastHit[];
+        friction: Vector2;
-        _tempHit: RaycastHit;
+        collidesWithLayers: number;
-        _checkedColliders: Collider[];
+        particles: Particle[];
-        _cellHits: RaycastHit[];
+        _constraints: Constraint[];
-        _ray: Ray2D;
+        solveConstraints(): void;
-        _layerMask: number;
+        updateParticles(deltaTimeSquared: number, gravity: Vector2): void;
-        start(ray: Ray2D, hits: RaycastHit[], layerMask: number): void;
+        handleConstraintCollisions(): void;
-        checkRayIntersection(cellX: number, cellY: number, cell: Collider[]): boolean;
+        debugRender(camera: Camera): void;
-        reset(): void;
+    }
+}
+declare module es {
+    abstract class Constraint {
+        collidesWithColliders: boolean;
+        abstract solve(): any;
+        handleCollisions(collidesWithLayers: number): void;
     }
 }
 declare module es {
@@ -2295,7 +2373,7 @@ declare module es {
 }
 declare module es {
     class CoroutineImpl implements ICoroutine, IPoolable {
-        enumerator: IEnumerator;
+        enumerator: Iterator<any>;
         waitTimer: number;
         isDone: boolean;
         waitForCoroutine: CoroutineImpl;
@@ -2305,16 +2383,11 @@ declare module es {
         prepareForuse(): void;
         reset(): void;
     }
-    interface IEnumerator {
-        current: any;
-        moveNext(): boolean;
-        reset(): any;
-    }
     class CoroutineManager extends GlobalManager {
         _isInUpdate: boolean;
         _unblockedCoroutines: CoroutineImpl[];
         _shouldRunNextFrame: CoroutineImpl[];
-        startCoroutine(enumerator: IEnumerator): CoroutineImpl;
+        startCoroutine(enumerator: Iterator<any>): CoroutineImpl;
         update(): void;
         tickCoroutine(coroutine: CoroutineImpl): boolean;
     }

source/src/ECS/Components/Renderables/Mesh.ts

@@ -0,0 +1,106 @@
+///<reference path="RenderableComponent.ts"/>
+module es {
+    /**
+     * 可用于创建简单网格的基本类
+     */
+    export class Mesh extends RenderableComponent {
+        public displayObject: egret.Mesh = new egret.Mesh();
+        public get bounds(){
+            if (this._areBoundsDirty){
+                this._bounds.calculateBounds(Vector2.add(this.entity.transform.position, this._topLeftVertPosition), Vector2.zero,
+                    Vector2.zero, this.entity.transform.scale, this.entity.transform.rotation, this._width, this._height);
+                this._areBoundsDirty = false;
+            }
+
+            return this._bounds;
+        }
+
+        public _primitiveCount: number = 0;
+        public _topLeftVertPosition: Vector2;
+        public _width: number = 0;
+        public _height: number = 0;
+        public _triangles: number[] = [];
+        public _verts: VertexPositionColorTexture[] = [];
+
+        /**
+         * 重新计算边界和可选地设置uv。设置uv以最适合的方式映射纹理。
+         * @param recalculateUVs
+         */
+        public recalculateBounds(recalculateUVs: boolean){
+            this._topLeftVertPosition = new Vector2(Number.MAX_VALUE, Number.MAX_VALUE);
+            let max = new Vector2(Number.MIN_VALUE, Number.MIN_VALUE);
+
+            for (let i = 0; i < this._verts.length; i ++){
+                this._topLeftVertPosition.x = Math.min(this._topLeftVertPosition.x, this._verts[i].position.x);
+                this._topLeftVertPosition.y = Math.min(this._topLeftVertPosition.y, this._verts[i].position.y);
+                max.x = Math.max(max.x, this._verts[i].position.x);
+                max.y = Math.max(max.y, this._verts[i].position.y);
+            }
+
+            this._width = max.x - this._topLeftVertPosition.x;
+            this._height = max.y - this._topLeftVertPosition.y;
+
+            // 如果需要处理uv
+            if (recalculateUVs){
+                for (let i = 0; i < this._verts.length; i ++){
+                    this._verts[i].textureCoordinate.x = (this._verts[i].position.x - this._topLeftVertPosition.x) / this._width;
+                    this._verts[i].textureCoordinate.y = (this._verts[i].position.y - this._topLeftVertPosition.y) / this._height;
+                }
+            }
+
+            return this;
+        }
+
+        /**
+         * 设置纹理。传入null来取消纹理设置。
+         * @param texture
+         */
+        public setTexture(texture: egret.Texture): Mesh{
+            this.displayObject.texture = texture;
+            return this;
+        }
+
+        /**
+         * 设置vert位置。如果position数组与vert数组大小不匹配，则将重新创建vert数组。
+         * @param positions
+         */
+        public setVertPositions(positions: Vector2[]){
+            if (this._verts == undefined || this._verts.length != positions.length){
+                this._verts = new Array(positions.length);
+                this._verts.fill(new VertexPositionColorTexture(), 0, positions.length);
+            }
+
+            for (let i = 0; i < this._verts.length; i ++){
+                this._verts[i].position = positions[i];
+            }
+            return this;
+        }
+
+        /**
+         * 设置渲染的三角形索引
+         * @param triangles
+         */
+        public setTriangles(triangles: number[]){
+            if (triangles.length % 3 != 0){
+                console.error("三角形必须是3的倍数");
+                return;
+            }
+
+            this._primitiveCount = triangles.length / 3;
+            this._triangles = triangles;
+            return this;
+        }
+
+        public render(camera: es.Camera) {
+            let renderNode = this.displayObject.$renderNode as egret.sys.MeshNode;
+            renderNode.imageWidth = this._width;
+            renderNode.imageHeight = this._height;
+            renderNode.vertices = this._triangles;
+        }
+    }
+
+    export class VertexPositionColorTexture {
+        public position: Vector2;
+        public textureCoordinate: Vector2;
+    }
+}

source/src/ECS/Components/Renderables/RenderableComponent.ts

@@ -1,4 +1,4 @@
-///<reference path="./PooledComponent.ts" />
+///<reference path="../PooledComponent.ts" />
 module es {
     /**
      * 所有可渲染组件的基类

source/src/ECS/Core.ts

@@ -133,7 +133,7 @@ module es {
          * 返回null将使协程在下一帧中被执行。
          * @param enumerator
          */
-        public static startCoroutine(enumerator: IEnumerator){
+        public static startCoroutine(enumerator: Iterator<any>){
             return this._instance._coroutineManager.startCoroutine(enumerator);
         }
 

source/src/Utils/Coroutines/CoroutineManager.ts

@@ -3,7 +3,7 @@ module es {
      * CoroutineManager使用的内部类，用于隐藏协同程序所需的数据
      */
     export class CoroutineImpl implements ICoroutine, IPoolable {
-        public enumerator: IEnumerator;
+        public enumerator: Iterator<any>;
         /**
          * 每当产生延迟时，它就被添加到跟踪延迟的waitTimer中
          */
@@ -34,12 +34,6 @@ module es {
         }
     }
 
-    export interface IEnumerator {
-        current: any;
-        moveNext(): boolean;
-        reset();
-    }
-
     /**
      * 基本CoroutineManager。协同程序可以做以下事情:
      * - return null(在下一帧继续执行)
@@ -60,7 +54,7 @@ module es {
          * 将i枚举器添加到CoroutineManager。协程在每一帧调用更新之前被执行。
          * @param enumerator
          */
-        public startCoroutine(enumerator: IEnumerator) {
+        public startCoroutine(enumerator: Iterator<any>) {
             // 查找或创建CoroutineImpl
             let coroutine = Pool.obtain<CoroutineImpl>(CoroutineImpl);
             coroutine.prepareForuse();
@@ -126,30 +120,30 @@ module es {
          * @param coroutine
          */
         public tickCoroutine(coroutine: CoroutineImpl){
+            let current = coroutine.enumerator.next();
             // 这个协同程序已经完成了
-            if (!coroutine.enumerator.moveNext() || coroutine.isDone){
+            if (!current.value || current.done){
                 Pool.free<CoroutineImpl>(coroutine);
                 return false;
             }
 
-            if (coroutine.enumerator.current == null){
+            if (!current.value){
-                // 再运行下一帧
                 return true;
             }
 
-            if (coroutine.enumerator.current instanceof WaitForSeconds){
+            if (current.value instanceof WaitForSeconds){
-                coroutine.waitTimer = (coroutine.enumerator.current as WaitForSeconds).waitTime;
+                coroutine.waitTimer = (current.value as WaitForSeconds).waitTime;
                 return true;
             }
 
-            if (coroutine.enumerator.current instanceof Number){
+            if (current.value instanceof Number){
                 console.warn("协同程序检查返回一个Number类型，请不要在生产环境使用");
-                coroutine.waitTimer = Number(coroutine.enumerator.current);
+                coroutine.waitTimer = Number(current);
                 return true;
             }
 
-            if (coroutine.enumerator.current instanceof  CoroutineImpl){
+            if (current.value instanceof  CoroutineImpl){
-                coroutine.waitForCoroutine = coroutine.enumerator.current as CoroutineImpl;
+                coroutine.waitForCoroutine = current.value as CoroutineImpl;
                 return true;
             }else {
                 return true;