主版本（支持渲染版本移动分支至support_engine）

source/bin/framework.d.ts

@@ -1,52 +1,96 @@
 declare module es {
     /**
-     * 用于包装事件的一个小类
+     *  全局核心类
      */
-    class FuncPack {
-        /** 函数 */
-        func: Function;
-        /** 上下文 */
-        context: any;
-        constructor(func: Function, context: any);
-    }
-    /**
-     * 用于事件管理
-     */
-    class Emitter<T> {
-        private _messageTable;
-        constructor();
-        /**
-         * 开始监听项
-         * @param eventType 监听类型
-         * @param handler 监听函数
-         * @param context 监听上下文
-         */
-        addObserver(eventType: T, handler: Function, context: any): void;
-        /**
-         * 移除监听项
-         * @param eventType 事件类型
-         * @param handler 事件函数
-         */
-        removeObserver(eventType: T, handler: Function): void;
-        /**
-         * 触发该事件
-         * @param eventType 事件类型
-         * @param data 事件数据
-         */
-        emit(eventType: T, ...data: any[]): void;
-    }
-}
-declare module es {
-    /**
-     * 这里作为框架的核心件
-     * 全局函数移动到这
-     */
-    class Framework {
+    class Core {
         /**
          * 核心发射器。只发出核心级别的事件
          */
         static emitter: Emitter<CoreEvents>;
-        static batcher: IBatcher;
+        /**
+         * 启用/禁用焦点丢失时的暂停。如果为真，则不调用更新或渲染方法
+         */
+        static pauseOnFocusLost: boolean;
+        /**
+         * 是否启用调试渲染
+         */
+        static debugRenderEndabled: boolean;
+        /**
+         * 简化对内部类的全局内容实例的访问
+         */
+        static _instance: Core;
+        /**
+         * 用于确定是否应该使用EntitySystems
+         */
+        static entitySystemsEnabled: boolean;
+        _nextScene: Scene;
+        /**
+         * 用于凝聚GraphicsDeviceReset事件
+         */
+        _graphicsDeviceChangeTimer: ITimer;
+        /**
+         * 全局访问系统
+         */
+        _globalManagers: GlobalManager[];
+        _coroutineManager: CoroutineManager;
+        _timerManager: TimerManager;
+        width: number;
+        height: number;
+        constructor(width: number, height: number, enableEntitySystems?: boolean);
+        /**
+         * 提供对单例/游戏实例的访问
+         * @constructor
+         */
+        static readonly Instance: Core;
+        _frameCounterElapsedTime: number;
+        _frameCounter: number;
+        _totalMemory: number;
+        _titleMemory: (totalMemory: number, frameCounter: number) => void;
+        _scene: Scene;
+        /**
+         * 当前活动的场景。注意，如果设置了该设置，在更新结束之前场景实际上不会改变
+         */
+        /**
+        * 当前活动的场景。注意，如果设置了该设置，在更新结束之前场景实际上不会改变
+        * @param value
+        */
+        static scene: Scene;
+        /**
+         * 添加一个全局管理器对象，它的更新方法将调用场景前的每一帧。
+         * @param manager
+         */
+        static registerGlobalManager(manager: es.GlobalManager): void;
+        /**
+         * 删除全局管理器对象
+         * @param manager
+         */
+        static unregisterGlobalManager(manager: es.GlobalManager): void;
+        /**
+         * 获取类型为T的全局管理器
+         * @param type
+         */
+        static getGlobalManager<T extends es.GlobalManager>(type: any): T;
+        /**
+         * 启动一个coroutine。Coroutine可以将number延时几秒或延时到其他startCoroutine.Yielding
+         * null将使coroutine在下一帧被执行。
+         * @param enumerator
+         */
+        static startCoroutine(enumerator: any): ICoroutine;
+        /**
+         * 调度一个一次性或重复的计时器，该计时器将调用已传递的动作
+         * @param timeInSeconds
+         * @param repeats
+         * @param context
+         * @param onTime
+         */
+        static schedule(timeInSeconds: number, repeats: boolean, context: any, onTime: (timer: ITimer) => void): Timer;
+        startDebugDraw(): void;
+        /**
+         * 在一个场景结束后，下一个场景开始之前调用
+         */
+        onSceneChanged(): void;
+        protected initialize(): void;
+        protected update(currentTime?: number): Promise<void>;
     }
 }
 declare module es {
@@ -129,7 +173,6 @@ declare module es {
          * @param comp
          */
         onEntityTransformChanged(comp: transform.Component): void;
-        debugRender(batcher: IBatcher): void;
         /**
          *当父实体或此组件启用时调用
          */
@@ -144,31 +187,14 @@ declare module es {
 }
 declare module es {
     enum CoreEvents {
-        /**
-         * 在图形设备重置时触发。当这种情况发生时，任何渲染目标或其他内容的VRAM将被擦除，需要重新生成
-         */
-        graphicsDeviceReset = 0,
         /**
          * 当场景发生变化时触发
          */
-        sceneChanged = 1,
+        sceneChanged = 0,
         /**
-         * 当设备方向改变时触发
+         * 每帧更新事件
          */
-        orientationChanged = 2,
-        /**
-         * 当Core.useCustomUpdate为true时则派发该事件
-         */
-        sceneUpdated = 3,
-        addDefaultRender = 4,
-        setRenderTarget = 5,
-        clearGraphics = 6,
-        disposeRenderTarget = 7,
-        resolutionScale = 8,
-        resolutionOffset = 9,
-        createRenderTarget = 10,
-        createCamera = 11,
-        rendererSizeChanged = 12
+        frameUpdated = 1
     }
 }
 declare module es {
@@ -305,11 +331,6 @@ declare module es {
          * 每帧进行调用进行更新组件
          */
         update(): void;
-        /**
-         * 自定义渲染器可以选择是否调用它
-         * @param batcher
-         */
-        debugRender(batcher: IBatcher): void;
         /**
          * 将组件添加到组件列表中。返回组件。
          * @param component
@@ -517,69 +538,16 @@ declare module es {
     }
     /** 场景 */
     class Scene {
-        /**
-         * 默认场景 摄像机
-         */
-        camera: ICamera;
         /**
          * 这个场景中的实体列表
          */
         readonly entities: EntityList;
-        /** 管理当前在场景中的所有RenderableComponents的列表 Entitys */
-        readonly renderableComponents: RenderableComponentList;
-        /**
-         * 如果ResolutionPolicy是完美的像素，这将被设置为为它计算的比例
-         */
-        pixelPerfectScale: number;
-        /**
-         * 如果设置了，最终渲染到屏幕上的时间可以推迟到这个委托。
-         * 这实际上只在最终渲染可能需要全屏大小效果的情况下有用，即使使用了一个小的后置缓冲区
-         */
-        finalRenderDelegate: IFinalRenderDelegate;
-        private _finalRenderDelegate;
         /**
          * 管理所有实体处理器
          */
         readonly entityProcessors: EntityProcessorList;
-        /**
-         * 所有场景的默认分辨率大小
-         */
-        private static _defaultDesignResolutionSize;
-        private static _defaultDesignBleedSize;
-        /**
-         * 用于所有场景的默认分辨率策略
-         */
-        private static _defaultSceneResolutionPolicy;
-        /**
-         * 场景的解析策略
-         */
-        private _resolutionPolicy;
-        /**
-         * 场景使用的设计分辨率大小
-         */
-        private _designResolutionSize;
-        private _designBleedSize;
-        /**
-         * 这将根据分辨率策略进行设置，并用于RenderTarget的最终输出
-         */
-        private _finalRenderDestinationRect;
-        private _sceneRenderTarget;
-        private _destinationRenderTarget;
-        private _screenshotRequestCallback;
         readonly _sceneComponents: SceneComponent[];
-        _renderers: IRenderer[];
-        readonly _afterPostProcessorRenderers: IRenderer[];
         private _didSceneBegin;
-        private currentRenderId;
-        /**
-         * 设置新场景将使用的默认设计尺寸和分辨率策略，水平/垂直Bleed仅与BestFit相关
-         * @param width
-         * @param height
-         * @param sceneResolutionPolicy
-         * @param horizontalBleed
-         * @param vertialcalBleed
-         */
-        static setDefaultDesignResolution(width: number, height: number, sceneResolutionPolicy: SceneResolutionPolicy, horizontalBleed?: number, vertialcalBleed?: number): void;
         constructor();
         /**
          * 在场景子类中重写这个，然后在这里进行加载。
@@ -597,22 +565,7 @@ declare module es {
         unload(): void;
         begin(): void;
         end(): void;
-        updateResolutionScaler(): void;
-        /**
-         * 下一次绘制完成后，这将克隆回缓冲区，并调用回调与clone。
-         * 注意，当使用完Texture后，你必须处理掉它
-         * @param callback
-         */
-        requestScreenshot(callback: (texture: any) => void): void;
         update(): void;
-        render(): void;
-        /**
-         * 任何存在的PostProcessors都可以进行处理，然后我们对RenderTarget进行最后的渲染。
-         * 几乎在所有情况下，finalRenderTarget都是空的。
-         * 只有在场景转换的第一帧中，如果转换请求渲染，它才会有一个值。
-         * @param finalRenderTarget
-         */
-        postRender(finalRenderTarget?: any): void;
         /**
          * 向组件列表添加并返回SceneComponent
          * @param component
@@ -633,21 +586,6 @@ declare module es {
          * @param component
          */
         removeSceneComponent(component: SceneComponent): void;
-        /**
-         * 添加一个渲染器到场景中
-         * @param renderer
-         */
-        addRenderer<T extends IRenderer>(renderer: T): T;
-        /**
-         * 得到第一个T型的渲染器
-         * @param type
-         */
-        getRenderer<T extends IRenderer>(type: any): T;
-        /**
-         * 从场景中移除渲染器
-         * @param renderer
-         */
-        removeRenderer(renderer: IRenderer): void;
         /**
          * 将实体添加到此场景，并返回它
          * @param name
@@ -1272,7 +1210,6 @@ declare module es {
          * @param height
          */
         setHeight(height: number): void;
-        debugRender(batcher: IBatcher): void;
         toString(): string;
     }
 }
@@ -1292,7 +1229,6 @@ declare module es {
          * @param radius
          */
         setRadius(radius: number): CircleCollider;
-        debugRender(batcher: IBatcher): void;
         toString(): string;
     }
 }
@@ -1306,183 +1242,6 @@ declare module es {
          * @param points
          */
         constructor(points: Vector2[]);
-        debugRender(batcher: IBatcher): void;
-    }
-}
-declare module es {
-    /**
-     * 接口，当应用于一个Component时，它将被注册到场景渲染器中。
-     * 请仔细实现这个功能 改变像layerDepth/renderLayer/material这样的东西需要更新Scene RenderableComponentList
-     */
-    interface IRenderable {
-        /** 包裹此对象的AABB。用来进行相机筛选 */
-        bounds: Rectangle;
-        /** 这个IRenderable是否应该被渲染 */
-        enabled: boolean;
-        /**
-         * 标准的Batcher图层深度，0为前面，1为后面。
-         * 改变这个值会触发场景中可渲染组件列表的排序
-         */
-        layerDepth: number;
-        /**
-         * 较低的renderLayers在前面，较高的在後面，就像layerDepth一样，但不是限制在0-1。
-         * 请注意，这意味着较高的renderLayers首先被发送到Batcher。在使用模板缓冲区时，这是一个重要的事实
-         */
-        renderLayer: number;
-        /**
-         * 由渲染器使用，用于指定该精灵应如何渲染。
-         * 如果非空，当组件从实体中移除时，它会被自动处理。
-         */
-        material: any;
-        /**
-         * 这个Renderable的可见性。
-         * 状态的改变最终会调用onBecameVisible/onBecameInvisible方法
-         */
-        isVisible: boolean;
-        /**
-         * 用于检索一个已经铸造的Material子类的帮助程序
-         */
-        getMaterial<T extends IMaterial>(): T;
-        /**
-         * 如果Renderables的边界与Camera.bounds相交，则返回true。
-         * 处理isVisible标志的状态切换。
-         * 在你的渲染方法中使用这个方法来决定你是否应该渲染
-         * @param camera
-         */
-        isVisibleFromCamera(camera: ICamera): boolean;
-        /**
-         * 被渲染器调用。摄像机可以用来进行裁剪，并使用Batcher实例进行绘制
-         * @param batcher
-         * @param camera
-         */
-        render(batcher: IBatcher, camera: ICamera): any;
-        /**
-         * 只有在没有对撞机的情况下才会渲染边界。
-         * 始终在原点上渲染一个正方形
-         * @param batcher
-         */
-        debugRender(batcher: IBatcher): any;
-    }
-    /**
-     * 对IRenderables进行排序的比较器。
-     * 首先按 RenderLayer 排序，然后按 LayerDepth 排序。
-     * 如果出现平局，则使用材料作为平局的断定器，以避免渲染状态的改变
-     */
-    class RenderableComparer implements IComparer<IRenderable> {
-        compare(self: IRenderable, other: IRenderable): number;
-    }
-}
-declare module es {
-    /**
-     * IRenderable的具体实现。包含方便的方法。
-     * 非常重要！子类必须覆盖width/height或bounds! 子类必须覆盖width/height或bounds!
-     */
-    abstract class RenderableComponent extends Component implements IRenderable, IComparer<RenderableComponent> {
-        static renderIdGenerator: number;
-        /**
-         * 不重写bounds属性的子类必须实现这个！RenderableComponent的宽度。
-         */
-        abstract readonly width: any;
-        /**
-         * 不重写bounds属性的子类必须实现这个!
-         */
-        abstract readonly height: any;
-        /**
-         * 包裹此对象的AABB。用来进行相机筛选。
-         */
-        abstract readonly bounds: any;
-        /**
-         * 标准的Batcher图层深度，0为前面，1为后面。
-         * 改变这个值会触发场景中可渲染组件列表的排序。
-         */
-        layerDepth: number;
-        /**
-         * 较低的renderLayers在前面，较高的在后面，就像layerDepth一樣，但不是限制在0-1。
-         * 请注意，这意味着更高的renderLayers首先被发送到Batcher。
-         */
-        renderLayer: number;
-        /**
-         * 渲染时传递给批处理程序的颜色
-         */
-        color: number;
-        /**
-         * 由渲染器使用，用于指定该精灵的渲染方式
-         */
-        material: IMaterial;
-        /**
-         * 偏移。用于将多个Renderables添加到需要特定定位的实体
-         */
-        localOffset: Vector2;
-        /**
-         * 这个Renderable的可见性。
-         * 状态的改变最终会调用onBecameVisible/onBecameInvisible方法
-         */
-        isVisible: boolean;
-        constructor();
-        debugRenderEnabled: boolean;
-        protected _localOffset: Vector2;
-        protected _layerDepth: number;
-        protected _renderLayer: number;
-        protected _bounds: Rectangle;
-        protected _isVisble: boolean;
-        protected _areBoundsDirty: boolean;
-        onEntityTransformChanged(comp: transform.Component): void;
-        /**
-         * 被渲染器调用。摄像机可以用来进行裁剪，并使用Batcher实例进行绘制
-         * @param batcher
-         * @param camera
-         */
-        abstract render(batcher: IBatcher, camera: ICamera): any;
-        /**
-         * 只有在没有对撞机的情况下才会渲染边界。始终在原点上渲染一个正方形
-         * @param batcher
-         */
-        debugRender(batcher: IBatcher): void;
-        /**
-         * 当Renderable进入相机帧时被调用。
-         * 请注意，如果您的Renderer没有使用isVisibleFromCamera来进行裁剪检查，这些方法将不会被调用。
-         * 所有默认的Renderer都会这样做
-         */
-        protected onBecameVisible(): void;
-        /**
-         * 当渲染器退出相机帧时，将调用这些方法。
-         * 请注意，如果你的Renderer没有使用isVisibleFromCamera来进行Culling检查，这些方法将不会被调用。
-         * 所有默认的Renderer都会这样做
-         */
-        protected onBecameInvisible(): void;
-        onRemovedFromEntity(): void;
-        /**
-         * 如果Renderables的边界与Camera.bounds相交，则返回true。
-         * 处理isVisible标志的状态切换。在你的渲染方法中使用这个方法来决定你是否应该渲染
-         * @param camera
-         */
-        isVisibleFromCamera(camera: ICamera): boolean;
-        setMaterial(material: IMaterial): this;
-        /**
-         * 标准的Batcher图层深度，0为前面，1为后面。
-         * 改变这个值会触发一种类似于renderableComponents的方法
-         * @param layerDepth
-         */
-        setLayerDepth(layerDepth: number): RenderableComponent;
-        /**
-        * 较低的渲染层在前面，较高的在后面
-        * @param renderLayer
-        */
-        setRenderLayer(renderLayer: number): RenderableComponent;
-        /**
-         * 偏移。用于将多个Renderables添加到需要特定定位的实体
-         * @param offset
-         */
-        setLocalOffset(offset: Vector2): RenderableComponent;
-        /**
-         * 用于检索一个已经铸造的Material子类的帮助程序
-         */
-        getMaterial<T extends IMaterial>(): T;
-        /**
-         * 先按renderLayer排序，再按layerDepth排序，最后按材质排序
-         * @param other
-         */
-        compare(other: RenderableComponent): 1 | -1 | 0;
     }
 }
 declare module es {
@@ -1633,7 +1392,6 @@ declare module es {
         onEntityTransformChanged(comp: transform.Component): void;
         onEntityEnabled(): void;
         onEntityDisabled(): void;
-        debugRender(batcher: IBatcher): void;
     }
 }
 declare module es {
@@ -1788,39 +1546,6 @@ declare module es {
         one(...types: any[]): this;
     }
 }
-declare module es {
-    class RenderableComponentList {
-        static compareUpdatableOrder: IComparer<IRenderable>;
-        /**
-         * 添加到实体的组件列表
-         */
-        private _components;
-        /**
-         * 通过renderLayer跟踪组件，便于检索
-         */
-        private _componentsByRenderLayer;
-        private _unsortedRenderLayers;
-        private _componentsNeedSort;
-        readonly count: number;
-        readonly buffer: IRenderable[];
-        get(index: number): IRenderable;
-        add(component: IRenderable): void;
-        remove(component: IRenderable): void;
-        updateRenderableRenderLayer(component: IRenderable, oldRenderLayer: number, newRenderLayer: number): void;
-        /**
-         * 弄脏RenderLayers排序标志，导致所有组件的重新排序
-         * @param renderLayer
-         */
-        setRenderLayerNeedsComponentSort(renderLayer: number): void;
-        private addToRenderLayerList;
-        /**
-         * 获取所有给定renderLayer的组件。组件列表是预先排序的。
-         * @param renderLayer
-         */
-        componentsWithRenderLayer(renderLayer: number): IRenderable[];
-        updateList(): void;
-    }
-}
 declare class StringUtils {
     /**
      * 特殊符号字符串
@@ -2001,166 +1726,6 @@ declare class TimeUtils {
      */
     static timeToMillisecond(time: string, partition?: string): string;
 }
-declare module es {
-    interface IBatcher {
-        /**
-         * 创建投影矩阵时要使用的矩阵
-         */
-        transformMatrix: Matrix;
-        /**
-         * 如果为true，则将在绘制目标位置之前将其四舍五入
-         */
-        shouldRoundDestinations: boolean;
-        disposed(): any;
-        begin(id: Ref<number>, effect: any, transformationMatrix?: Matrix, disableBatching?: boolean): any;
-        end(): any;
-        prepRenderState(): any;
-        /**
-         * 设置是否应忽略位置舍入。在为调试绘制基元时很有用
-         */
-        setIgnoreRoundingDestinations(shouldIgnore: boolean): any;
-        drawHollowRect(rect: Rectangle, color: number, thickness?: number): any;
-        drawHollowBounds(x: number, y: number, width: number, height: number, color: number, thickness: number): any;
-        drawLine(start: Vector2, end: Vector2, color: number, thickness: any): any;
-        draw(texture: any, position: Vector2, color?: number, rotation?: number, origin?: Vector2, scale?: Vector2, effects?: any): any;
-        drawPixel(position: Vector2, color: number, size?: number): any;
-        drawPolygon(position: Vector2, points: Vector2[], color: number, closePoly?: boolean, thickness?: number): any;
-        drawCircle(position: Vector2, radius: number, color: number, thickness?: number, resolution?: number): any;
-    }
-}
-declare module es {
-    interface ICamera extends Component {
-        position: Vector2;
-        rotation: number;
-        rawZoom: number;
-        zoom: number;
-        minimumZoom: number;
-        maximumZoom: number;
-        bounds: Rectangle;
-        transformMatrix: Matrix2D;
-        inverseTransformMatrix: Matrix2D;
-        projectionMatrix: Matrix;
-        viewprojectionMatrix: Matrix;
-        origin: Vector2;
-        setInset(left: number, right: number, top: number, bottom: number): ICamera;
-        setPosition(position: Vector2): ICamera;
-        setRotation(rotation: number): ICamera;
-        setZoom(zoom: number): ICamera;
-        setMinimumZoom(minZoom: number): ICamera;
-        setMaximumZoom(maxZoom: number): ICamera;
-        forceMatrixUpdate(): any;
-        onEntityTransformChanged(comp: transform.Component): any;
-        zoomIn(deltaZoom: number): any;
-        zoomOut(deltaZoom: number): any;
-        worldToScreenPoint(worldPosition: Vector2): Vector2;
-        screenToWorldPoint(screenPosition: Vector2): Vector2;
-        onSceneRenderTargetSizeChanged(newWidth: number, newHeight: number): any;
-    }
-}
-declare module es {
-    /**
-     * 可选接口，可以添加到任何对象中，用于特殊情况下需要覆盖最终渲染到屏幕。
-     * 请注意，如果有IFinalRenderDelegate存在，Scene.screenshotRequestCallback将不会像预期的那样工作。
-     */
-    interface IFinalRenderDelegate {
-        /**
-         * 在添加到场景中时调用
-         * @param scene
-         */
-        onAddedToScene(scene: Scene): any;
-        /**
-         * 当后置缓冲区大小改变时调用
-         * @param newWidth
-         * @param newHeight
-         */
-        onSceneBackBufferSizeChanged(newWidth: number, newHeight: number): any;
-        /**
-         * 这个被场景调用，这样就可以处理最终的渲染。渲染应该在finalRenderTarget中完成。
-         * 在大多数情况下，finalRenderTarget将是空的，所以渲染将只是到回缓冲区。
-         * finalRenderTarget只有在场景转换的第一帧时才会被设置，其中转换已经请求了上一个场景的渲染
-         * @param finalRenderTarget
-         * @param source
-         * @param finalRenderDestinationRect
-         */
-        handleFinalRender(finalRenderTarget: any, source: any, finalRenderDestinationRect: Rectangle): any;
-        /**
-         * 场景结束时调用。在这里释放任何资源
-         */
-        unload(): any;
-    }
-}
-declare module es {
-    /**
-     * 便利的子类，有一个单一的属性，可以投递Effect，使配置更简单
-     */
-    interface IMaterial {
-        /**
-         * Batcher为当前RenderableComponent使用的效果
-         */
-        effect: any;
-        dispose(): any;
-        onPreRender(camera: ICamera): any;
-        compareTo(other: IMaterial): number;
-        clone(): IMaterial;
-    }
-}
-declare module es {
-    interface IRenderer {
-        /**
-         * Batcher使用的材料。任何RenderableComponent都可以覆盖它
-         */
-        material: IMaterial;
-        /**
-        * 渲染器用于渲染的Camera(实际上是它的transformMatrix和culling的边界)。
-        * 这是一个方便的字段，不是必需的。
-        * 渲染器子类可以在调用beginRender时选择使用的摄像机
-        */
-        camera: ICamera;
-        /**
-         * 指定场景调用渲染器的顺序
-         */
-        renderOrder: number;
-        /**
-         * 如果renderTarget不是空的，这个渲染器将渲染到RenderTarget中，而不是渲染到屏幕上
-         */
-        renderTexture: any;
-        /**
-         * 标志，决定是否要调试渲染。
-         * 渲染方法接收一个bool(debugRenderEnabled)让渲染器知道全局调试渲染是否开启/关闭。
-         * 然后渲染器使用本地的bool来决定是否应该调试渲染
-         */
-        shouldDebugRender: boolean;
-        /**
-         * 如果为true，场景将使用场景RenderTarget调用SetRenderTarget。
-         * 如果Renderer有一个renderTexture，默认的实现会返回true
-         */
-        wantsToRenderToSceneRenderTarget: boolean;
-        /**
-         * 如果为true，场景将在所有后处理器完成后调用渲染方法。
-         * 这必须在调用Scene.addRenderer生效之前设置为true，并且Renderer不应该有renderTexture。
-         * 使用这种类型的渲染器的主要原因是为了让你可以在不进行后期处理的情况下，在Scene的其余部分上渲染你的UI。
-         * ScreenSpaceRenderer是一个将此设置为真的Renderer例子
-         */
-        wantsToRenderAfterPostProcessors: boolean;
-        /**
-         * 当Renderer被添加到场景中时被调用
-         * @param scene
-         */
-        onAddedToScene(scene: Scene): any;
-        /**
-         * 当场景结束或该渲染器从场景中移除时，调用该函数，用于清理
-         */
-        unload(): any;
-        render(scene: Scene): any;
-        /**
-         * 当默认的场景RenderTarget被调整大小时，以及在场景已经开始的情况下添加一个Renderer时，会被调用。
-         * @param newWidth
-         * @param newHeight
-         */
-        onSceneBackBufferSizeChanged(newWidth: number, newHeight: number): any;
-        compare(other: IRenderer): number;
-    }
-}
 declare module es {
     /**
      * 三次方和二次方贝塞尔帮助器(cubic and quadratic bezier helper)
@@ -3449,6 +3014,44 @@ declare module es {
         static boxToBoxCast(first: Box, second: Box, movement: Vector2, hit: RaycastHit): boolean;
     }
 }
+declare module es {
+    /**
+     * 用于包装事件的一个小类
+     */
+    class FuncPack {
+        /** 函数 */
+        func: Function;
+        /** 上下文 */
+        context: any;
+        constructor(func: Function, context: any);
+    }
+    /**
+     * 用于事件管理
+     */
+    class Emitter<T> {
+        private _messageTable;
+        constructor();
+        /**
+         * 开始监听项
+         * @param eventType 监听类型
+         * @param handler 监听函数
+         * @param context 监听上下文
+         */
+        addObserver(eventType: T, handler: Function, context: any): void;
+        /**
+         * 移除监听项
+         * @param eventType 事件类型
+         * @param handler 事件函数
+         */
+        removeObserver(eventType: T, handler: Function): void;
+        /**
+         * 触发该事件
+         * @param eventType 事件类型
+         * @param data 事件数据
+         */
+        emit(eventType: T, ...data: any[]): void;
+    }
+}
 declare module es {
     enum Edge {
         top = 0,
@@ -4773,7 +4376,7 @@ declare module es {
          * @param a
          * @param b
          */
-        compare(a: EndPoint, b: EndPoint): 1 | -1 | 0;
+        compare(a: EndPoint, b: EndPoint): 0 | 1 | -1;
     }
 }
 declare module es {