Rework & separate renderers

flixel/FlxGame.hx

@@ -1,6 +1,6 @@
 package flixel;
 
-import flixel.graphics.tile.FlxDrawBaseItem;
+import flixel.system.render.FlxCameraView;
 import flixel.system.FlxSplash;
 import flixel.util.FlxArrayUtil;
 import flixel.util.FlxDestroyUtil;
@@ -803,10 +803,9 @@ class FlxGame extends Sprite
 
 		FlxG.signals.preDraw.dispatch();
 
-		if (FlxG.renderTile)
-			FlxDrawBaseItem.drawCalls = 0;
+		FlxCameraView.totalDrawCalls = 0;
 
-		FlxG.cameras.lock();
+		FlxG.cameras.clear();
 
 		if (FlxG.plugins.drawOnTop)
 		{
@@ -819,17 +818,15 @@ class FlxGame extends Sprite
 			_state.draw();
 		}
 
+		FlxG.cameras.render();
+
 		if (FlxG.renderTile)
 		{
-			FlxG.cameras.render();
-
 			#if FLX_DEBUG
-			debugger.stats.drawCalls(FlxDrawBaseItem.drawCalls);
+			debugger.stats.drawCalls(FlxCameraView.totalDrawCalls);
 			#end
 		}
 
-		FlxG.cameras.unlock();
-
 		FlxG.signals.postDraw.dispatch();
 
 		#if FLX_DEBUG

flixel/FlxObject.hx

@@ -1318,18 +1318,27 @@ class FlxObject extends FlxBasic
 
 		if (rect.width > 0 && rect.height > 0)
 		{
-			final gfx = beginDrawDebug(camera);
-			drawDebugBoundingBox(gfx, rect, allowCollisions, immovable);
-			endDrawDebug(camera);
+			camera.beginDrawDebug();
+			drawDebugBoundingBox(camera, rect, allowCollisions);
+			camera.endDrawDebug();
 		}
 	}
 
-	function drawDebugBoundingBox(gfx:Graphics, rect:FlxRect, allowCollisions:FlxDirectionFlags, partial:Bool)
+	@:deprecated("drawDebugBoundingBox(gfx, rect, allowCollisions, partial) is deprecated. Use drawDebugBoundingBox(camera, rect, allowCollisions) instead.")
+	overload extern inline function drawDebugBoundingBox(gfx:Graphics, rect:FlxRect, allowCollisions:FlxDirectionFlags, partial:Bool)
 	{
 		// Find the color to use
 		final color = getDebugBoundingBoxColor(allowCollisions);
 		drawDebugBoundingBoxColor(gfx, rect, color);
 	}
+
+	overload extern inline function drawDebugBoundingBox(camera:FlxCamera, rect:FlxRect, allowCollisions:FlxDirectionFlags)
+	{
+		// Find the color to use
+		var color = getDebugBoundingBoxColor(allowCollisions);
+		color.alphaFloat = 0.75;
+		drawDebugBoundingBoxColor(camera, rect, color);
+	}
 
 	function getDebugBoundingBoxColor(allowCollisions:FlxDirectionFlags)
 	{
@@ -1346,30 +1355,38 @@ class FlxObject extends FlxBasic
 
 	}
 
-	function drawDebugBoundingBoxColor(gfx:Graphics, rect:FlxRect, color:FlxColor)
+	@:deprecated("drawDebugBoundingBoxColor(gfx, rect, color) is deprecated, use drawDebugBoundingBoxColor(camera, rect, color) instead")
+	overload extern inline function drawDebugBoundingBoxColor(gfx:Graphics, rect:FlxRect, color:FlxColor)
 	{
 		// fill static graphics object with square shape
 		gfx.lineStyle(1, color, 0.75, false, null, null, MITER, 255);
 		gfx.drawRect(rect.x + 0.5, rect.y + 0.5, rect.width - 1.0, rect.height - 1.0);
 	}
 
