(5a377a8ee) Unstable v0.9.1000.0

Barotrauma/BarotraumaClient/ClientSource/GUI/GUIImage.cs

@@ -1,12 +1,27 @@
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace Barotrauma
 {
     public class GUIImage : GUIComponent
     {
+        //paths of the textures that are being loaded asynchronously
+        private static readonly List<string> activeTextureLoads = new List<string>();
+
+        private static bool loadingTextures;
+
+        public static bool LoadingTextures
+        {
+            get
+            {
+                return loadingTextures;
+            }
+        }
+
         public float Rotation;
 
         private Sprite sprite;
@@ -15,8 +30,12 @@ namespace Barotrauma
 
         private bool crop;
 
-        private bool scaleToFit;
-        
+        private readonly bool scaleToFit;
+
+        private bool lazyLoaded, loading;
+
+        public bool LoadAsynchronously;
+                
         public bool Crop
         {
             get
@@ -75,7 +94,6 @@ namespace Barotrauma
         private GUIImage(RectTransform rectT, Sprite sprite, Rectangle? sourceRect, bool scaleToFit, string style) : base(style, rectT)
         {
             this.scaleToFit = scaleToFit;
-            sprite?.EnsureLazyLoaded();
             Sprite = sprite;
             if (sourceRect.HasValue)
             {
@@ -95,18 +113,45 @@ namespace Barotrauma
             }
             else
             {
-                rectT.SizeChanged += RecalculateScale;
+                if (Sprite != null && !Sprite.LazyLoad)
+                {
+                    rectT.SizeChanged += RecalculateScale;
+                }
             }
             Enabled = true;
         }
 
         protected override void Draw(SpriteBatch spriteBatch)
         {
-            if (!Visible) return;
+            if (!Visible || loading) { return; }
 
             if (Parent != null) { State = Parent.State; }
             if (OverrideState != null) { State = OverrideState.Value; }
 
+            if (Sprite != null && Sprite.LazyLoad && !lazyLoaded)
+            {
+                if (LoadAsynchronously)
+                {
+                    loadingTextures = true;
+                    loading = true;
+                    TaskPool.Add(LoadTextureAsync(), (Task) =>
+                    {
+                        loading = false;
+                        lazyLoaded = true;
+                        RectTransform.SizeChanged += RecalculateScale;
+                        RecalculateScale();
+                    });
+                    return;
+                }
+                else
+                {
+                    Sprite.EnsureLazyLoaded();
+                    RectTransform.SizeChanged += RecalculateScale;
+                    RecalculateScale();
+                    lazyLoaded = true;
+                }
+            }
+
             Color currentColor = GetColor(State);
 
             if (BlendState != null)
@@ -146,9 +191,53 @@ namespace Barotrauma
 
         private void RecalculateScale()
         {
+            if (sourceRect == Rectangle.Empty && sprite != null)
+            {
+                sourceRect = sprite.SourceRect;
+            }
+
             Scale = sprite == null || sprite.SourceRect.Width == 0 || sprite.SourceRect.Height == 0 ?
                 1.0f :
                 Math.Min(RectTransform.Rect.Width / (float)sprite.SourceRect.Width, RectTransform.Rect.Height / (float)sprite.SourceRect.Height);
         }
+
+        private async Task<bool> LoadTextureAsync()
+        {
+            await Task.Yield();
+            bool wait = true;
+            {
+                //if another GUIImage is already loading the same texture, wait for it to finish
+                while (wait)
+                {
+                    await Task.Delay(5);
+                    lock (activeTextureLoads)
+                    {
+                        wait = activeTextureLoads.Contains(Sprite.FullPath);
+                    }
+                }                
+            }
+            try
+            {
+                lock (activeTextureLoads)
+                {
+                    activeTextureLoads.Add(Sprite.FullPath);
+                }
+                Sprite.EnsureLazyLoaded();
+            }
+            finally
+            {
+                DateTime timeOut = DateTime.Now + new TimeSpan(0, 0, 10);
+                while (!Sprite.Loaded && DateTime.Now < timeOut)
+                {
+                    await Task.Delay(5);
+                }
+                lock (activeTextureLoads)
+                {
+                    activeTextureLoads.Remove(Sprite.FullPath);
+                    loadingTextures = activeTextureLoads.Count > 0;
+                }
+            }
+            return true;
+        }
     }
 }