demo 更新

source/src/Graphics/Renderers/IRenderable.ts

@@ -34,6 +34,11 @@ module es {
          * @param camera
          */
         render(camera: Camera);
+
+        /**
+         * 只有在没有碰撞器时才呈现边界。总是在原点上渲染一个正方形。
+         */
+        debugRender();
     }
 
     /**

source/src/Graphics/Renderers/RenderLayerExcludeRenderer.ts

@@ -0,0 +1,40 @@
+module es {
+    /**
+     * 除了一个渲染层，只渲染所有的渲染器。
+     * 当与RenderLayerRenderer一起使用时，将UI渲染与游戏的其他部分分离开来。
+     */
+    export class RenderLayerExcludeRenderer extends Renderer {
+        public excludedRenderLayers: number[];
+
+        constructor(renderOrder: number, ...excludedRenderLayers: number[]){
+            super(renderOrder, null);
+            this.excludedRenderLayers = excludedRenderLayers;
+        }
+
+        public render(scene: es.Scene) {
+            let cam = this.camera ? this.camera : scene.camera;
+            this.beginRender(cam);
+
+            for (let i = 0; i < scene.renderableComponents.count; i ++) {
+                let renderable = scene.renderableComponents.buffer[i];
+                if (!this.excludedRenderLayers.contains(renderable.renderLayer) && renderable.enabled &&
+                    renderable.isVisibleFromCamera(cam))
+                    this.renderAfterStateCheck(renderable, cam);
+            }
+
+            if (this.shouldDebugRender && Core.debugRenderEndabled)
+                this.debugRender(scene, cam);
+        }
+
+        protected debugRender(scene: es.Scene, cam: es.Camera) {
+            for (let i = 0; i < scene.renderableComponents.count; i ++){
+                let renderable = scene.renderableComponents.buffer[i];
+                if (!this.excludedRenderLayers.contains(renderable.renderLayer) && renderable.enabled &&
+                    renderable.isVisibleFromCamera(cam))
+                    renderable.debugRender();
+            }
+
+            super.debugRender(scene, cam);
+        }
+    }
+}

source/src/Graphics/Renderers/Renderer.ts

@@ -13,6 +13,23 @@ module es {
          * 指定场景调用渲染器的顺序
          */
         public readonly renderOrder: number = 0;
+        /**
+         * 如果renderTarget不是null，这个渲染器将渲染到渲染目标而不是屏幕
+         */
+        public renderTexture: egret.RenderTexture;
+        /**
+         * 这个渲染器的标志，决定它是否应该调试渲染。
+         * render方法接收一个bool (debugRenderEnabled)，让渲染器知道全局调试渲染是否打开/关闭。
+         * 渲染器然后使用本地bool来决定它是否应该调试渲染。
+         */
+        public shouldDebugRender: boolean = true;
+        /**
+         * 如果为true，场景将使用场景渲染目标调用setRenderTarget。
+         * 如果渲染器有渲染纹理，默认实现返回true
+         */
+        public get wantsToRenderToSceneRenderTarget(): boolean{
+            return !!this.renderTexture;
+        }
 
         protected constructor(renderOrder: number, camera: Camera = null) {
             this.camera = camera;
@@ -62,5 +79,18 @@ module es {
         protected renderAfterStateCheck(renderable: IRenderable, cam: Camera) {
             renderable.render(cam);
         }
+
+        /**
+         * 默认debugRender方法只循环遍历所有实体并调用entity.debugRender
+         * @param scene
+         * @param cam
+         */
+        protected debugRender(scene: Scene, cam: Camera){
+            for (let i = 0; i < scene.entities.count; i ++){
+                let entity = scene.entities.buffer[i];
+                if (entity.enabled)
+                    entity.debugRender();
+            }
+        }
     }
 }

source/src/Graphics/Renderers/ScreenSpaceRenderer.ts

@@ -3,7 +3,47 @@ module es {
      * 渲染器使用自己的不移动的摄像机进行渲染。
      */
     export class ScreenSpaceRenderer extends Renderer {
+        public renderLayers: number[];
+
+        constructor(renderOrder: number, ...renderLayers: number[]){
+            super(renderOrder, null);
+            renderLayers.sort();
+            renderLayers.reverse();
+            this.renderLayers = renderLayers;
+        }
+
         public render(scene: Scene) {
+            this.beginRender(this.camera);
+
+            for (let i = 0; i < this.renderLayers.length; i ++){
+                let renderables = scene.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]);
+                for (let j = 0; j < renderables.length; j ++){
+                    let renderable = renderables[j];
+                    if (renderable.enabled && renderable.isVisibleFromCamera(this.camera))
+                        this.renderAfterStateCheck(renderable, this.camera);
+                }
+            }
+
+            if (this.shouldDebugRender && Core.debugRenderEndabled)
+                this.debugRender(scene, this.camera);
+        }
+
+        protected debugRender(scene: es.Scene, cam: es.Camera) {
+            for (let i = 0; i < this.renderLayers.length; i ++){
+                let renderables = scene.renderableComponents.componentsWithRenderLayer(this.renderLayers[i]);
+                for (let j = 0; j < renderables.length; j ++){
+                    let entity = renderables[j];
+                    if (entity.enabled)
+                        entity.debugRender();
+                }
+            }
+        }
+
+        public onSceneBackBufferSizeChanged(newWidth: number, newHeight: number) {
+            super.onSceneBackBufferSizeChanged(newWidth, newHeight);
+
+            if (!this.camera)
+                this.camera = Core.scene.createEntity("screenspace camera").addComponent(new Camera());
         }
     }
 }