+	overload extern inline function drawDebugBoundingBoxColor(camera:FlxCamera, rect:FlxRect, color:FlxColor)
+	{
+		camera.drawDebugRect(rect.x + 0.5, rect.y + 0.5, rect.width - 1.0, rect.height - 1.0, color);
+	}
+
+	@:deprecated("use object.beginDrawDebug(camera) is deprecated, camera.beginDrawDebug() instead")
 	inline function beginDrawDebug(camera:FlxCamera):Graphics
 	{
+		camera.beginDrawDebug();
+
 		if (FlxG.renderBlit)
 		{
-			FlxSpriteUtil.flashGfx.clear();
 			return FlxSpriteUtil.flashGfx;
 		}
 		else
 		{
-			return camera.debugLayer.graphics;
+			return camera.viewQuad.debugLayer.graphics;
 		}
 	}
 
+	@:deprecated("use object.endDrawDebug(camera) is deprecated, camera.endDrawDebug() instead")
 	inline function endDrawDebug(camera:FlxCamera)
 	{
-		if (FlxG.renderBlit)
-			camera.buffer.draw(FlxSpriteUtil.flashGfxSprite);
+		camera.endDrawDebug();
 	}
 	#end
 

flixel/graphics/tile/FlxDrawBaseItem.hx

@@ -2,6 +2,7 @@ package flixel.graphics.tile;
 
 import flixel.FlxCamera;
 import flixel.graphics.frames.FlxFrame;
+import flixel.system.render.FlxCameraView;
 import flixel.math.FlxMatrix;
 import openfl.display.BlendMode;
 import openfl.geom.ColorTransform;
@@ -14,7 +15,18 @@ class FlxDrawBaseItem<T>
 	/**
 	 * Tracks the total number of draw calls made each frame.
 	 */
-	public static var drawCalls:Int = 0;
+	@:deprecated("drawCalls is deprecated, use FlxCameraView.totalDrawCalls instead")
+	public static var drawCalls(get, set):Int;
+
+	static function set_drawCalls(value:Int):Int
+	{
+		return FlxCameraView.totalDrawCalls = value;
+	}
+
+	static function get_drawCalls():Int
+	{
+		return FlxCameraView.totalDrawCalls;
+	}
 
 	@:noCompletion
 	@:deprecated("blendToInt() is deprecated, remove all references to it")
@@ -63,7 +75,7 @@ class FlxDrawBaseItem<T>
 
 	public function render(camera:FlxCamera):Void
 	{
-		drawCalls++;
+		FlxCameraView.totalDrawCalls++;
 	}
 
 	public function addQuad(frame:FlxFrame, matrix:FlxMatrix, ?transform:ColorTransform):Void {}

flixel/graphics/tile/FlxDrawQuadsItem.hx

@@ -133,10 +133,10 @@ class FlxDrawQuadsItem extends FlxDrawBaseItem<FlxDrawQuadsItem>
 		setParameterValue(shader.hasTransform, true);
 		setParameterValue(shader.hasColorTransform, colored || hasColorOffsets);
 
-		camera.canvas.graphics.overrideBlendMode(blend);
-		camera.canvas.graphics.beginShaderFill(shader);
-		camera.canvas.graphics.drawQuads(rects, null, transforms);
-		camera.canvas.graphics.endFill();
+		camera.viewQuad.canvas.graphics.overrideBlendMode(blend);
+		camera.viewQuad.canvas.graphics.beginShaderFill(shader);
+		camera.viewQuad.canvas.graphics.drawQuads(rects, null, transforms);
+		camera.viewQuad.canvas.graphics.endFill();
 		super.render(camera);
 	}
 

flixel/graphics/tile/FlxDrawTrianglesItem.hx

@@ -75,20 +75,20 @@ class FlxDrawTrianglesItem extends FlxDrawBaseItem<FlxDrawTrianglesItem>
 		setParameterValue(shader.hasTransform, true);
 		setParameterValue(shader.hasColorTransform, colored || hasColorOffsets);
 
-		camera.canvas.graphics.overrideBlendMode(blend);
+		camera.viewQuad.canvas.graphics.overrideBlendMode(blend);
 
-		camera.canvas.graphics.beginShaderFill(shader);
+		camera.viewQuad.canvas.graphics.beginShaderFill(shader);
 		#else
