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

source/src/ECS/Component.ts

@@ -78,9 +78,6 @@ module es {
         public onEntityTransformChanged(comp: transform.Component) {
         }
 
-        public debugRender(batcher: IBatcher) {
-        }
-
         /**
          *当父实体或此组件启用时调用
          */

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

@@ -84,14 +84,6 @@ module es {
             }
         }
 
-        public debugRender(batcher: IBatcher) {
-            let poly = this.shape as Polygon;
-            batcher.drawHollowRect(this.bounds, Debug.colliderBounds, 1);
-            batcher.drawPolygon(this.shape.position, poly.points, Debug.colliderEdge, true, 1);
-            batcher.drawPixel(this.entity.transform.position, Debug.colliderPosition, 4);
-            batcher.drawPixel(Vector2.add(this.entity.transform.position, this.shape.center), Debug.colliderCenter, 2);
-        }
-
         public toString() {
             return `[BoxCollider: bounds: ${this.bounds}]`;
         }

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

@@ -40,13 +40,6 @@ module es {
             return this;
         }
 
-        public debugRender(batcher: IBatcher) {
-            batcher.drawHollowRect(this.bounds, Debug.colliderBounds, 1);
-            batcher.drawCircle(this.shape.position, (this.shape as Circle).radius, Debug.colliderEdge, 1);
-            batcher.drawPixel(this.entity.transform.position, Debug.colliderPosition, 4);
-            batcher.drawPixel(this.shape.position, Debug.colliderCenter, 2);
-        }
-
         public toString() {
             return `[CircleCollider: bounds: ${this.bounds}, radius: ${(this.shape as Circle).radius}]`
         }

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

@@ -114,32 +114,6 @@ module es {
         }
 
         public onAddedToEntity() {
-            if (this._colliderRequiresAutoSizing) {
-                Insist.isTrue(this instanceof BoxCollider || this instanceof CircleCollider, "只有框和圆的碰撞器可以自动创建");
-
-                let renderable = this.entity.getComponent<RenderableComponent>(RenderableComponent);
-                if (renderable == null)
-                    console.warn("Collider没有形状，也没有RenderableComponent。不知道如何确定它的大小。");
-                if (renderable != null) {
-                    let renderableBounds = renderable.bounds.clone();
-
-                    // 我们在这里需要大小*反比例，因为当我们自动调整Collider的大小时，它需要没有一个缩放的Renderable
-                    let width = renderableBounds.width / this.entity.transform.scale.x;
-                    let height = renderableBounds.height / this.entity.transform.scale.y;
-
-                    if (this instanceof CircleCollider) {
-                        this.radius = Math.max(width, height) * 0.5;
-                        // 获取Renderable的中心，将其转移到本地坐标，并将其作为我们碰撞器的localOffset
-                        this.localOffset = Vector2.subtract(renderableBounds.center, this.entity.transform.position);
-                    } else if (this instanceof BoxCollider) {
-                        this.width = width;
-                        this.height = height;
-
-                        this.localOffset = Vector2.subtract(renderableBounds.center, this.entity.transform.position);
-                    }
-                }
-            }
-
             this._isParentEntityAddedToScene = true;
             this.registerColliderWithPhysicsSystem();
         }

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

@@ -23,13 +23,5 @@ module es {
             Polygon.recenterPolygonVerts(points);
             this.shape = new Polygon(points);
         }
-
-        public debugRender(batcher: IBatcher) {
-            let poly = this.shape as Polygon;
-            batcher.drawHollowRect(this.bounds, Debug.colliderBounds, 1);
-            batcher.drawPolygon(this.shape.position, poly.points, Debug.colliderEdge, true, 1);
-            batcher.drawPixel(this.entity.transform.position, Debug.colliderPosition, 4);
-            batcher.drawPixel(this.shape.position, Debug.colliderCenter, 2);
-        }
     }
 }

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

