Changes to FlxTransition

Author: EliteMasterEric

flixel/addons/transition/FlxTransitionableState.hx

@@ -93,7 +93,7 @@ class FlxTransitionableState extends FlxState
 			// play the exit transition, and when it's done call FlxG.switchState
 			_exiting = true;
 			transitionOut(onOutroComplete);
-			
+
 			if (skipNextTransOut)
 			{
 				skipNextTransOut = false;
@@ -170,6 +170,7 @@ class FlxTransitionableState extends FlxState
 	{
 		return switch (data.type)
 		{
+			case CUSTOM: data.transitionState;
 			case TILES: new Transition(data);
 			case FADE: new Transition(data);
 			default: null;

flixel/addons/transition/FlxTransitionableSubState.hx

@@ -0,0 +1,192 @@
+package flixel.addons.transition;
+
+// TODO: remove this check when min flixel version is 5.6.0,
+// So that FlxAddonDefines will handle this
+#if (flixel < "5.3.0")
+#error "Flixel-Addons is not compatible with flixel versions older than 5.3.0";
+#end
+
+import flixel.FlxState;
+
+/**
+ * A `FlxState` which can perform visual transitions
+ *
+ * Usage:
+ *
+ * First, extend `FlxTransitionableState` as ie, `FooState`.
+ *
+ * Method 1:
+ *
+ * ```haxe
+ * var in:TransitionData = new TransitionData(...); // add your data where "..." is
+ * var out:TransitionData = new TransitionData(...);
+ *
+ * FlxG.switchState(new FooState(in,out));
+ * ```
+ *
+ * Method 2:
+ *
+ * ```haxe
+ * FlxTransitionableState.defaultTransIn = new TransitionData(...);
+ * FlxTransitionableState.defaultTransOut = new TransitionData(...);
+ *
+ * FlxG.switchState(new FooState());
+ * ```
+ */
+class FlxTransitionableSubState extends FlxSubState
+{
+	// beginning & ending transitions for THIS state:
+	public var transIn:TransitionData;
+	public var transOut:TransitionData;
+
+	public var hasTransIn(get, never):Bool;
+	public var hasTransOut(get, never):Bool;
+
+	/**
+	 * Create a state with the ability to do visual transitions
+	 * @param	TransIn		Plays when the state begins
+	 * @param	TransOut	Plays when the state ends
+	 */
+	public function new(?TransIn:TransitionData, ?TransOut:TransitionData)
+	{
+		transIn = TransIn;
+		transOut = TransOut;
+
+		if (transIn == null && FlxTransitionableState.defaultTransIn != null)
+		{
+			transIn = FlxTransitionableState.defaultTransIn;
+		}
+		if (transOut == null && FlxTransitionableState.defaultTransOut != null)
+		{
+			transOut = FlxTransitionableState.defaultTransOut;
+		}
+		super();
+	}
+
+	override function destroy():Void
+	{
+		super.destroy();
+		transIn = null;
+		transOut = null;
+		_onExit = null;
+	}
+
+	override function create():Void
+	{
+		super.create();
+		transitionIn();
+	}
+
+	override function startOutro(onOutroComplete:() -> Void)
+	{
+		if (!hasTransOut)
+			onOutroComplete();
+		else if (!_exiting)
+		{
+			// play the exit transition, and when it's done call FlxG.switchState
+			_exiting = true;
+			transitionOut(onOutroComplete);
+
+			if (FlxTransitionableState.skipNextTransOut)
+			{
+				FlxTransitionableState.skipNextTransOut = false;
+				finishTransOut();
+			}
+		}
+	}
+
+	/**
+	 * Starts the in-transition. Can be called manually at any time.
+	 */
+	public function transitionIn():Void
+	{
+		if (transIn != null && transIn.type != NONE)
+		{
+			if (FlxTransitionableState.skipNextTransIn)
+			{
+				FlxTransitionableState.skipNextTransIn = false;
+				if (finishTransIn != null)
+				{
+					finishTransIn();
+				}
+				return;
+			}
+
+			var _trans = createTransition(transIn);
+
+			_trans.setStatus(FULL);
+			openSubState(_trans);
+
+			_trans.finishCallback = finishTransIn;
+			_trans.start(OUT);
+		}
+	}
+
+	/**
+	 * Starts the out-transition. Can be called manually at any time.
+	 */
+	public function transitionOut(?OnExit:Void->Void):Void
+	{
+		_onExit = OnExit;
+		if (hasTransOut)
+		{
+			var _trans = createTransition(transOut);
+
+			_trans.setStatus(EMPTY);
+			openSubState(_trans);
+
+			_trans.finishCallback = finishTransOut;
+			_trans.start(IN);
+		}
+		else
+		{
+			_onExit();
+		}
+	}
+
+	var transOutFinished:Bool = false;
+
+	var _exiting:Bool = false;
+	var _onExit:Void->Void;
+
+	function get_hasTransIn():Bool
+	{
+		return transIn != null && transIn.type != NONE;
+	}
+
+	function get_hasTransOut():Bool
+	{
+		return transOut != null && transOut.type != NONE;
+	}
+
+	function createTransition(data:TransitionData):Transition
+	{
+		return switch (data.type)
+		{
+			case CUSTOM: data.transitionState;
+			case TILES: new Transition(data);
+			case FADE: new Transition(data);
+			default: null;
+		}
+	}
+
+	function finishTransIn()
+	{
+		closeSubState();
+	}
+
+	function finishTransOut()
+	{
+		transOutFinished = true;
+
+		if (!_exiting)
+		{
+			closeSubState();
+		}
+
+		if (_onExit != null)
+		{
+			_onExit();
+		}
+	}
+}

flixel/addons/transition/Transition.hx

@@ -25,41 +25,43 @@ import flixel.util.FlxTimer;
 class Transition extends FlxSubState
 {
 	public var finishCallback(get, set):Void->Void;
-	
+
 	var _effect:TransitionEffect;
-	
+
 	public function new(data:TransitionData)
 	{
 		super(FlxColor.TRANSPARENT);
-		
+
 		_effect = createEffect(data);
 		_effect.scrollFactor.set(0, 0);
 		add(_effect);
 	}
-	
+
 	public override function destroy():Void
 	{
 		super.destroy();
-		
+
 		finishCallback = null;
-		
+
 		_effect = FlxDestroyUtil.destroy(_effect);
 	}
-	
+
 	public function start(newStatus:TransitionStatus):Void
 	{
 		_effect.start(newStatus);
 	}
-	
+
 	public function setStatus(newStatus:TransitionStatus):Void
 	{
 		_effect.setStatus(newStatus);
 	}
-	
+
 	function createEffect(data:TransitionData):TransitionEffect
 	{
 		switch (data.type)
 		{
+			case TransitionType.CUSTOM:
+				return new TransitionEffect(data);
 			case TransitionType.TILES:
 				return new TransitionTiles(data);
 			case TransitionType.FADE:
@@ -68,26 +70,26 @@ class Transition extends FlxSubState
 				throw "Unexpected TransitionType: NONE";
 		}
 	}
-	
+
 	function get_finishCallback():Void->Void
 	{
 		if (_effect != null)
 		{
 			return _effect.finishCallback;
 		}
-		
+
 		return null;
 	}
-	
+
 	function set_finishCallback(callback:Void->Void):Void->Void
 	{
 		if (_effect != null)
 		{
 			_effect.finishCallback = callback;
-			
+
 			return callback;
 		}
-		
+
 		return null;
 	}
 }