-		camera.canvas.graphics.beginBitmapFill(graphics.bitmap, null, true, (camera.antialiasing || antialiasing));
+		camera.viewQuad.canvas.graphics.beginBitmapFill(graphics.bitmap, null, true, (camera.antialiasing || antialiasing));
 		#end
 
-		camera.canvas.graphics.drawTriangles(vertices, indices, uvtData, TriangleCulling.NONE);
-		camera.canvas.graphics.endFill();
+		camera.viewQuad.canvas.graphics.drawTriangles(vertices, indices, uvtData, TriangleCulling.NONE);
+		camera.viewQuad.canvas.graphics.endFill();
 
 		#if FLX_DEBUG
 		if (FlxG.debugger.drawDebug)
 		{
-			var gfx:Graphics = camera.debugLayer.graphics;
+			var gfx:Graphics = camera.viewQuad.debugLayer.graphics;
 			gfx.lineStyle(1, FlxColor.BLUE, 0.5);
 			gfx.drawTriangles(vertices, indices, uvtData);
 		}

flixel/path/FlxBasePath.hx

@@ -318,18 +318,8 @@ class FlxTypedBasePath<TTarget:FlxBasic> extends FlxBasic implements IFlxDestroy
 	 */
 	public function drawDebugOnCamera(camera:FlxCamera):Void
 	{
-		// Set up our global flash graphics object to draw out the path
-		var gfx:Graphics = null;
-		if (FlxG.renderBlit)
-		{
-			gfx = FlxSpriteUtil.flashGfx;
-			gfx.clear();
-		}
-		else
-		{
-			gfx = camera.debugLayer.graphics;
-		}
-
+		camera.beginDrawDebug();
+
 		final length = nodes.length;
 		// Then fill up the object with node and path graphics
 		for (i=>node in nodes)
@@ -355,24 +345,20 @@ class FlxTypedBasePath<TTarget:FlxBasic> extends FlxBasic implements IFlxDestroy
 			}
 
 			// draw a box for the node
-			drawNode(gfx, prevNodeScreen, nodeSize, nodeColor);
+			drawNode(camera, prevNodeScreen, nodeSize, nodeColor);
 
 			if (i + 1 < length || loopType == LOOP)
 			{
 				// draw a line to the next node, if LOOP, get connect the tail and head
 				final nextNode = nodes[(i + 1) % length];
 				final nextNodeScreen = copyWorldToScreenPos(nextNode, camera);
-				drawLine(gfx, prevNodeScreen, nextNodeScreen);
+				drawLine(camera, prevNodeScreen, nextNodeScreen);
 				nextNodeScreen.put();
 			}
 			prevNodeScreen.put();
 		}
 
-		if (FlxG.renderBlit)
-		{
-			// then stamp the path down onto the game buffer
-			camera.buffer.draw(FlxSpriteUtil.flashGfxSprite);
-		}
+		camera.endDrawDebug();
 	}
 
 	@:access(flixel.FlxCamera)
@@ -396,16 +382,14 @@ class FlxTypedBasePath<TTarget:FlxBasic> extends FlxBasic implements IFlxDestroy
 		return result;
 	}
 
-	inline function drawNode(gfx:Graphics, node:FlxPoint, size:Int, color:FlxColor)
+	inline function drawNode(camera:FlxCamera, node:FlxPoint, size:Int, color:FlxColor)
 	{
-		gfx.beginFill(color.rgb, color.alphaFloat);
-		gfx.lineStyle();
 		final offset = Math.floor(size * 0.5);
-		gfx.drawRect(node.x - offset, node.y - offset, size, size);
-		gfx.endFill();
+		camera.drawDebugFilledRect(node.x - offset, node.y - offset, size, size, color);
 	}
 
-	function drawLine(gfx:Graphics, node1:FlxPoint, node2:FlxPoint)
+	@:deprecated("drawLine(gfx, node1, node2) is deprecated. Use drawLine(camera, node1, node2) instead.")
+	overload extern inline function drawLine(gfx:Graphics, node1:FlxPoint, node2:FlxPoint)
 	{
 		// then draw a line to the next node
 		final color = debugDrawData.lineColor;
@@ -416,6 +400,16 @@ class FlxTypedBasePath<TTarget:FlxBasic> extends FlxBasic implements IFlxDestroy
 		gfx.moveTo(node1.x + lineOffset, node1.y + lineOffset);
 		gfx.lineTo(node2.x + lineOffset, node2.y + lineOffset);
 	}