@@ -1,80 +0,0 @@
-module es {
-    /**
-     * 接口，当应用于一个Component时，它将被注册到场景渲染器中。
-     * 请仔细实现这个功能 改变像layerDepth/renderLayer/material这样的东西需要更新Scene RenderableComponentList
-     */
-    export interface IRenderable {
-        /** 包裹此对象的AABB。用来进行相机筛选 */
-        bounds: Rectangle;
-        /** 这个IRenderable是否应该被渲染 */
-        enabled: boolean;
-        /** 
-         * 标准的Batcher图层深度，0为前面，1为后面。
-         * 改变这个值会触发场景中可渲染组件列表的排序 
-         */
-        layerDepth: number;
-        /** 
-         * 较低的renderLayers在前面，较高的在後面，就像layerDepth一样，但不是限制在0-1。
-         * 请注意，这意味着较高的renderLayers首先被发送到Batcher。在使用模板缓冲区时，这是一个重要的事实 
-         */
-        renderLayer: number;
-        /**
-         * 由渲染器使用，用于指定该精灵应如何渲染。
-         * 如果非空，当组件从实体中移除时，它会被自动处理。
-         */
-        material;
-        /**
-         * 这个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);
-        /**
-         * 只有在没有对撞机的情况下才会渲染边界。
-         * 始终在原点上渲染一个正方形
-         * @param batcher 
-         */
-        debugRender(batcher: IBatcher);
-    }
-
-    /**
-     * 对IRenderables进行排序的比较器。
-     * 首先按 RenderLayer 排序，然后按 LayerDepth 排序。
-     * 如果出现平局，则使用材料作为平局的断定器，以避免渲染状态的改变
-     */
-    export class RenderableComparer implements IComparer<IRenderable> {
-        public compare(self: IRenderable, other: IRenderable): number {
-            let res = other.renderLayer - self.renderLayer;
-            if (res == 0) {
-                res = other.layerDepth - self.layerDepth;
-                if (res == 0) {
-                    if (self.material == other.material)
-                        return 0;
-
-                    if (other.material == null)
-                        return -1;
-
-                    return 1;
-                }
-            }
-
-            return res;
-        }
-    }
-}

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

