Handling lost gpu context on stage3d

src/flambe/System.hx

@@ -121,15 +121,21 @@ class System
      */
     public static var volume (default, null) :AnimatedFloat = new AnimatedFloat(1);
 
+    /**
+    * Used to indicate whether asynchronous platform initialization has finished
+    */
+    public static var promise (default, null) :Promise<Bool>;
+
     /**
      * Starts up Flambe, this should usually be the first thing a game does.
      */
     public static function init ()
     {
         if (!_calledInit) {
-            _platform.init();
+            promise = _platform.init();
             _calledInit = true;
         }
+        return promise;
     }
 
     /**

src/flambe/platform/InternalRenderer.hx

@@ -31,4 +31,9 @@ interface InternalRenderer<NativeImage> extends RendererSystem<NativeImage>
      * Notifies the renderer that drawing the frame is complete.
      */
     function didRender () :Void;
+
+	/**
+	 * Returns true if rendering can be done, false otherwise (e.g. gpu context is lost).
+	 */
+	function canRender () :Bool;
 }

src/flambe/platform/Platform.hx

@@ -13,7 +13,7 @@ import flambe.util.Promise;
 
 interface Platform
 {
-    function init () :Void;
+    function init () :Promise<Bool>;
 
     function getExternal () :ExternalSystem;
     function getKeyboard () :KeyboardSystem;

src/flambe/platform/flash/FlashPlatform.hx

@@ -37,6 +37,10 @@ class FlashPlatform
     public function init ()
     {
         var stage = Lib.current.stage;
+        var promise = new Promise<Bool>();
+        promise.success.connect(function (result) {
+            Log.info("Initialized Flash platform", ["renderer", _renderer.type]);
+        });
 
         _stage = new FlashStage(stage);
         _pointer = new BasicPointer();
@@ -47,7 +51,12 @@ class FlashPlatform
         _touch = new DummyTouch();
 #end
 
-        _renderer = new Stage3DRenderer();
+        var stage3DRenderer = new Stage3DRenderer();
+        _renderer = stage3DRenderer;
+        stage3DRenderer.promise.success.connect(function (result) {
+            // Stage3DRenderer's initialization is the only asynchronous part of FlashPlatform's init
+            promise.result = result;
+        });
         mainLoop = new MainLoop();
 
         stage.addEventListener(Event.ENTER_FRAME, onEnterFrame);
@@ -96,7 +105,7 @@ class FlashPlatform
         new DebugLogic(this);
         _catapult = FlashCatapultClient.canUse() ? new FlashCatapultClient() : null;
 #end
-        Log.info("Initialized Flash platform", ["renderer", _renderer.type]);
+        return promise;
     }
 
     public function loadAssetPack (manifest :Manifest) :Promise<AssetPack>
@@ -238,7 +247,8 @@ class FlashPlatform
 
     private function onRender (_)
     {
-        mainLoop.render(_renderer);
+		if(_renderer.canRender())
+			mainLoop.render(_renderer);
     }
 
     private function onUncaughtError (event :UncaughtErrorEvent)

src/flambe/platform/flash/FlashStage.hx

@@ -122,6 +122,9 @@ class FlashStage
 
     private function onResize (_)
     {
+#if flash
+		if (!FlashPlatform.instance.getRenderer().canRender()) return;
+#end
         resize.emit();
     }
 

src/flambe/platform/flash/Stage3DRenderer.hx

@@ -10,6 +10,7 @@ import flash.display.Stage3D;
 import flash.events.ErrorEvent;
 import flash.events.Event;
 import flash.Lib;
+import hxsl.Shader;
 
 import haxe.io.Bytes;
 
@@ -18,6 +19,7 @@ import flambe.display.Graphics;
 import flambe.display.Texture;
 import flambe.subsystem.RendererSystem;
 import flambe.util.Assert;
+import flambe.util.Promise;
 import flambe.util.Value;
 
 class Stage3DRenderer
@@ -31,9 +33,23 @@ class Stage3DRenderer
 
     public var batcher (default, null) :Stage3DBatcher;
 
+    /**
+    * Used to indicate whether a Context3D has been created yet, as this is the only asynchronous point of Flash init
+    */
+    public var promise : Promise<Bool>;
+
+#if stage3d_handle_context_loss
+	private var rootToData:Map<Stage3DTextureRoot, BitmapData>;
+#end
+
     public function new ()
     {
         _hasGPU = new Value<Bool>(false);
+        promise = new Promise<Bool>();
+#if stage3d_handle_context_loss
+		rootToData = new Map();
+		_hasGPU.changed.connect(handleContextLoss, true);
+#end
 
         // Use the first available Stage3D
         var stage = Lib.current.stage;
@@ -55,6 +71,23 @@ class Stage3DRenderer
         }
         Log.error("No free Stage3Ds available!");
     }