+
+	overload extern inline function drawLine(camera:FlxCamera, node1:FlxPoint, node2:FlxPoint)
+	{
+		// then draw a line to the next node
+		final color = debugDrawData.lineColor;
+		final size = debugDrawData.lineSize;
+		final lineOffset = debugDrawData.lineSize / 2;
+
+		camera.drawDebugLine(node1.x + lineOffset, node1.y + lineOffset, node2.x + lineOffset, node2.y + lineOffset, color, size);
+	}
 	#end
 }
 

flixel/system/debug/interaction/Interaction.hx

@@ -16,6 +16,7 @@ import flixel.system.debug.interaction.tools.TrackObject;
 import flixel.system.debug.interaction.tools.Transform;
 import flixel.util.FlxDestroyUtil;
 import flixel.util.FlxSpriteUtil;
+import flixel.util.FlxColor;
 import openfl.display.BitmapData;
 import openfl.display.DisplayObject;
 import openfl.display.Graphics;
@@ -377,6 +378,7 @@ class Interaction extends Window
 			drawItemsSelection();
 	}
 
+	@:deprecated("getDebugGraphics() is deprecated. Use the debug draw functions from FlxCamera instead.")
 	public function getDebugGraphics():Graphics
 	{
 		if (FlxG.renderBlit)
@@ -394,25 +396,23 @@ class Interaction extends Window
 
 	function drawItemsSelection():Void
 	{
-		var gfx:Graphics = getDebugGraphics();
-		if (gfx == null)
-			return;
+		final camera = FlxG.camera;
+		camera.beginDrawDebug();
 
 		for (member in selectedItems)
 		{
 			if (member != null && member.scrollFactor != null && member.isOnScreen())
 			{
 				final margin = 0.5;
-				final scroll = FlxG.camera.scroll;
+				final scroll = camera.scroll;
 				// Render a white rectangle centered at the selected item
-				gfx.lineStyle(1.0, 0xFFFFFF, 0.75);
-				gfx.drawRect(member.x - scroll.x - margin, member.y - scroll.y - margin, member.width + margin*2, member.height + margin*2);
+
+				final color:FlxColor = FlxColor.fromRGBFloat(1, 1, 1, 0.75);
+				camera.drawDebugRect(member.x - scroll.x - margin, member.y - scroll.y - margin, member.width + margin*2, member.height + margin*2, color);
 			}
 		}
 
-		// Draw the debug info to the main camera buffer.
-		if (FlxG.renderBlit)
-			FlxG.camera.buffer.draw(FlxSpriteUtil.flashGfxSprite);
+		camera.endDrawDebug();
 	}
 
 	/**
@@ -791,18 +791,18 @@ class Interaction extends Window
 	public function toDebugX(worldX:Float, camera:FlxCamera)
 	{
 		if (FlxG.renderTile)
-			return camera.canvas.localToGlobal(new Point(worldX, 0)).x;
+			return camera.viewQuad.canvas.localToGlobal(new Point(worldX, 0)).x;
 		else
 			@:privateAccess
-			return camera._flashBitmap.localToGlobal(new Point(worldX, 0)).x;
+			return camera.viewBlit._flashBitmap.localToGlobal(new Point(worldX, 0)).x;
 	}
 
 	public function toDebugY(worldY:Float, camera:FlxCamera)
 	{
 		if (FlxG.renderTile)
-			return camera.canvas.localToGlobal(new Point(0, worldY)).y;
+			return camera.viewQuad.canvas.localToGlobal(new Point(0, worldY)).y;
 		else
 			@:privateAccess
-			return camera._flashBitmap.localToGlobal(new Point(0, worldY)).y;
+			return camera.viewBlit._flashBitmap.localToGlobal(new Point(0, worldY)).y;
 	}
 }