Initial commit using new rendering

EndGate/EndGate.Core.JS/Game.js

@@ -25,6 +25,8 @@ var EndGate;
 
             this.Scene = new EndGate.Rendering.Scene2d(function (context) {
                 _this.Draw(context);
+            }, function (context) {
+                _this.PreDraw(context);
             }, gameCanvas);
 
             this.Input = new EndGate.Input.InputManager(this.Scene.DrawArea);
@@ -85,6 +87,12 @@ var EndGate;
         Game.prototype.Draw = function (context) {
             // This is called by the scene
         };
+        Game.prototype.PreDraw = function (context) {
+            // This is called by the scene
+        };
+        Game.prototype.PostDraw = function (context) {
+            // This is called by the scene
+        };
 
         /**
         * Removes game canvas and disposes all tracked objects.

EndGate/EndGate.Core.JS/Game.ts

@@ -15,7 +15,7 @@ module EndGate {
     * Defines a virtual Game object that is meant to be derived from.  Games contain a multitude of management objects to control every aspect of the game.
     */
     export class Game implements _.ITyped, IUpdateable, IDisposable {
-        public _type: string = "Game";        
+        public _type: string = "Game";
 
         /**
         * The games configuration.  Used to modify settings such as the game update rate.
@@ -63,17 +63,20 @@ module EndGate {
 
             this.Scene = new Rendering.Scene2d(context => {
                 this.Draw(context);
+            },
+            context => {
+                this.PreDraw(context);
             }, gameCanvas);
 
             this.Input = new Input.InputManager(this.Scene.DrawArea);
             this.Content = new Content.ContentManager();
-            
+
             initialQuadTreeSize = this.Scene.Camera.Size;
 
             if (initialQuadTreeSize.Width % defaultMinQuadTreeSize.Width !== 0) {
                 initialQuadTreeSize = new Size2d(initialQuadTreeSize.Width % defaultMinQuadTreeSize.Width + initialQuadTreeSize.Width);
             }
-            
+
             this.Configuration = new GameConfiguration(GameRunnerInstance.Register(this), initialQuadTreeSize)
             this.CollisionManager = new Collision.CollisionManager(this.Configuration.CollisionConfiguration);
 
@@ -124,6 +127,12 @@ module EndGate {
         public Draw(context: CanvasRenderingContext2D): void {
             // This is called by the scene
         }
+        public PreDraw(context: CanvasRenderingContext2D): void {
+            // This is called by the scene
+        }
+        public PostDraw(context: CanvasRenderingContext2D): void {
+            // This is called by the scene
+        }
 
         /**
         * Removes game canvas and disposes all tracked objects.

EndGate/EndGate.Core.JS/Rendering/Camera/Camera2dRenderer.js

@@ -1,4 +1,4 @@
-/// <reference path="Camera2d.ts" />
+/// <reference path="Camera2d.ts" />
 /// <reference path="../Renderer2d.ts" />
 /// <reference path="../../Assets/Sizes/Size2d.ts" />
 /// <reference path="Camera2dCanvasContextBuilder.ts" />
@@ -21,10 +21,13 @@ var EndGate;
             * @param renderOnto The canvas to render onto.
             * @param camera The camera that ultimately decides what is drawn to the renderOnto canvas.
             */
-            function Camera2dRenderer(renderOnto, camera) {
+            function Camera2dRenderer(renderOnto, camera, preRender) {
+                if (typeof preRender === "undefined") { preRender = function (_) {
+                }; }
                 var _this = this;
                 _super.call(this, renderOnto);
 
+                this._preRender = preRender;
                 this._camera = camera;
                 this._contextBuilder = new EndGate.Rendering._.Camera2dCanvasContextBuilder(this._camera);
 
@@ -40,13 +43,13 @@ var EndGate;
             * Renders the provided renderables onto the renderOnto canvas.  Returns the canvas that was rendered onto.
             * @param renderables Array of items that are to be rendered.
             */
-            Camera2dRenderer.prototype.Render = function (renderables) {
+            Camera2dRenderer.prototype.Render = function (preRender, renderables) {
                 var context, inverseScale = this._camera._GetInverseDistanceScale();
 
                 this._BufferContext.save();
                 this._BufferContext.scale(inverseScale, inverseScale);
 
-                context = _super.prototype.Render.call(this, this.GetOnScreenRenderables(renderables));
+                context = _super.prototype.Render.call(this, this._preRender, this.GetOnScreenRenderables(renderables));
 
                 this._BufferContext.restore();
 

EndGate/EndGate.Core.JS/Rendering/Camera/Camera2dRenderer.ts

@@ -11,15 +11,17 @@ module EndGate.Rendering {
     export class Camera2dRenderer extends Renderer2d {
         private _camera: Camera2d;
         private _contextBuilder: _.Camera2dCanvasContextBuilder;
+        private _preRender: (context: CanvasRenderingContext2D) => void;
 
         /**
         * Creates a new instance of the Camera2dRenderer.
         * @param renderOnto The canvas to render onto.
         * @param camera The camera that ultimately decides what is drawn to the renderOnto canvas.
         */
-        constructor(renderOnto: HTMLCanvasElement, camera: Camera2d) {
+        constructor(renderOnto: HTMLCanvasElement, camera: Camera2d, preRender: (context: CanvasRenderingContext2D) => void = _ => { }) {
             super(renderOnto);
 
+            this._preRender = preRender;
             this._camera = camera;
             this._contextBuilder = new _.Camera2dCanvasContextBuilder(this._camera);
 
@@ -37,14 +39,14 @@ module EndGate.Rendering {
         * Renders the provided renderables onto the renderOnto canvas.  Returns the canvas that was rendered onto.
         * @param renderables Array of items that are to be rendered. 
         */
-        public Render(renderables: IRenderable[]): CanvasRenderingContext2D {
+        public Render(preRender: (context: CanvasRenderingContext2D) => void, renderables: IRenderable[]): CanvasRenderingContext2D {
             var context,
                 inverseScale = this._camera._GetInverseDistanceScale();
 
             this._BufferContext.save();
             this._BufferContext.scale(inverseScale, inverseScale)
 
-            context = super.Render(this.GetOnScreenRenderables(renderables));
+            context = super.Render(this._preRender, this.GetOnScreenRenderables(renderables));
 
             this._BufferContext.restore();
 

EndGate/EndGate.Core.JS/Rendering/IRenderer.js

@@ -1,2 +1,2 @@
-/// <reference path="../Interfaces/IDisposable.ts" />
+/// <reference path="../Interfaces/IDisposable.ts" />
 /// <reference path="IRenderable.ts" />

EndGate/EndGate.Core.JS/Rendering/IRenderer.ts

@@ -4,7 +4,7 @@
 declare module EndGate.Rendering._ {
 
     export interface IRenderer extends IDisposable {
-        Render(renderables: IRenderable[]): CanvasRenderingContext2D;
+        Render(preRender: (context: CanvasRenderingContext2D) => void, renderables: IRenderable[]): CanvasRenderingContext2D;
     }
 
 }

EndGate/EndGate.Core.JS/Rendering/Renderer2d.js

@@ -1,4 +1,4 @@
-/// <reference path="IRenderer.ts" />
+/// <reference path="IRenderer.ts" />
 /// <reference path="IRenderable.ts" />
 /// <reference path="../Interfaces/IDisposable.ts" />
 /// <reference path="../Utilities/EventHandler1.ts" />
@@ -41,7 +41,7 @@ var EndGate;
             * Renders the provided renderables onto the renderOnto canvas.  Returns the canvas that was rendered onto.
             * @param renderables Array of items that are to be rendered, assumes Visible is set to true.
             */
-            Renderer2d.prototype.Render = function (renderables) {
+            Renderer2d.prototype.Render = function (preRender, renderables) {
                 // Check if our visible canvas has changed size
                 if (this._BufferCanvas.width !== this._visibleCanvas.width || this._BufferCanvas.height !== this._visibleCanvas.height) {
                     this.UpdateBufferSize();
@@ -54,6 +54,8 @@ var EndGate;
                 // Clear our buffer to prepare it for new drawings
                 this._ClearBuffer();
 
+                preRender(this._BufferContext);
+
                 // Sort the renderables by the ZIndex so we draw in the correct order (for layering);
                 renderables.sort(Renderer2d._zindexSort);
 

EndGate/EndGate.Core.JS/Rendering/Renderer2d.ts

@@ -49,7 +49,7 @@ module EndGate.Rendering {
         * Renders the provided renderables onto the renderOnto canvas.  Returns the canvas that was rendered onto.
         * @param renderables Array of items that are to be rendered, assumes Visible is set to true.
         */
-        public Render(renderables: IRenderable[]): CanvasRenderingContext2D {
+        public Render(preRender: (context: CanvasRenderingContext2D) => void, renderables: IRenderable[]): CanvasRenderingContext2D {
             // Check if our visible canvas has changed size
             if (this._BufferCanvas.width !== this._visibleCanvas.width || this._BufferCanvas.height !== this._visibleCanvas.height) {
                 this.UpdateBufferSize();
@@ -61,6 +61,8 @@ module EndGate.Rendering {
             // Clear our buffer to prepare it for new drawings
             this._ClearBuffer();
 
+            preRender(this._BufferContext);
+
             // Sort the renderables by the ZIndex so we draw in the correct order (for layering);
             renderables.sort(Renderer2d._zindexSort);
 

EndGate/EndGate.Core.JS/Rendering/Scene2d.js

@@ -1,4 +1,4 @@
-/// <reference path="../Interfaces/IDisposable.ts" />
+/// <reference path="../Interfaces/IDisposable.ts" />
 /// <reference path="../Interfaces/ITyped.ts" />
 /// <reference path="../GameTime.ts" />
 /// <reference path="../Graphics/Graphic2d.ts" />
@@ -14,9 +14,11 @@ var EndGate;
         * Defines a scene object that is used to maintain a list of renderable objects that are rendered onto a joint game area.
         */
         var Scene2d = (function () {
-            function Scene2d(onDraw, drawArea) {
+            function Scene2d(onDraw, onPreDraw, drawArea) {
                 if (typeof onDraw === "undefined") { onDraw = function (_) {
                 }; }
+                if (typeof onPreDraw === "undefined") { onPreDraw = function (_) {
+                }; }
                 this._actorMappings = [];
                 this._actors = [];
 
@@ -25,10 +27,11 @@ var EndGate;
                 }
 
                 this._onDraw = onDraw;
+                this._preDraw = onPreDraw;
 
                 this._drawArea = drawArea;
                 this._camera = new EndGate.Rendering.Camera2d(new EndGate.Vector2d(this._drawArea.width / 2, this._drawArea.height / 2), new EndGate.Size2d(this._drawArea.width, this._drawArea.height));
-                this._renderer = new EndGate.Rendering.Camera2dRenderer(this._drawArea, this._camera);
+                this._renderer = new EndGate.Rendering.Camera2dRenderer(this._drawArea, this._camera, this._preDraw);
                 this._disposed = false;
             }
             Object.defineProperty(Scene2d.prototype, "DrawArea", {
@@ -91,7 +94,7 @@ var EndGate;
             * Draws all actors within the Scene and triggers the Scene2d's onDraw callback.
             */
             Scene2d.prototype.Draw = function () {
-                this._onDraw(this._renderer.Render(this._actors));
+                this._onDraw(this._renderer.Render(this._preDraw, this._actors));
             };
 
             /**

EndGate/EndGate.Core.JS/Rendering/Scene2d.ts

@@ -23,6 +23,7 @@ module EndGate.Rendering {
         private _actorMappings: IActorMapping[];
         private _renderer: _.IRenderer;
         private _onDraw: (context: CanvasRenderingContext2D) => void;
+        private _preDraw: (context: CanvasRenderingContext2D) => void;
         private _disposed: boolean;
         private _camera: Camera2d;
         private _drawArea: HTMLCanvasElement;
@@ -41,8 +42,8 @@ module EndGate.Rendering {
         * @param onDraw Callback to execute whenever the Scene's draw is triggered.
         * @param drawArea The game canvas to draw onto.
         */
-        constructor(onDraw: (context: CanvasRenderingContext2D) => void , drawArea: HTMLCanvasElement);
-        constructor(onDraw: (context: CanvasRenderingContext2D) => void = _ => { }, drawArea?: HTMLCanvasElement) {
+        constructor(onDraw: (context: CanvasRenderingContext2D) => void, onPreDraw: (context: CanvasRenderingContext2D) => void, drawArea: HTMLCanvasElement);
+        constructor(onDraw: (context: CanvasRenderingContext2D) => void = _ => { }, onPreDraw: (context: CanvasRenderingContext2D) => void = _ => { }, drawArea?: HTMLCanvasElement) {
             this._actorMappings = [];
             this._actors = [];
 
@@ -51,10 +52,11 @@ module EndGate.Rendering {
             }
 
             this._onDraw = onDraw;
+            this._preDraw = onPreDraw;
 
             this._drawArea = drawArea;
             this._camera = new Camera2d(new Vector2d(this._drawArea.width / 2, this._drawArea.height / 2), new Size2d(this._drawArea.width, this._drawArea.height));
-            this._renderer = new Camera2dRenderer(this._drawArea, this._camera);
+            this._renderer = new Camera2dRenderer(this._drawArea, this._camera, this._preDraw);
             this._disposed = false;
         }
 
@@ -109,7 +111,7 @@ module EndGate.Rendering {
         * Draws all actors within the Scene and triggers the Scene2d's onDraw callback.
         */
         public Draw(): void {
-            this._onDraw(this._renderer.Render(this._actors));
+            this._onDraw(this._renderer.Render(this._preDraw, this._actors));
         }
 
         /**