新增渲染接口

source/src/Graphics/Batcher/Color.ts

@@ -0,0 +1,15 @@
+module es {
+    export class Color {
+        public a: number = 255;
+        public r: number = 255;
+        public g: number = 255;
+        public b: number = 255;
+        
+        constructor(r: number, g: number, b: number, a: number = 255) {
+            this.a = a;
+            this.r = r;
+            this.g = g;
+            this.b = b;
+        }
+    }
+}

source/src/Graphics/Batcher/IBatcher.ts

@@ -0,0 +1,15 @@
+module es {
+    export interface IBatcher {
+        begin(cam: ICamera);
+        end();
+        drawPoints(points: Vector2[], color: Color, thickness?: number);
+        drawPolygon(poisition: Vector2, points: Vector2[], color: Color, closePoly: boolean, thickness?: number);
+        drawHollowRect(x: number, y: number, width: number, height: number, color: Color, thickness?: number);
+        drawCircle(position: Vector2, raidus: number, color: Color, thickness?: number);
+        drawCircleLow(position: es.Vector2, radius: number, color: Color, thickness?: number, resolution?: number);
+        drawRect(x: number, y: number, width: number, height: number, color: Color);
+        drawLine(start: Vector2, end: Vector2, color: Color, thickness: number);
+        drawPixel(position: Vector2, color: Color, size?: number);
+    }
+}
+

source/src/Graphics/Batcher/ICamera.ts

@@ -0,0 +1,5 @@
+module es {
+    export interface ICamera extends Component {
+        bounds: Rectangle;
+    }
+}

source/src/Graphics/Graphics.ts

@@ -0,0 +1,10 @@
+module es {
+    export class Graphics {
+        public static instance: Graphics;
+        public batcher: IBatcher;
+
+        constructor(batcher: IBatcher) {
+            this.batcher = batcher;
+        }
+    }
+}

source/src/Graphics/Renderers/DefaultRenderer.ts

@@ -0,0 +1,24 @@
+///<reference path="Renderer.ts" />
+module es {
+    export class DefaultRenderer extends Renderer {
+        constructor(renderOrder: number = 0, camera: ICamera = null) {
+            super(renderOrder, camera);
+        }
+    
+        public render(scene: Scene): void {
+            let cam = this.camera ? this.camera : scene.camera;
+            this.beginRender(cam);
+    
+            for (let i = 0; i < scene.renderableComponents.count; i ++) {
+                let renderable = scene.renderableComponents.get(i);
+                if (renderable.enabled && renderable.isVisibleFromCamera(scene.camera))
+                    this.renderAfterStateCheck(renderable, cam);
+            }
+    
+            if (this.shouldDebugRender && es.Core.debugRenderEndabled)
+                this.debugRender(scene);
+    
+            this.endRender();
+        }
+    }
+}

source/src/Graphics/Renderers/Renderer.ts

@@ -0,0 +1,39 @@
+module es {
+    export abstract class Renderer {
+        public camera: ICamera;
+        public readonly renderOrder: number = 0;
+        public shouldDebugRender: boolean = true;
+    
+        constructor(renderOrder: number, camera: ICamera) {
+            this.renderOrder = renderOrder;
+            this.camera = camera;
+        }
+    
+        public onAddedToScene(scene: es.Scene) { }
+    
+        public unload() { }
+    
+        protected beginRender(cam: ICamera) {
+            Graphics.instance.batcher.begin(cam);
+        }
+    
+        protected endRender() {
+            Graphics.instance.batcher.end();
+        }
+    
+        public abstract render(scene: Scene): void;
+    
+        protected renderAfterStateCheck(renderable: IRenderable, cam: ICamera) {
+            renderable.render(Graphics.instance.batcher, cam);
+        }
+    
+        protected debugRender(scene: Scene) {
+            for (let i = 0; i < scene.entities.count; i ++) {
+                let entity = scene.entities.buffer[i];
+                if (entity.enabled) {
+                    entity.debugRender(Graphics.instance.batcher);
+                }
+            }
+        }
+    }
+}