+
+	public function canRender():Bool {
+		return _context3D != null && _context3D.driverInfo != "Disposed";
+	}
+
+#if stage3d_handle_context_loss
+	function handleContextLoss(has:Bool, didHave:Bool) :Void
+	{
+		if (has && promise.hasResult) {//context was created and it's not the first context
+			Log.info("Stage3D GPU context was lost, reuploading textures");
+			for (root in rootToData.keys()) {
+				root.init(_context3D, false);
+				root.uploadBitmapData(rootToData.get(root));
+			}
+		}
+	}
+#end
 
     inline private function get_type () :RendererType
     {
@@ -76,9 +109,12 @@ class Stage3DRenderer
         if (_context3D == null) {
             return null; // No Stage3D context yet
         }
-
+		
         var bitmapData :BitmapData = cast bitmapData;
         var root = new Stage3DTextureRoot(this, bitmapData.width, bitmapData.height);
+#if stage3d_handle_context_loss
+		rootToData.set(root, bitmapData.clone());
+#end
         root.init(_context3D, false);
         root.uploadBitmapData(bitmapData);
         return root.createTexture(bitmapData.width, bitmapData.height);
@@ -142,8 +178,15 @@ class Stage3DRenderer
         onResize(null);
 
         // Signal that the GPU context was (re)created
+		ShaderGlobals.disposeAll(true);
         hasGPU._ = false;
         hasGPU._ = true;
+
+        // initialization of the Renderer has completed if a Context3D has been created
+        if (!promise.hasResult)
+        {
+            promise.result = true;
+        }
     }
 
     private function onError (event :ErrorEvent)
@@ -153,7 +196,7 @@ class Stage3DRenderer
 
     private function onResize (_)
     {
-        if (graphics != null) {
+        if (graphics != null && canRender()) {
             var stage = Lib.current.stage;
             batcher.resizeBackbuffer(stage.stageWidth, stage.stageHeight);
             graphics.onResize(stage.stageWidth, stage.stageHeight);

src/flambe/platform/html/CanvasRenderer.hx

@@ -78,6 +78,10 @@ class CanvasRenderer
     {
         graphics.didRender();
     }
+
+	public function canRender() {
+		return true;
+	}
 
     public function getName () :String
     {

src/flambe/platform/html/HtmlPlatform.hx

@@ -266,7 +266,12 @@ class HtmlPlatform
         _catapult = HtmlCatapultClient.canUse() ? new HtmlCatapultClient() : null;
 #end
 #end
-        Log.info("Initialized HTML platform", ["renderer", _renderer.type]);
+        var promise = new Promise<Bool>();
+        promise.success.connect(function (result) {
+            Log.info("Initialized HTML platform", ["renderer", _renderer.type]);
+        });
+        promise.result = true;
+        return promise;
     }
 
     public function loadAssetPack (manifest :Manifest) :Promise<AssetPack>

src/flambe/platform/html/WebGLRenderer.hx

@@ -105,6 +105,10 @@ class WebGLRenderer
     {
         graphics.didRender();
     }
+
+	public function canRender() {
+		return !gl.isContextLost();
+	}
 
     private function onResize ()
     {