新增renderer渲染器 用于控制场景如何渲染

source/src/ECS/Components/RenderableComponent.ts

@@ -1,7 +1,7 @@
 /** 
  * 所有可渲染组件的基类 
  */
-abstract class RenderableComponent extends Component {
+abstract class RenderableComponent extends Component implements IRenderable {
     private _isVisible: boolean;
     protected _areBoundsDirty = true;
     protected _bounds: Rectangle;
@@ -60,4 +60,8 @@ abstract class RenderableComponent extends Component {
         this.isVisible = camera.bounds.intersects(this.bounds);
         return this.isVisible;
     }
+
+    public onEntityTransformChanged(comp: ComponentTransform){
+        this._areBoundsDirty = true;
+    }
 }

source/src/ECS/Components/SpriteEffects.ts

@@ -0,0 +1,5 @@
+enum SpriteEffects {
+    none = 0,
+    flipHorizontally = 1,
+    flipVertically = 2
+}

source/src/ECS/Components/SpriteRenderer.ts

@@ -31,6 +31,20 @@ class SpriteRenderer extends RenderableComponent {
         return this;
     }
 
+    public get origin(){
+        return this._origin;
+    }
+    public set origin(value: Vector2){
+        this.setOrigin(value);
+    }
+    public setOrigin(origin: Vector2){
+        if (this._origin != origin){
+            this._origin = origin;
+            this._areBoundsDirty = true;
+        }
+        return this;
+    }
+
     public render(camera: Camera) {
         if (!this.sprite)
             return;

source/src/ECS/Scene.ts

@@ -1,49 +1,52 @@
 /** 场景 */
 class Scene extends egret.DisplayObjectContainer {
-   public camera: Camera; 
+   public camera: Camera;
    public readonly entities: EntityList;
+   public readonly renderableComponents: RenderableComponentList;
 
    private _projectionMatrix: Matrix2D;
    private _transformMatrix: Matrix2D;
    private _matrixTransformMatrix: Matrix2D;
+   private _renderers: Renderer[] = [];
 
    public readonly entityProcessors: EntityProcessorList;
 
-   constructor(displayObject: egret.DisplayObject){
+   constructor(displayObject: egret.DisplayObject) {
       super();
       displayObject.stage.addChild(this);
       this._projectionMatrix = new Matrix2D(0, 0, 0, 0, 0, 0);
       this.entityProcessors = new EntityProcessorList();
+      this.renderableComponents = new RenderableComponentList();
       this.entities = new EntityList(this);
-      
+
       this.addEventListener(egret.Event.ACTIVATE, this.onActive, this);
       this.addEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
       this.addEventListener(egret.Event.ENTER_FRAME, this.update, this);
    }
 
-   public createEntity(name: string){
+   public createEntity(name: string) {
       let entity = new Entity(name);
       entity.transform.position = new Vector2(0, 0);
       return this.addEntity(entity);
    }
 
-   public addEntity(entity: Entity){
+   public addEntity(entity: Entity) {
       this.entities.add(entity);
       entity.scene = this;
 
-      for (let i = 0; i < entity.transform.childCount; i ++)
+      for (let i = 0; i < entity.transform.childCount; i++)
          this.addEntity(entity.transform.getChild(i).entity);
 
       return entity;
    }
 
-   public destroyAllEntities(){
-      for (let i = 0; i < this.entities.count; i ++){
+   public destroyAllEntities() {
+      for (let i = 0; i < this.entities.count; i++) {
          this.entities.buffer[i].destory();
       }
    }
 
-   public findEntity(name: string): Entity{
+   public findEntity(name: string): Entity {
       return this.entities.findEntity(name);
    }
 
@@ -51,13 +54,13 @@ class Scene extends egret.DisplayObjectContainer {
     * 在场景中添加一个EntitySystem处理器
     * @param processor 处理器
     */
-   public addEntityProcessor(processor: EntitySystem){
+   public addEntityProcessor(processor: EntitySystem) {
       processor.scene = this;
       this.entityProcessors.add(processor);
       return processor;
    }
 
-   public removeEntityProcessor(processor: EntitySystem){
+   public removeEntityProcessor(processor: EntitySystem) {
       this.entityProcessors.remove(processor);
    }
 
@@ -65,14 +68,40 @@ class Scene extends egret.DisplayObjectContainer {
       return this.entityProcessors.getProcessor<T>();
    }
 
-   public setActive(): Scene{
+   public setActive(): Scene {
       SceneManager.setActiveScene(this);
 
       return this;
    }
 
+   public addRenderer<T extends Renderer>(renderer: T) {
+      this._renderers.push(renderer);
+      this._renderers.sort();
+
+      renderer.onAddedToScene(this);
+
+      return renderer;
+   }
+
+   public getRenderer<T extends Renderer>(type): T{
+      for (let i = 0; i < this._renderers.length; i ++){
+         if (this._renderers[i] instanceof type)
+            return this._renderers[i] as T;
+      }
+
+      return null;
+   }
+
+   public removeRenderer(renderer: Renderer){
+      this._renderers.remove(renderer);
+   }
+
    /** 初始化场景 */
-   public initialize(){
+   public initialize() {
+      if (this._renderers.length == 0) {
+         this.addRenderer(new DefaultRenderer());
+         console.warn("场景开始时没有渲染器 自动添加DefaultRenderer以保证能够正常渲染");
+      }
       /** 初始化默认相机 */
       this.camera = this.createEntity("camera").getOrCreateComponent(new Camera());
 
@@ -83,19 +112,19 @@ class Scene extends egret.DisplayObjectContainer {
    }
 
    /** 场景激活 */
-   public onActive(){
-      
+   public onActive() {
+
    }
 
    /** 场景失去焦点 */
-   public onDeactive(){
+   public onDeactive() {
 
    }
 
-   public update(){
+   public update() {
       Time.update(egret.getTimer());
 
-      for (let i = GlobalManager.globalManagers.length - 1; i >= 0; i --){
+      for (let i = GlobalManager.globalManagers.length - 1; i >= 0; i--) {
          if (GlobalManager.globalManagers[i].enabled)
             GlobalManager.globalManagers[i].update();
       }
@@ -109,9 +138,11 @@ class Scene extends egret.DisplayObjectContainer {
 
       if (this.entityProcessors)
          this.entityProcessors.lateUpdate();
+
+      this.renderableComponents.updateList();
    }
 
-   public prepRenderState(){
+   public prepRenderState() {
       this._projectionMatrix.m11 = 2 / this.stage.width;
       this._projectionMatrix.m22 = -2 / this.stage.height;
 
@@ -119,7 +150,7 @@ class Scene extends egret.DisplayObjectContainer {
       this._matrixTransformMatrix = Matrix2D.multiply(this._transformMatrix, this._projectionMatrix);
    }
 
-   public destory(){
+   public destory() {
       this.removeEventListener(egret.Event.DEACTIVATE, this.onDeactive, this);
       this.removeEventListener(egret.Event.ACTIVATE, this.onActive, this);
 

source/src/ECS/Utils/RenderableComponentList.ts

@@ -0,0 +1,22 @@
+class RenderableComponentList {
+    private _components: IRenderable[] = [];
+    public get count(){
+        return this._components.length;
+    }
+
+    public get buffer(){
+        return this._components;
+    }
+
+    public add(component: IRenderable){
+        this._components.push(component);
+    }
+
+    public remove(component: IRenderable){
+        this._components.remove(component);
+    }
+
+    public updateList(){
+
+    }
+}

source/src/Graphics/Renderers/DefaultRenderer.ts

@@ -0,0 +1,12 @@
+///<reference path="./Renderer.ts" />
+class DefaultRenderer extends Renderer {
+    public render(scene: Scene) {
+        let cam = this.camera ? this.camera : scene.camera;
+
+        for (let i = 0; i < scene.renderableComponents.count; i++){
+            let renderable = scene.renderableComponents.buffer[i];
+            if (renderable.enabled && renderable.isVisibleFromCamera(cam))
+                this.renderAfterStateCheck(renderable, cam);
+        }
+    }
+}

source/src/Graphics/Renderers/IRenderable.ts

@@ -0,0 +1,7 @@
+interface IRenderable {
+    bounds: Rectangle;
+    enabled: boolean;
+    isVisible: boolean;
+    isVisibleFromCamera(camera: Camera);
+    render(camera: Camera);
+}

source/src/Graphics/Renderers/Renderer.ts

@@ -0,0 +1,32 @@
+/**
+ * 渲染器被添加到场景中并处理所有对RenderableComponent的实际调用
+ */
+abstract class Renderer {
+    /** 
+     * 渲染器用于渲染的摄像机(实际上是用于剔除的变换矩阵和边界)
+     * 不是必须的
+     * Renderer子类可以选择调用beginRender时使用的摄像头
+     */
+    public camera: Camera;
+
+    /**
+     * 当渲染器被添加到场景时调用
+     * @param scene 
+     */
+    public onAddedToScene(scene: Scene){}
+
+    /**
+     * 
+     * @param scene 
+     */
+    public abstract render(scene: Scene);
+    
+    /**
+     * 
+     * @param renderable 
+     * @param cam 
+     */
+    protected renderAfterStateCheck(renderable: IRenderable, cam: Camera){
+        renderable.render(cam);
+    }
+}

source/src/Graphics/Renderers/ScreenSpaceRenderer.ts

@@ -0,0 +1,7 @@
+/**
+ * 渲染器使用自己的不移动的摄像机进行渲染。
+ */
+class ScreenSpaceRenderer extends Renderer {
+    public render(scene: Scene) {
+    }
+}