@@ -1,230 +0,0 @@
-module es {
-    /**
-     * IRenderable的具体实现。包含方便的方法。
-     * 非常重要！子类必须覆盖width/height或bounds! 子类必须覆盖width/height或bounds!
-     */
-    export abstract class RenderableComponent extends Component implements IRenderable, IComparer<RenderableComponent> {
-        public static renderIdGenerator: number = 0;
-        /**
-         * 不重写bounds属性的子类必须实现这个！RenderableComponent的宽度。
-         */
-        public abstract get width();
-
-        /**
-         * 不重写bounds属性的子类必须实现这个!
-         */
-        public abstract get height();
-
-        /**
-         * 包裹此对象的AABB。用来进行相机筛选。
-         */
-        public abstract get bounds();
-
-        /**
-         * 标准的Batcher图层深度，0为前面，1为后面。
-         * 改变这个值会触发场景中可渲染组件列表的排序。
-         */
-        public get layerDepth() {
-            return this._layerDepth;
-        }
-        public set layerDepth(value: number) {
-            this.setLayerDepth(value);
-        }
-
-        /**
-         * 较低的renderLayers在前面，较高的在后面，就像layerDepth一樣，但不是限制在0-1。
-         * 请注意，这意味着更高的renderLayers首先被发送到Batcher。
-         */
-        public get renderLayer() {
-            return this._renderLayer;
-        }
-        public set renderLayer(value: number) {
-            this.setRenderLayer(value);
-        }
-
-        /**
-         * 渲染时传递给批处理程序的颜色
-         */
-        public color: number = 0xffffff;
-
-        /**
-         * 由渲染器使用，用于指定该精灵的渲染方式
-         */
-        public material: IMaterial;
-        /**
-         * 偏移。用于将多个Renderables添加到需要特定定位的实体
-         */
-        public get localOffset(): Vector2 {
-            return this._localOffset;
-        }
-        public set localOffset(value: Vector2) {
-            this.setLocalOffset(value);
-        }
-        /**
-         * 这个Renderable的可见性。
-         * 状态的改变最终会调用onBecameVisible/onBecameInvisible方法
-         */
-        public get isVisible() {
-            return this._isVisble;
-        }
-        public set isVisible(value: boolean) {
-            if (this._isVisble != value) {
-                this._isVisble = value;
-
-                if (this._isVisble)
-                    this.onBecameVisible();
-                else
-                    this.onBecameInvisible();
-            }
-        }
-
-        constructor() {
-            super();
-        }
-
-        public debugRenderEnabled: boolean = true;
-
-        protected _localOffset: Vector2 = Vector2.zero;
-        protected _layerDepth: number;
-        protected _renderLayer: number;
-        protected _bounds: Rectangle = Rectangle.empty;
-        protected _isVisble: boolean;
-
-        protected _areBoundsDirty: boolean = true;
-
-        public onEntityTransformChanged(comp: transform.Component) {
-            this._areBoundsDirty = true;
-        }
-
-        /**
-         * 被渲染器调用。摄像机可以用来进行裁剪，并使用Batcher实例进行绘制
-         * @param batcher 
-         * @param camera 
-         */
-        public abstract render(batcher: IBatcher, camera: ICamera);
-
-        /**
-         * 只有在没有对撞机的情况下才会渲染边界。始终在原点上渲染一个正方形
-         * @param batcher 
-         */
-        public debugRender(batcher: IBatcher) {
-            if (!this.debugRenderEnabled)
-                return;
-
-            // 如果我们没有对撞机，我们就画出我们的范围
-            if (this.entity.getComponent<Collider>(Collider) == null)
-                batcher.drawHollowRect(this.bounds, 0xFFFF00);
-
-            batcher.drawPixel(this.entity.transform.position.add(this._localOffset), 0xcc3299, 4);
-        }
-
-        /**
-         * 当Renderable进入相机帧时被调用。
-         * 请注意，如果您的Renderer没有使用isVisibleFromCamera来进行裁剪检查，这些方法将不会被调用。
-         * 所有默认的Renderer都会这样做
-         */
-        protected onBecameVisible() {
-
-        }
-
-        /**
-         * 当渲染器退出相机帧时，将调用这些方法。
-         * 请注意，如果你的Renderer没有使用isVisibleFromCamera来进行Culling检查，这些方法将不会被调用。
-         * 所有默认的Renderer都会这样做
-         */
-        protected onBecameInvisible() {
-
-        }
-
-        public onRemovedFromEntity() {
-
-        }
-
-        /**
-         * 如果Renderables的边界与Camera.bounds相交，则返回true。
-         * 处理isVisible标志的状态切换。在你的渲染方法中使用这个方法来决定你是否应该渲染
-         * @param camera 
-         */
-        public isVisibleFromCamera(camera: ICamera) {
-            this.isVisible = camera.bounds.intersects(this.bounds);
-            return this.isVisible;
-        }
-
-        public setMaterial(material: IMaterial) {
-            this.material = material;
-            if (this.entity != null && this.entity.scene != null)
-                this.entity.scene.renderableComponents.setRenderLayerNeedsComponentSort(this.renderLayer);
-            return this;
-        }
-
-        /**
-         * 标准的Batcher图层深度，0为前面，1为后面。
-         * 改变这个值会触发一种类似于renderableComponents的方法
-         * @param layerDepth 
-         */
-        public setLayerDepth(layerDepth: number): RenderableComponent {
-            this._layerDepth = MathHelper.clamp01(layerDepth);
-
-            if (this.entity != null && this.entity.scene != null)
-                this.entity.scene.renderableComponents.setRenderLayerNeedsComponentSort(this.renderLayer);
-            return this;
-        }
-
-        /**
-        * 较低的渲染层在前面，较高的在后面
-        * @param renderLayer
-        */
-        public setRenderLayer(renderLayer: number): RenderableComponent {
-            if (renderLayer != this._renderLayer) {
-                let oldRenderLayer = this._renderLayer;
-                this._renderLayer = renderLayer;
-
-                // 如果该组件拥有一个实体，那么是由ComponentList管理，需要通知它改变了渲染层
-                if (this.entity && this.entity.scene)
-                    this.entity.scene.renderableComponents.updateRenderableRenderLayer(this, oldRenderLayer, this._renderLayer);
-            }
-
-            return this;
-        }
-
-        /**
-         * 偏移。用于将多个Renderables添加到需要特定定位的实体
-         * @param offset 
-         */
-        public setLocalOffset(offset: Vector2): RenderableComponent {
-            if (!this._localOffset.equals(offset)) {
-                this._localOffset = offset;
-                this._areBoundsDirty = true;
-            }
-
-            return this;
-        }
-
-        /**
-         * 用于检索一个已经铸造的Material子类的帮助程序
-         */
-        public getMaterial<T extends IMaterial>(): T {
-            return this.material as T;
-        }
-
-        /**
-         * 先按renderLayer排序，再按layerDepth排序，最后按材质排序
-         * @param other 
-         */
-        public compare(other: RenderableComponent) {
-            let res = other.renderLayer - this.renderLayer;
-            if (res == 0) {
-                res = other.layerDepth - this.layerDepth;
-                if (res == 0) {
-                    if (this.material == other.material)
-                        return 0;
-
-                    if (other.material == null)
-                        return -1;
-
-                    return 1;
-                }
-            }
-        }
-    }
-}

source/src/ECS/CoreEvents.ts

@@ -1,29 +1,12 @@
 module es {
     export enum CoreEvents {
-        /**
-         * 在图形设备重置时触发。当这种情况发生时，任何渲染目标或其他内容的VRAM将被擦除，需要重新生成
-         */
-        graphicsDeviceReset,
         /**
          * 当场景发生变化时触发
          */
         sceneChanged,
         /**
-         * 当设备方向改变时触发
+         * 每帧更新事件
          */
-        orientationChanged,
-        /**
-         * 当Core.useCustomUpdate为true时则派发该事件
-         */
-        sceneUpdated,
-        addDefaultRender,
-        setRenderTarget,
-        clearGraphics,
-        disposeRenderTarget,
-        resolutionScale,
-        resolutionOffset,
-        createRenderTarget,
-        createCamera,
-        rendererSizeChanged,
+        frameUpdated,
     }
 }

