Rework & separate renderers

flixel/FlxG.hx

@@ -1,5 +1,6 @@
 package flixel;
 
+import flixel.system.render.FlxRenderer;
 import flixel.math.FlxMath;
 import flixel.math.FlxRandom;
 import flixel.math.FlxRect;
@@ -143,10 +144,33 @@ class FlxG
 	 */
 	public static var onMobile(get, never):Bool;
 
-	public static var renderMethod(default, null):FlxRenderMethod;
+	@:deprecated("renderMethod is deprecated, use FlxG.render.method, instead.")
+	public static var renderMethod(get, null):flixel.system.render.FlxRenderer.FlxRenderMethod;
+	@:noCompletion static inline function get_renderMethod():flixel.system.render.FlxRenderer.FlxRenderMethod
+	{
+		return FlxG.renderer.method;
+	}
+
+	@:deprecated("renderBlit is deprecated, compare against FlxG.render.method, instead.")
+	public static var renderBlit(get, never):Bool;
+	@:noCompletion static inline function get_renderBlit():Bool
+	{
+		return FlxG.renderer.method == BLITTING;
+	}
+
+	@:deprecated("renderTile is deprecated, compare against FlxG.render.method, instead.")
+	public static var renderTile(get, never):Bool;
+	@:noCompletion static inline function get_renderTile():Bool
+	{
+		return FlxG.renderer.method != BLITTING;
+	}
 
-	public static var renderBlit(default, null):Bool;
-	public static var renderTile(default, null):Bool;
+	/**
+	 * The global renderer instance.
+	 * 
+	 * @see `FlxRenderer`
+	 */
+	public static var renderer(default, null):FlxRenderer;
 
 	/**
 	 * Represents the amount of time in seconds that passed since last frame.
@@ -541,10 +565,6 @@ class FlxG
 		FlxG.height = height;
 
 		initRenderMethod();
-		#if FLX_OPENGL_AVAILABLE
-		// Query once when window is created and cache for later
-		bitmap.get_maxTextureSize();
-		#end
 
 		FlxG.initialWidth = width;
 		FlxG.initialHeight = height;
@@ -590,28 +610,8 @@ class FlxG
 
 	static function initRenderMethod():Void
 	{
-		#if !flash
-		renderMethod = switch (stage.window.context.type)
-		{
-			case OPENGL, OPENGLES, WEBGL: DRAW_TILES;
-			default: BLITTING;
-		}
-		#else
-		#if web
-		renderMethod = BLITTING;
-		#else
-		renderMethod = DRAW_TILES;
-		#end
-		#end
-
-		#if air
-		renderMethod = BLITTING;
-		#end
-
-		renderBlit = renderMethod == BLITTING;
-		renderTile = renderMethod == DRAW_TILES;
-
-		FlxObject.defaultPixelPerfectPosition = renderBlit;
+		renderer = FlxRenderer.create();
+		FlxObject.defaultPixelPerfectPosition =	FlxG.renderer.method == BLITTING;
 	}
 
 	#if FLX_SAVE
@@ -750,8 +750,5 @@ class FlxG
 	}
 }
 
-enum FlxRenderMethod
-{
-	DRAW_TILES;
-	BLITTING;
-}
+@:deprecated("FlxG.FlxRenderMethod is deprecated, use FlxRenderer.FlxRenderMethod instead")
+typedef FlxRenderMethod = flixel.system.render.FlxRenderer.FlxRenderMethod;

flixel/FlxGame.hx

@@ -1,6 +1,6 @@
 package flixel;
 
-import flixel.graphics.tile.FlxDrawBaseItem;
+import flixel.system.render.FlxRenderer;
 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;
+		FlxRenderer.totalDrawCalls = 0;
 
-		FlxG.cameras.lock();
+		FlxG.cameras.clear();
 
 		if (FlxG.plugins.drawOnTop)
 		{
@@ -819,17 +818,15 @@ class FlxGame extends Sprite
 			_state.draw();
 		}
 
-		if (FlxG.renderTile)
-		{
-			FlxG.cameras.render();
+		FlxG.cameras.render();
 
+		if (FlxG.renderer.method != BLITTING)
+		{
 			#if FLX_DEBUG
-			debugger.stats.drawCalls(FlxDrawBaseItem.drawCalls);
+			debugger.stats.drawCalls(FlxRenderer.totalDrawCalls);
 			#end
 		}
 
-		FlxG.cameras.unlock();
-
 		FlxG.signals.postDraw.dispatch();
 
 		#if FLX_DEBUG

flixel/FlxObject.hx

@@ -1308,7 +1308,7 @@ class FlxObject extends FlxBasic
 			return;
 
 		final rect = getBoundingBox(camera);
-		if (FlxG.renderTile)
+		if (FlxG.renderer.method != BLITTING)
 		{
 			final view = camera.getViewMarginRect();
 			view.pad(2);
@@ -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);
+			FlxG.renderer.beginDrawDebug(camera);
+			drawDebugBoundingBox(rect, allowCollisions);
+			FlxG.renderer.endDrawDebug();
 		}
 	}
 
-	function drawDebugBoundingBox(gfx:Graphics, rect:FlxRect, allowCollisions:FlxDirectionFlags, partial:Bool)
+	@:deprecated("drawDebugBoundingBox(gfx, rect, allowCollisions, partial) is deprecated. Use drawDebugBoundingBox(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(rect:FlxRect, allowCollisions:FlxDirectionFlags)
+	{
+		// Find the color to use
+		var color = getDebugBoundingBoxColor(allowCollisions);
+		color.alphaFloat = 0.75;
+		drawDebugBoundingBoxColor(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(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(rect:FlxRect, color:FlxColor)
+	{
+		FlxG.renderer.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, FlxG.renderer.beginDrawDebug(camera) instead")
 	inline function beginDrawDebug(camera:FlxCamera):Graphics
 	{
-		if (FlxG.renderBlit)
+		FlxG.renderer.beginDrawDebug(camera);
+
+		if (FlxG.renderer.method == BLITTING)
 		{
-			FlxSpriteUtil.flashGfx.clear();
 			return FlxSpriteUtil.flashGfx;
 		}
 		else
 		{
-			return camera.debugLayer.graphics;
+			return camera.viewQuad.debugLayer.graphics;
 		}
 	}
 
+	@:deprecated("use object.endDrawDebug(camera) is deprecated, FlxG.renderer.endDrawDebug() instead")
 	inline function endDrawDebug(camera:FlxCamera)
 	{
-		if (FlxG.renderBlit)
-			camera.buffer.draw(FlxSpriteUtil.flashGfxSprite);
+		FlxG.renderer.endDrawDebug();
 	}
 	#end