source/src/ECS/Entity.ts

@@ -380,14 +380,6 @@ module es {
             this.components.update();
         }
 
-        /**
-         * 自定义渲染器可以选择是否调用它
-         * @param batcher 
-         */
-        public debugRender(batcher: IBatcher) {
-            this.components.debugRender(batcher);
-        }
-
         /**
          * 将组件添加到组件列表中。返回组件。
          * @param component

source/src/ECS/Scene.ts

@@ -13,105 +13,23 @@ module es {
 
     /** 场景 */
     export class Scene {
-        /**
-         * 默认场景 摄像机
-         */
-        public camera: ICamera;
         /**
          * 这个场景中的实体列表
          */
         public readonly entities: EntityList;
-        /** 管理当前在场景中的所有RenderableComponents的列表 Entitys */
-        public readonly renderableComponents: RenderableComponentList;
-        /**
-         * 如果ResolutionPolicy是完美的像素，这将被设置为为它计算的比例
-         */
-        public pixelPerfectScale: number = 1;
-        /**
-         * 如果设置了，最终渲染到屏幕上的时间可以推迟到这个委托。
-         * 这实际上只在最终渲染可能需要全屏大小效果的情况下有用，即使使用了一个小的后置缓冲区
-         */
-        public set finalRenderDelegate(value: IFinalRenderDelegate) {
-            if (this._finalRenderDelegate != null)
-                this._finalRenderDelegate.unload();
 
-            this._finalRenderDelegate = value;
-
-            if (this._finalRenderDelegate != null)
-                this._finalRenderDelegate.onAddedToScene(this);
-        }
-
-        public get finalRenderDelegate() {
-            return this._finalRenderDelegate;
-        }
-
-        private _finalRenderDelegate: IFinalRenderDelegate;
         /**
          * 管理所有实体处理器
          */
         public readonly entityProcessors: EntityProcessorList;
-        /**
-         * 所有场景的默认分辨率大小
-         */
-        private static _defaultDesignResolutionSize: Vector2 = Vector2.zero;
-        private static _defaultDesignBleedSize: Vector2 = Vector2.zero;
-        /**
-         * 用于所有场景的默认分辨率策略
-         */
-        private static _defaultSceneResolutionPolicy: SceneResolutionPolicy = SceneResolutionPolicy.none;
-        /**
-         * 场景的解析策略
-         */
-        private _resolutionPolicy: SceneResolutionPolicy;
-        /**
-         * 场景使用的设计分辨率大小
-         */
-        private _designResolutionSize: Vector2 = Vector2.zero;
-        private _designBleedSize: Vector2 = Vector2.zero;
-        /**
-         * 这将根据分辨率策略进行设置，并用于RenderTarget的最终输出
-         */
-        private _finalRenderDestinationRect: Rectangle = Rectangle.empty;
-
-        private _sceneRenderTarget: Ref<any> = new Ref(null);
-        private _destinationRenderTarget: Ref<any> = new Ref(null);
-        private _screenshotRequestCallback: (texture) => void;
 
         public readonly _sceneComponents: SceneComponent[] = [];
-        public _renderers: IRenderer[] = [];
-        public readonly _afterPostProcessorRenderers: IRenderer[] = [];
         private _didSceneBegin: boolean;
 
-        private currentRenderId: Ref<number> = new Ref(null);
-
-        /**
-         * 设置新场景将使用的默认设计尺寸和分辨率策略，水平/垂直Bleed仅与BestFit相关
-         * @param width 
-         * @param height 
-         * @param sceneResolutionPolicy 
-         * @param horizontalBleed 
-         * @param vertialcalBleed 
-         */
-        public static setDefaultDesignResolution(width: number, height: number,
-            sceneResolutionPolicy: SceneResolutionPolicy,
-            horizontalBleed: number = 0, vertialcalBleed: number = 0) {
-            this._defaultDesignBleedSize = new Vector2(width, height);
-            this._defaultSceneResolutionPolicy = sceneResolutionPolicy;
-            if (this._defaultSceneResolutionPolicy == SceneResolutionPolicy.bestFit)
-                this._defaultDesignBleedSize = new Vector2(horizontalBleed, vertialcalBleed);
-        }
-
         constructor() {
             this.entities = new EntityList(this);
-            this.renderableComponents = new RenderableComponentList();
             this.entityProcessors = new EntityProcessorList();
 
-            Framework.emitter.emit(CoreEvents.createCamera, this);
-
-            this._resolutionPolicy = Scene._defaultSceneResolutionPolicy;
-            this._designResolutionSize = Scene._defaultDesignResolutionSize;
-            this._designBleedSize = Scene._defaultDesignBleedSize;
-
             this.initialize();
         }
 
@@ -136,16 +54,7 @@ module es {
         }
 
         public begin() {
-            if (this._renderers.length == 0) {
-                Framework.emitter.emit(CoreEvents.addDefaultRender);
-                console.warn("场景开始时没有渲染器");
-            }
-
             Physics.reset();
-            this.updateResolutionScaler();
-            Framework.emitter.emit(CoreEvents.setRenderTarget, this._sceneRenderTarget);
-            Framework.emitter.addObserver(CoreEvents.graphicsDeviceReset, this.updateResolutionScaler, this);
-            Framework.emitter.addObserver(CoreEvents.orientationChanged, this.updateResolutionScaler, this);
 
             if (this.entityProcessors != null)
                 this.entityProcessors.begin();
@@ -158,10 +67,6 @@ module es {
         public end() {
             this._didSceneBegin = false;
 
-            for (let i = 0; i < this._renderers.length; i++)
-                this._renderers[i].unload();
-
-            Framework.emitter.removeObserver(CoreEvents.graphicsDeviceReset, this.updateResolutionScaler);
             this.entities.removeAllEntities();
 
             for (let i = 0; i < this._sceneComponents.length; i++) {
@@ -169,9 +74,6 @@ module es {
             }
             this._sceneComponents.length = 0;
 
-            this.camera = null;
-            Framework.emitter.emit(CoreEvents.disposeRenderTarget, this._sceneRenderTarget);
-            Framework.emitter.emit(CoreEvents.disposeRenderTarget, this._destinationRenderTarget);
             Physics.clear();
 
             if (this.entityProcessors)
@@ -180,107 +82,7 @@ module es {
             this.unload();
         }
 
-        public updateResolutionScaler() {
-            let designSize = this._designResolutionSize;
-            let screenSize = new Vector2(Screen.width, Screen.height);
-            let screenAspectRatio = screenSize.x / screenSize.y;
-
-            let renderTargetWidth = screenSize.x;
-            let renderTargetHeight = screenSize.y;
-
-            let resolutionScaleX = screenSize.x / designSize.x;
-            let resolutionScaleY = screenSize.y / designSize.y;
-
-            let rectCalculated = false;
-
-            // 计算PixelPerfect变体所使用的比例
-            this.pixelPerfectScale = 1;
-            if (this._resolutionPolicy != SceneResolutionPolicy.none) {
-                if (designSize.x / designSize.y > screenAspectRatio)
-                    this.pixelPerfectScale = screenSize.x / designSize.x;
-                else
-                    this.pixelPerfectScale = screenSize.y / designSize.y;
-
-                if (this.pixelPerfectScale == 0)
-                    this.pixelPerfectScale = 1;
-            }
-
-            switch (this._resolutionPolicy) {
-                case SceneResolutionPolicy.none:
-                    this._finalRenderDestinationRect.x = this._finalRenderDestinationRect.y = 0;
-                    this._finalRenderDestinationRect.width = screenSize.x;
-                    this._finalRenderDestinationRect.height = screenSize.y;
-                    rectCalculated = true;
-                    break;
-                case SceneResolutionPolicy.bestFit:
-                    let safeScaleX = screenSize.x / (designSize.x - this._designBleedSize.x);
-                    let safeScaleY = screenSize.y / (designSize.y - this._designBleedSize.y);
-
-                    let resolutionScale = Math.max(resolutionScaleX, resolutionScaleY);
-                    let safeScale = Math.min(safeScaleX, safeScaleY);
-
-                    resolutionScaleX = resolutionScaleY = Math.min(resolutionScale, safeScale);
-
-                    renderTargetWidth = designSize.x;
-                    renderTargetHeight = designSize.y;
-
-                    break;
-            }
-
-            // 如果我们还没有计算出一个矩形
-            if (!rectCalculated) {
-                // 计算RenderTarget的显示矩形
-                let renderWidth = designSize.x * resolutionScaleX;
-                let renderHeight = designSize.y * resolutionScaleY;
-
-                this._finalRenderDestinationRect = new Rectangle((screenSize.x - renderWidth) / 2,
-                    (screenSize.y - renderHeight) / 2, renderWidth, renderHeight);
-            }
-
-            // 在Input类中设置一些值，将鼠标位置转换为我们的缩放分辨率
-            let scaleX = renderTargetWidth / this._finalRenderDestinationRect.width;
-            let scaleY = renderTargetHeight / this._finalRenderDestinationRect.height;
-
-            Framework.emitter.emit(CoreEvents.resolutionScale, new Vector2(scaleX, scaleY));
-            Framework.emitter.emit(CoreEvents.resolutionOffset, this._finalRenderDestinationRect.location);
-
-            // 调整我们的RenderTargets大小
-            if (this._sceneRenderTarget != null)
-                Framework.emitter.emit(CoreEvents.disposeRenderTarget, this._sceneRenderTarget);
-            Framework.emitter.emit(CoreEvents.createRenderTarget, this._sceneRenderTarget, renderTargetWidth, renderTargetHeight);
-
-            // 只有在已经存在的情况下才会创建 destinationRenderTarget
-            if (this._destinationRenderTarget != null) {
-                Framework.emitter.emit(CoreEvents.disposeRenderTarget, this._destinationRenderTarget);
-                Framework.emitter.emit(CoreEvents.createRenderTarget, this._destinationRenderTarget, renderTargetWidth, renderTargetHeight);
-            }
-
-            // 通知渲染器、后处理器和FinalRenderDelegate渲染纹理尺寸的变化
-            for (let i = 0; i < this._renderers.length; i++)
-                this._renderers[i].onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
-
-            for (let i = 0; i < this._afterPostProcessorRenderers.length; i++)
-                this._afterPostProcessorRenderers[i].onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
-
-            if (this._finalRenderDelegate != null)
-                this._finalRenderDelegate.onSceneBackBufferSizeChanged(renderTargetWidth, renderTargetHeight);
-
-            this.camera.onSceneRenderTargetSizeChanged(renderTargetWidth, renderTargetHeight);
-        }
-
-        /**
-         * 下一次绘制完成后，这将克隆回缓冲区，并调用回调与clone。
-         * 注意，当使用完Texture后，你必须处理掉它
-         * @param callback 
-         */
-        public requestScreenshot(callback: (texture) => void) {
-            this._screenshotRequestCallback = callback;
-        }
-
         public update() {
-            // 我们在这里设置RenderTarget，这样Viewport就会与RenderTarget正确匹配
-            Framework.emitter.emit(CoreEvents.setRenderTarget, this._sceneRenderTarget);
-
             // 更新我们的列表，以防它们有任何变化
             this.entities.updateLists();
 
@@ -296,92 +98,10 @@ module es {
             // 更新我们的实体组
             this.entities.update();
 
-            // 我们在entity.update之后更新我们的renderables，以防止任何新的Renderables被添加
-            this.renderableComponents.updateList();
-
             if (this.entityProcessors != null)
                 this.entityProcessors.lateUpdate();
         }
 
-        public render() {
-            if (this._renderers.length == 0) {
-                console.error("场景中没有渲染器!");
-                return;
-            }
-
-            // 渲染器应该总是先有那些需要RenderTarget的。
-            // 他们在渲染的时候会自己清空并设置自己为当前的RenderTarget。
-            // 如果第一个Renderer想要sceneRenderTarget，我们现在就设置并清除它
-            if (this._renderers[0].wantsToRenderToSceneRenderTarget) {
-                Framework.emitter.emit(CoreEvents.setRenderTarget, this._sceneRenderTarget);
-                Framework.emitter.emit(CoreEvents.clearGraphics);
-            }
-
-            let lastRendererHadRenderTarget = false;
-            for (let i = 0; i < this._renderers.length; i++) {
-                if (lastRendererHadRenderTarget && this._renderers[i].wantsToRenderToSceneRenderTarget) {
-                    Framework.emitter.emit(CoreEvents.setRenderTarget, this._sceneRenderTarget);
-                    Framework.emitter.emit(CoreEvents.clearGraphics);
-
-                    // 强制更新相机矩阵，以考虑到新的视口尺寸
-                    if (this._renderers[i].camera != null)
-                        this._renderers[i].camera.forceMatrixUpdate();
-                    this.camera && this.camera.forceMatrixUpdate();
-                }
-
-                this._renderers[i].render(this);
-                lastRendererHadRenderTarget = this._renderers[i].renderTexture != null;
-            }
-        }
-
-        /**
-         * 任何存在的PostProcessors都可以进行处理，然后我们对RenderTarget进行最后的渲染。
-         * 几乎在所有情况下，finalRenderTarget都是空的。
-         * 只有在场景转换的第一帧中，如果转换请求渲染，它才会有一个值。
-         * @param finalRenderTarget 
-         */
-        public postRender(finalRenderTarget = null) {
-            let enabledCounter = 0;
-
-            for (let i = 0; i < this._afterPostProcessorRenderers.length; i++) {
-                if (i == 0) {
-                    // 我们需要在这里设置正确的RenderTarget
-                    let currentRenderTarget = MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
-                    Framework.emitter.emit(CoreEvents.setRenderTarget, currentRenderTarget);
-                }
-
-                if (this._afterPostProcessorRenderers[i].camera != null)
-                    this._afterPostProcessorRenderers[i].camera.forceMatrixUpdate();
-                this._afterPostProcessorRenderers[i].render(this);
-            }
-
-            // 如果我们有一个截图请求，在最终渲染到回缓冲区之前处理它
-            if (this._screenshotRequestCallback != null) {
-                let currentRenderTarget = MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
-                this._screenshotRequestCallback(currentRenderTarget.value);
-                this._screenshotRequestCallback = null;
-            }
-
-            // 将我们的最终结果渲染到后置缓冲区，或者让我们的委托来做
-            if (this._finalRenderDelegate != null) {
-                let currentRenderTarget = MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
-                this._finalRenderDelegate.handleFinalRender(finalRenderTarget, currentRenderTarget, this._finalRenderDestinationRect);
-            } else {
-                let currentRenderTarget = MathHelper.isEven(enabledCounter) ? this._sceneRenderTarget : this._destinationRenderTarget;
-                Framework.emitter.emit(CoreEvents.setRenderTarget, finalRenderTarget);
-                Framework.emitter.emit(CoreEvents.clearGraphics);
-
-                Framework.batcher.begin(this.currentRenderId, null);
-                Framework.batcher.draw(currentRenderTarget.value,
-                    new Vector2(this._finalRenderDestinationRect.x, this._finalRenderDestinationRect.y),
-                    0xffffff,
-                    0,
-                    Vector2.zero,
-                    new Vector2(this._finalRenderDestinationRect.width, this._finalRenderDestinationRect.height));
-                Framework.batcher.end();
-            }
-        }
-
         /**
          * 向组件列表添加并返回SceneComponent
          * @param component
@@ -434,67 +154,6 @@ module es {
             component.onRemovedFromScene();
         }
 
-        /**
-         * 添加一个渲染器到场景中
-         * @param renderer 
-         */
-        public addRenderer<T extends IRenderer>(renderer: T): T {
-            if (renderer.wantsToRenderAfterPostProcessors) {
-                this._afterPostProcessorRenderers.push(renderer);
-                this._afterPostProcessorRenderers.sort((a, b) => {
-                    return a.compare(b);
-                });
-            } else {
-                this._renderers.push(renderer);
-                this._renderers.sort((a, b) => {
-                    return a.compare(b);
-                });
-            }
-
-            renderer.onAddedToScene(this);
-
-            if (this._didSceneBegin)
-                Framework.emitter.emit(CoreEvents.rendererSizeChanged, this._sceneRenderTarget.value);
-
-            return renderer;
-        }
-
-        /**
-         * 得到第一个T型的渲染器
-         * @param type 
-         */
-        public getRenderer<T extends IRenderer>(type): T {
-            for (let i = 0; i < this._renderers.length; i++) {
-                if (this._renderers[i] instanceof type)
-                    return this._renderers[i] as T;
-            }
-
-            for (let i = 0; i < this._afterPostProcessorRenderers.length; i++) {
-                if (this._afterPostProcessorRenderers[i] instanceof type)
-                    return this._afterPostProcessorRenderers[i] as T;
-            }
-
-            return null;
-        }
-
-        /**
-         * 从场景中移除渲染器
-         * @param renderer 
-         */
-        public removeRenderer(renderer: IRenderer) {
-            let afterProcessLinqList = new linq.List(this._afterPostProcessorRenderers);
-            let rendererLinqList = new linq.List(this._renderers);
-            Insist.isTrue(rendererLinqList.contains(renderer) ||
-                afterProcessLinqList.contains(renderer));
-
-            if (renderer.wantsToRenderAfterPostProcessors)
-                afterProcessLinqList.remove(renderer);
-            else
-                rendererLinqList.remove(renderer);
-
-            renderer.unload();
-        }
-
         /**
          * 将实体添加到此场景，并返回它
          * @param name

source/src/ECS/Utils/ComponentList.ts

@@ -82,9 +82,6 @@ module es {
             for (let component of this._components) {
                 if (!component) continue;
 
-                if (component instanceof RenderableComponent)
-                    new linq.List(this._entity.scene.renderableComponents.buffer).remove(component);
-
                 // 处理IUpdatable
                 if (isIUpdatable(component))
                     new linq.List(this._updatableComponents).remove(component);
@@ -96,9 +93,6 @@ module es {
 
         public registerAllComponents() {
             for (let component of this._components) {
-                if (component instanceof RenderableComponent)
-                    this._entity.scene.renderableComponents.buffer.push(component);
-
                 if (isIUpdatable(component))
                     this._updatableComponents.push(component);
 
@@ -124,9 +118,6 @@ module es {
                 for (let i = 0, count = this._componentsToAdd.length; i < count; i++) {
                     let component = this._componentsToAdd[i];
 
-                    if (component instanceof RenderableComponent)
-                        this._entity.scene.renderableComponents.buffer.push(component);
-
                     if (isIUpdatable(component))
                         this._updatableComponents.push(component);
 
@@ -162,9 +153,6 @@ module es {
         }
 
         public handleRemove(component: Component) {
-            if (component instanceof RenderableComponent)
-                new linq.List(this._entity.scene.renderableComponents.buffer).remove(component);
-
             if (isIUpdatable(component))
                 new linq.List(this._updatableComponents).remove(component);
 
@@ -254,12 +242,5 @@ module es {
             for (let i = 0; i < this._components.length; i++)
                 this._components[i].onDisabled();
         }
-
-        public debugRender(batcher: IBatcher) {
-            for (let i = 0; i < this._components.length; i++) {
-                if (this._components[i].enabled)
-                    this._components[i].debugRender(batcher);
-            }
-        }
     }
 }

source/src/ECS/Utils/RenderableComponentList.ts

@@ -1,94 +0,0 @@
-module es {
-    export class RenderableComponentList {
-        // IRenderable列表的全局updateOrder排序
-        public static compareUpdatableOrder: IComparer<IRenderable> = new RenderableComparer();
-
-        /**
-         * 添加到实体的组件列表
-         */
-        private _components: IRenderable[] = [];
-        /**
-         * 通过renderLayer跟踪组件，便于检索
-         */
-        private _componentsByRenderLayer: Map<number, IRenderable[]> = new Map();
-
-        private _unsortedRenderLayers: number[] = [];
-        private _componentsNeedSort: boolean = true;
-
-        public get count() {
-            return this._components.length;
-        }
-
-        public get buffer(){
-            return this._components;
-        }
-
-        public get(index: number): IRenderable {
-            return this._components[index];
-        }
-
-        public add(component: IRenderable) {
-            this._components.push(component);
-            this.addToRenderLayerList(component, component.renderLayer);
-        }
-
-        public remove(component: IRenderable) {
-            new linq.List(this._components).remove(component);
-            new linq.List(this._componentsByRenderLayer.get(component.renderLayer)).remove(component);
-        }
-
-        public updateRenderableRenderLayer(component: IRenderable, oldRenderLayer: number, newRenderLayer: number) {
-            // 需要注意的是，在组件 "上线 "之前，renderLayer可能会发生变化
-            if (this._componentsByRenderLayer.has(oldRenderLayer) &&
-                new linq.List(this._componentsByRenderLayer.get(oldRenderLayer)).contains(component)) {
-                new linq.List(this._componentsByRenderLayer.get(oldRenderLayer)).remove(component);
-                this.addToRenderLayerList(component, newRenderLayer);
-            }
-        }
-
-        /**
-         * 弄脏RenderLayers排序标志，导致所有组件的重新排序
-         * @param renderLayer 
-         */
-        public setRenderLayerNeedsComponentSort(renderLayer: number) {
-            if (!new linq.List(this._unsortedRenderLayers).contains(renderLayer))
-                this._unsortedRenderLayers.push(renderLayer);
-            this._componentsNeedSort = true;
-        }
-
-        private addToRenderLayerList(component: IRenderable, renderLayer: number) {
-            let list = this.componentsWithRenderLayer(renderLayer);
-            Insist.isFalse(new linq.List(list).contains(component), "组件renderLayer列表已经包含这个组件");
-        }
-
-        /**
-         * 获取所有给定renderLayer的组件。组件列表是预先排序的。
-         * @param renderLayer 
-         */
-        public componentsWithRenderLayer(renderLayer: number) {
-            if (!this._componentsByRenderLayer.has(renderLayer)) {
-                this._componentsByRenderLayer.set(renderLayer, []);
-            }
-
-            return this._componentsByRenderLayer.get(renderLayer);
-        }
-
-        public updateList() {
-            if (this._componentsNeedSort) {
-                this._components.sort(RenderableComponentList.compareUpdatableOrder.compare);
-                this._componentsNeedSort = false;
-            }
-
-            if (this._unsortedRenderLayers.length > 0) {
-                for (let i = 0, count = this._unsortedRenderLayers.length; i < count; i++) {
-                    let renderLayerComponents = this._componentsByRenderLayer.get(this._unsortedRenderLayers[i]);
-                    if (renderLayerComponents) {
-                        renderLayerComponents.sort(RenderableComponentList.compareUpdatableOrder.compare);
-                    }
-                }
-
-                this._unsortedRenderLayers.length = 0;
-            }
-        }
-    }
-}