Trying to make a map viewer scene

Assets/Plugins/LibreMetaverse/Imaging/TGALoader.cs

@@ -462,6 +462,8 @@ namespace OpenMetaverse.Imaging
             return LoadTGA(stream); // better refactor this mess later
 
         }
+
+        //Decode TGA file given in stream form.
         public static Texture2D LoadTGA(System.IO.Stream source)
         {
             //byte[] buffer = new byte[source.Length];

Assets/Raindrop/UI/map.meta

@@ -1,5 +1,6 @@
 fileFormatVersion: 2
-guid: 9df6cd2f9439dd04fb0d7a5aeb12e189
+guid: ed442c2a5b1abb14b92417c79f45d2f4
+folderAsset: yes
 DefaultImporter:
   externalObjects: {}
   userData: 

Assets/Raindrop/UI/map/MapDataPool.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Raindrop
+{
+    //holds data for the map in memory.
+    //the model.
+    public class MapDataPool
+    {
+        public class MapTile
+        {
+            // it seems that a tile from the http is ~ 17KB in JPEG format; making it kind of spammable at the highest zoom level of 4.
+            public int size; //in sims.
+            public Texture2D texture;
+
+            public int gridPosX;
+            public int gridPosY;
+
+            public static Texture2D emptyTexture = Texture2D.redTexture;
+
+            public MapTile(int width, int height)
+            {
+                texture = emptyTexture;
+                size = 0;
+                gridPosX = 0;
+                gridPosY = 0;
+            }
+
+            public void clearTex()
+            {
+                texture = emptyTexture;
+                size = 0;
+                gridPosX = 0;
+                gridPosY = 0;
+            }
+
+            public Vector2Int regionMin => new Vector2Int(gridPosX, gridPosY);
+            public Vector2Int regionMax => new Vector2Int(gridPosX + size - 1, gridPosY + size - 1); //inclusive
+        }
+
+
+        //tiles showing.
+        public Dictionary<ulong, MapTile> regionTiles = new Dictionary<ulong, MapTile>();
+        public int texCount => regionTiles.Count;
+
+        // tiles that can be recycled.
+        private List<MapTile> tilesToRecycle = new List<MapTile>();
+        private Queue<MapTile> tilePool;
+        //public int poolSize = 10;
+        //List<ulong> tileRequests = new List<ulong>();
+
+        public MapDataPool(int poolSize)
+        {
+            tilePool = new Queue<MapTile>(poolSize);
+            for (int i = 0; i < poolSize; i++)
+            {
+                tilePool.Enqueue(new MapTile(256, 256));
+            }
+
+        }
+
+        // gets a maptile from available pool.
+        public MapTile getUnusedTex()
+        {
+            if (tilePool.Count == 0)
+            {
+                recycleTex();
+                return tilePool.Dequeue();
+            }
+            else
+            {
+                return tilePool.Dequeue();
+            }
+        }
+
+        // marks the texture/region for recycling.
+        public void markTileToBeRecycled(MapTile tile)
+        {
+            tilesToRecycle.Add(tile);
+
+        }
+
+        // try to drop old textures and return them to the pool.
+        private void recycleTex()
+        {
+            //foreach (var tile in tilesToRecycle)
+            //{
+            //    MapTile _tex;
+            //    regionTiles.TryGetValue(reg, out _tex);
+            //    tilePool.Enqueue(_tex);
+                
+            //}
+        }
+    }
+}

Assets/Raindrop/UI/map/MapDataPool.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: a2be8bfbd0fb2ed4392954006c629c35
+guid: f157d1bbe73dcd6478c48641516b668a
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/Raindrop/UI/map/MapLogic.cs

@@ -0,0 +1,213 @@
+using OpenMetaverse;
+using Raindrop.Network;
+using Raindrop.UI;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+using static Raindrop.MapDataPool;
+
+namespace Raindrop
+{
+    public class MapLogic
+    {
+        //range logic
+        internal static OpenMetaverse.Vector2 getMinVec2(OpenMetaverse.Vector2 range, OpenMetaverse.Vector2 focalPoint)
+        {
+            return focalPoint - new OpenMetaverse.Vector2(range.X / 2 , range.Y / 2);
+        }
+        
+        internal static OpenMetaverse.Vector2 getMaxVec2(OpenMetaverse.Vector2 range, OpenMetaverse.Vector2 focalPoint)
+        {
+            return focalPoint + new OpenMetaverse.Vector2(range.X / 2 , range.Y / 2);
+        }
+
+        //backend image fetch logic
+
+
+        //backend, map fetching class
+        public class MapFetcher
+        {
+            private MapDataPool mapData;
+            List<ulong> tileRequests = new List<ulong>(); // a list of pending fetch requests. the ulongs are the x and y world coordinates (gridX * 256), packed.
+            uint regionSize = 256;
+            private ParallelDownloader downloader;
+            int poolSize = 10;
+
+            public MapFetcher()
+            {
+                mapData = new MapDataPool(poolSize);
+                downloader = new ParallelDownloader();
+            }
+
+            public MapTile GetMapTile(ulong handle, int zoom)
+            {
+                if (mapData.regionTiles.ContainsKey(handle))
+                {
+                    return mapData.regionTiles[handle];
+                }
+
+                return null;
+            }
+
+
+            //get region tile using SL map API -- JPEG images.
+            public MapTile GetRegionTileExternal(ulong handle, int zoom)
+            {
+                if ( (zoom > 4) || (zoom < 1) )
+                {
+                    return null;
+                }
+
+
+                if (mapData.regionTiles.ContainsKey(handle))
+                {
+                    return mapData.regionTiles[handle];
+                }
+                else
+                {
+                    lock (tileRequests)
+                    {
+                        if (tileRequests.Contains(handle)) return null;
+                        tileRequests.Add(handle);
+                    }
+
+                    uint regX, regY;
+                    Utils.LongToUInts(handle, out regX, out regY);
+                    regX /= regionSize;
+                    regY /= regionSize;
+                    //int zoom = 1;
+
+                    downloader.QueueDownlad(
+                        new Uri(string.Format("http://map.secondlife.com/map-{0}-{1}-{2}-objects.jpg", zoom, regX, regY)),
+                        20 * 1000,
+                        null,
+                        null,
+                        (request, response, responseData, error) =>
+                        {
+                            if (error == null && responseData != null)
+                            {
+                                try
+                                {
+                                    //using (MemoryStream s = new MemoryStream(responseData)) //s of JPEG
+                                    //{
+                                        //lock (mapData.regionTiles)
+                                        //{
+                                        //    //decode http response data into texture2d
+                                        //    MapTile tex = mapData.getUnusedTex();
+                                        //    tex.texture.LoadImage(responseData); //Image.FromStream(s);
+                                        //    //mapData.regionTiles[handle] = 
+                                        //    //needRepaint = true;
+                                        //}
+                                    //}
+                                }
+                                catch { }
+                            }
+                        }
+                    );
+
+                    lock (mapData.regionTiles)
+                    {
+                        mapData.regionTiles[handle] = null;
+                    }
+
+                    return null;
+                }
+            }
+
+
+            // get image from cache or asset manager. returns tex2D.
+            // should only be used for the minimap. Use http map API fetch for normal map.
+            //Texture2D DownloadRegionTile(ulong handle, UUID imageID, GridClient Client)
+            //{
+            //    //if (mapData.regionTiles.ContainsKey(handle)) return;
+
+            //    //lock (tileRequests)
+            //    //    if (!tileRequests.Contains(handle))
+            //    //        tileRequests.Add(handle);
+
+
+            //    Uri url = Client.Network.CurrentSim.Caps.GetTextureCapURI();
+            //    if (url != null)
+            //    {
+            //        if (Client.Assets.Cache.HasAsset(imageID))
+            //        {
+            //            Texture2D img;
+            //            OpenMetaverse.Imaging.ManagedImage mi;
+            //            if (OpenMetaverse.Imaging.OpenJPEG.DecodeToImage(Client.Assets.Cache.GetCachedAssetBytes(imageID), out mi, out img))
+            //            {
+            //                return img;
+            //                //mapData.regionTiles[handle] = img;
+            //            }
+            //            lock (tileRequests)
+            //                if (tileRequests.Contains(handle))
+            //                    tileRequests.Remove(handle);
+            //        }
+            //        else
+            //        {
+            //            downloader.QueueDownlad(
+            //                new Uri($"{url}/?texture_id={imageID}"),
+            //                30 * 1000,
+            //                "image/x-j2c",
+            //                null,
+            //                (request, response, responseData, error) =>
+            //                {
+            //                    if (error == null && responseData != null)
+            //                    {
+            //                        Image img;
+            //                        OpenMetaverse.Imaging.ManagedImage mi;
+            //                        if (OpenMetaverse.Imaging.OpenJPEG.DecodeToImage(responseData, out mi, out img))
+            //                        {
+            //                            mapData.regionTiles[handle] = img;
+            //                            Client.Assets.Cache.SaveAssetToCache(imageID, responseData);
+            //                        }
+            //                    }
+
+            //                    lock (tileRequests)
+            //                    {
+            //                        if (tileRequests.Contains(handle))
+            //                        {
+            //                            tileRequests.Remove(handle);
+            //                        }
+            //                    }
+            //                });
+            //        }
+            //    }
+            //    else
+            //    {
+            //        Client.Assets.RequestImage(imageID, (state, assetTexture) =>
+            //        {
+            //            switch (state)
+            //            {
+            //                case TextureRequestState.Pending:
+            //                case TextureRequestState.Progress:
+            //                case TextureRequestState.Started:
+            //                    return;
+
+            //                case TextureRequestState.Finished:
+            //                    if (assetTexture?.AssetData != null)
+            //                    {
+            //                        Image img;
+            //                        OpenMetaverse.Imaging.ManagedImage mi;
+            //                        if (OpenMetaverse.Imaging.OpenJPEG.DecodeToImage(assetTexture.AssetData, out mi, out img))
+            //                        {
+            //                            mapData.regionTiles[handle] = img;
+            //                        }
+            //                    }
+            //                    lock (tileRequests)
+            //                        if (tileRequests.Contains(handle))
+            //                            tileRequests.Remove(handle);
+            //                    break;
+
+            //                default:
+            //                    lock (tileRequests)
+            //                        if (tileRequests.Contains(handle))
+            //                            tileRequests.Remove(handle);
+            //                    break;
+            //            }
+            //        });
+            //    }
+            //}
+        }
+    }
+}

Assets/Raindrop/UI/map/MapLogic.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: ada9c0a801a9e0243818fc859eb91566
+guid: 58911af2e320c754488a329d38fda964
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/Raindrop/UI/map/MapMover.cs

@@ -0,0 +1,32 @@
+using System;
+using UnityEngine;
+using Raindrop;
+using OpenMetaverse;
+
+namespace Raindrop.Presenters
+{
+    //an instance of a map 'look at' ; the focal point of camera.
+    public class MapMover : MonoBehaviour
+    {
+        //grid coordinates * 256
+        [SerializeField]
+        public uint lookAt_x = 1000 * 256;
+        [SerializeField]
+        public uint lookAt_y = 1000 * 256;
+
+
+
+        ////get the grid location that we are looking at.
+        //public OpenMetaverse.Vector2 GetLookAt()
+        //{
+        //    return new OpenMetaverse.Vector2(lookAt_x,lookAt_y);
+        //}
+
+        public ulong GetLookAt()
+        {
+            return Utils.UIntsToLong(lookAt_x, lookAt_y);
+
+        }
+
+    }
+}

Assets/Raindrop/UI/map/MapMover.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: a533c5654a7ae0543b6cfbcfb692ef00
+guid: c99728517c04bae4ab466165d1e37fd7
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/Raindrop/UI/map/MapPoolPresenter.cs

@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Raindrop.UI
+{
+    // manages the pool of map textures and gameobjects.
+    // map pool.
+    // map maker
+
+    class MapPoolPresenter : MonoBehaviour
+    {
+
+
+        [SerializeField]
+        public GameObject mapPrefab;
+
+        private Dictionary<Vector2Int, GameObject> map_collection; //coordinates -> GO
+
+
+        //viewable area of the current map_collection.
+        public int max_X, max_Y;
+        public int min_X, min_Y;
+
+        //the current zoom level that the user is requesting.
+        // 1 - one 256^2 texture is 1 sim.
+        // ...
+        // 4 - one 256^2 texture is 8*8 sims.
+        public int zoomLevel;
+
+        private void Awake()
+        {
+            max_X = max_Y = max_X = max_Y = 1000;
+            zoomLevel = 1;
+            var map = Instantiate(mapPrefab, new Vector3(0, 0, 0), Quaternion.identity);
+            map_collection.Add(new Vector2Int(1000,1000), map);
+        }
+
+        private void createMapTileAt(Vector2Int pos, int zoomLevel)
+        {
+            var map = Instantiate(mapPrefab, new Vector3(0, 0, 0), Quaternion.identity);
+            map_collection.Add(pos, map);
+
+
+        }
+        private void clearTiles()
+        {
+            map_collection.Clear();
+
+        }
+
+        //private void setViewableRangeMinMax(OpenMetaverse.Vector2 min, OpenMetaverse.Vector2 max)
+        //{
+        //    // re-composites the scene based on the viewable region
+        //    updateTexturesIfNecessary(min, max);
+        //}
+
+        public void setViewableRange(OpenMetaverse.Vector2 focalPoint, OpenMetaverse.Vector2 range)
+        {
+            var min = MapLogic.getMinVec2(range, focalPoint);
+            var max = MapLogic.getMaxVec2(range, focalPoint);
+
+            // re-composites the scene based on the viewable region
+            updateTexturesIfNecessary(min, max);
+        }
+        public void setViewableRange(uint x,uint y, OpenMetaverse.Vector2 range)
+        {
+            setViewableRange(new OpenMetaverse.Vector2(x,y), range);
+        }
+
+        // min : bottom left
+        // max : top right
+        private void updateTexturesIfNecessary(OpenMetaverse.Vector2 min, OpenMetaverse.Vector2 max)
+        {
+            //'round-up' the corners.
+            int _max_X = (int) Mathf.CeilToInt(max.X);
+            int _max_Y = (int) Mathf.CeilToInt(max.Y);
+            int _min_X = (int) Mathf.CeilToInt(min.X);
+            int _min_Y = (int) Mathf.CeilToInt(min.Y);
+
+            //check if all are in the map. 
+            ////obtain list of viewable textures.
+            ////List<Vector2Int> list = new List<Vector2Int>();
+            for (int i = _min_Y; i <= _max_Y; i++)
+            {
+                for (int j = _min_X; j <= _max_X; j++)
+                {
+                    var tocheck = new Vector2Int(j, i);
+                    if (! map_collection.ContainsKey(tocheck))
+                    {
+
+                    } 
+                    //list.Add( new Vector2Int(j,i) );
+                }
+            }
+
+        }
+
+        ////sets a map block that is 256pic * 256pic
+        //private void SetMapLayer(Texture2D new_texture, Vector2Int regionXY)
+        //{
+        //    Debug.Log("setting the image to the new gameobject");
+        //    if (mapManager.map_collection.ContainsKey(regionXY))
+        //    {
+        //        //update the region.
+        //        //MonoBehaviour theGO;
+        //        //map_collection.TryGetValue(regionXY, out theGO);
+
+        //        //Destroy(theGO.map_tex); //delete the tex2d that is no longer (?) used.
+        //    }
+        //    else
+        //    {
+        //        GameObject mapGO = new GameObject();
+        //        mapGO.transform.SetParent(this.transform);
+
+        //        var MR = mapGO.AddComponent<MeshRenderer>();
+        //        MR.sharedMaterial = new UnityEngine.Material(Shader.Find("Standard"));
+        //        //MR.
+        //        var MF = mapGO.AddComponent<MeshFilter>();
+
+        //        //generate the plane.
+        //        Mesh m = new Mesh();
+        //        var width = 1;
+        //        var height = 1;
+        //        m.vertices = new Vector3[]{
+        //                        new Vector3(0, 0, 0),
+        //                        new Vector3(width, 0, 0),
+        //                        new Vector3(width, height, 0),
+        //                        new Vector3(0, height, 0)
+        //        };
+        //        m.uv = new Vector2[]{
+        //            new Vector2(0, 0),
+        //            new Vector2(0, 1),
+        //            new Vector2(1, 1),
+        //            new Vector2(1, 0),
+        //        };
+        //        m.triangles = new int[] { 0, 2, 1, 0, 3, 2 }; //clockwise?
+        //        MF.mesh = m;
+        //        m.RecalculateBounds();
+        //        m.RecalculateNormals();
+
+        //        MR.material.mainTexture = new_texture;
+
+        //        map_collection.Add(regionXY, mapGO);
+
+        //    }
+
+
+        //}
+
+
+
+    }
+}

Assets/Raindrop/UI/map/MapPoolPresenter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a541a4368999b2c40b30c71f55aa25a1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Raindrop/UI/map/MapPresenter.cs

@@ -0,0 +1,138 @@
+using OpenMetaverse;
+using OpenMetaverse.Assets;
+using OpenMetaverse.Imaging;
+using Raindrop.Netcom;
+using Raindrop.UI;
+using System;
+using System.Collections.Generic;
+using UniRx;
+using Unity;
+using UnityEngine;
+using UnityEngine.UI;
+using Vector2 = UnityEngine.Vector2;
+using Vector3 = UnityEngine.Vector3;
+
+namespace Raindrop.Presenters
+{
+    // map texture module - root gameobject.
+
+    // this manages the 2d texture objects in the map texture layer
+    // min = bottom left (OM)
+    // max = top right (OM)
+    public class MapPresenter : MonoBehaviour
+    {
+        //camera. contains the viewable range.
+        [SerializeField]
+        public GameObject cameraPresenterGO;
+        private StationaryDownwardOrthoCameraPresenter cameraPresenter;
+
+        //map mover. Contains focal point. Moves focal point in response to screen swipes.
+        [SerializeField]
+        public GameObject mapMoverGO;
+        private MapMover mapMover;
+        //public OpenMetaverse.Vector2 focalPoint;
+        //public Transform mapOrigin; // 1000,1000
+
+        // map manager. keeps track of mapsGOs. creates new mapGOs from prefabs. culls those that are no longer visible. fetches those that need to be viewed.
+        [SerializeField]
+        public GameObject mapManagerGO;
+        private MapPoolPresenter mapManager;
+
+        // a reference to the avatar in the grid.
+        public GameObject Avatar;
+
+        private RaindropInstance instance { get { return ServiceLocator.ServiceLocator.Instance.Get<RaindropInstance>(); } }
+        private RaindropNetcom netcom { get { return instance.Netcom; } }
+        private GridClient client { get { return instance.Client; } }
+
+
+
+        public void Awake()
+        {
+
+            if (cameraPresenterGO == null)
+            {
+                throw new Exception("cameraPresenterGO not assigned.");
+            }
+            cameraPresenter = cameraPresenterGO.GetComponent<StationaryDownwardOrthoCameraPresenter>();
+
+            if (mapMoverGO == null)
+            {
+                throw new Exception("MapMoverGO not assigned.");
+            }
+            mapMover = mapMover.GetComponent<MapMover>();
+
+            if (mapManagerGO == null)
+            {
+                throw new Exception("mapManagerGO not assigned.");
+            }
+            mapManager = mapManager.GetComponent<MapPoolPresenter>(); 
+
+
+            //instance.Client.Network.SimChanged += Network_OnCurrentSimChanged;
+        }
+
+
+        private void Update()
+        {
+            UpdateMapViewing();
+        }
+
+        //update what is viewable and what is not.
+        private void UpdateMapViewing()
+        {
+            var range = cameraPresenter.getRange(); // we can see this ranges now.
+            ulong focalPoint = mapMover.GetLookAt();
+            uint x;
+            uint y;
+            //var min = MapLogic.getMinVec2(range, focalPoint);
+            //var max = MapLogic.getMaxVec2(range, focalPoint);
+            Utils.LongToUInts(focalPoint, out x, out y);
+            mapManager.setViewableRange(x, y, range);
+
+        }
+
+        //private void Network_OnCurrentSimChanged(object sender, SimChangedEventArgs e)
+        //{
+
+        //    if (client.Network.Connected) return;
+
+        //    Debug.Log("Network_OnCurrentSimChanged");
+
+        //    GridRegion region;
+        //    if (client.Grid.GetGridRegion(client.Network.CurrentSim.Name, GridLayerType.Objects, out region))
+        //    {
+
+        //        Texture2D _new_MapLayer = null; // LOL! its unity texture btw.
+
+        //        UUID _MapImageID = region.MapImageID;
+        //        Vector2Int regionPos = new Vector2Int(region.X,region.Y);
+        //        ManagedImage nullImage;
+
+        //        Debug.Log("requesting map image.");
+
+        //        client.Assets.RequestImage(_MapImageID, ImageType.Baked,
+        //            delegate (TextureRequestState state, AssetTexture asset)
+        //            {
+        //                if (state == TextureRequestState.Finished)
+        //                {
+        //                    Debug.Log("minimap texture fetched, decoding it!");
+        //                    OpenJPEG.DecodeToImage(asset.AssetData, out nullImage, out _new_MapLayer); //this call interally calls to another function 'DecodeToImage(byte[] encoded, out ManagedImage managedImage)'
+
+        //                    UnityMainThreadDispatcher.Instance().Enqueue(() =>
+        //                    {
+        //                        SetMapLayer(_new_MapLayer, regionPos);
+        //                    });
+        //                }
+        //                else
+        //                    Debug.LogWarning("minimap failed to DL texture.");
+        //            });
+        //    }
+
+        //}
+
+        
+
+
+    }
+}

Assets/Raindrop/UI/map/MapPresenter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 24789bb55dde1a94880c980856f15a0a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Raindrop/UI/map/MapTileView.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+// An implementation of view. Attach to GO that has rawimage.
+// refers to a single texture; a single tile. can refer to many sims on a single tile.
+[RequireComponent(typeof(RawImage))]
+public class MapTileView : MonoBehaviour
+{
+    public void setRawImage(Texture2D img)
+    {
+        //hack: delete old texture before loading new one
+
+        if (this.GetComponent<RawImage>().texture != null)
+        {
+            UnityEngine.Object.Destroy(this.GetComponent<RawImage>().texture);
+        }
+        this.GetComponent<RawImage>().texture = img;
+
+    }
+}

Assets/Raindrop/UI/map/MapTileView.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 866e029c2878fad448f745025e9b4341
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Raindrop/UI/map/ParallelDownloader.cs

@@ -0,0 +1,138 @@
+using OpenMetaverse.Http;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Raindrop.Network
+{
+    // why is the code so repeated!!!!
+
+    public class ParallelDownloader : IDisposable
+    {
+        Queue<QueuedItem> queue = new Queue<QueuedItem>();
+        List<HttpWebRequest> activeDownloads = new List<HttpWebRequest>();
+
+        public int ParallelDownloads { get; set; } = 15;
+
+        public X509Certificate2 ClientCert { get; set; }
+
+        public virtual void Dispose()
+        {
+            lock (activeDownloads)
+            {
+                foreach (var download in activeDownloads)
+                {
+                    try
+                    {
+                        download.Abort();
+                    }
+                    catch { }
+                }
+            }
+        }
+
+        protected virtual HttpWebRequest SetupRequest(Uri address, string acceptHeader)
+        {
+            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(address);
+            request.Method = "GET";
+
+            if (!string.IsNullOrEmpty(acceptHeader))
+                request.Accept = acceptHeader;
+
+            // Add the client certificate to the request if one was given
+            if (ClientCert != null)
+                request.ClientCertificates.Add(ClientCert);
+
+            // Leave idle connections to this endpoint open for up to 60 seconds
+            request.ServicePoint.MaxIdleTime = 0;
+            // Disable stupid Expect-100: Continue header
+            request.ServicePoint.Expect100Continue = false;
+            // Crank up the max number of connections per endpoint (default is 2!)
+            request.ServicePoint.ConnectionLimit = Math.Max(request.ServicePoint.ConnectionLimit, 128);
+            // Caps requests are never sent as trickles of data, so Nagle's
+            // coalescing algorithm won't help us
+            request.ServicePoint.UseNagleAlgorithm = false;
+
+            return request;
+        }
+
+        private void EnqueuePending()
+        {
+            lock (queue)
+            {
+                if (queue.Count > 0)
+                {
+                    int nr = 0;
+                    lock (activeDownloads) nr = activeDownloads.Count;
+
+                    for (int i = nr; i < ParallelDownloads && queue.Count > 0; i++)
+                    {
+                        QueuedItem item = queue.Dequeue();
+                        Debug.Log("Requesting " + item.address);
+                        HttpWebRequest req = SetupRequest(item.address, item.contentType);
+                        CapsBase.DownloadDataAsync(
+                            req,
+                            item.millisecondsTimeout,
+                            item.downloadProgressCallback,
+                            (request, response, responseData, error) =>
+                            {
+                                lock (activeDownloads) activeDownloads.Remove(request);
+                                item.completedCallback(request, response, responseData, error);
+                                EnqueuePending();
+                            }
+                        );
+
+                        lock (activeDownloads) activeDownloads.Add(req);
+                    }
+                }
+            }
+        }
+
+        // Call this to request content which runs a desired callback on completion.
+        public void QueueDownlad(Uri address, int millisecondsTimeout,
+            string contentType,
+            CapsBase.DownloadProgressEventHandler downloadProgressCallback,
+            CapsBase.RequestCompletedEventHandler completedCallback)
+        {
+            lock (queue)
+            {
+                queue.Enqueue(new QueuedItem(
+                    address,
+                    millisecondsTimeout,
+                    contentType,
+                    downloadProgressCallback,
+                    completedCallback
+                    ));
+            }
+            EnqueuePending();
+        }
+
+        public class QueuedItem
+        {
+            public Uri address;
+            public int millisecondsTimeout;
+            public CapsBase.DownloadProgressEventHandler downloadProgressCallback;
+            public CapsBase.RequestCompletedEventHandler completedCallback;
+            public string contentType;
+
+            public QueuedItem(Uri address, int millisecondsTimeout,
+                string contentType,
+                CapsBase.DownloadProgressEventHandler downloadProgressCallback,
+                CapsBase.RequestCompletedEventHandler completedCallback)
+            {
+                this.address = address;
+                this.millisecondsTimeout = millisecondsTimeout;
+                this.downloadProgressCallback = downloadProgressCallback;
+                this.completedCallback = completedCallback;
+                this.contentType = contentType;
+            }
+        }
+
+    }
+
+}

Assets/Raindrop/UI/map/ParallelDownloader.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0b1bcd9ff695f1f41a5a81b781a750b1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Raindrop/UI/map/StationaryDownwardOrthoCameraPresenter.cs

@@ -0,0 +1,113 @@
+using OpenMetaverse;
+using System;
+using UnityEngine;
+using Vector2 = OpenMetaverse.Vector2;
+
+namespace Raindrop.Presenters
+{
+    //the camera no longer moves. however the zoom is still controlled here.
+    //the map moves.
+    internal class StationaryDownwardOrthoCameraPresenter : MonoBehaviour
+    {
+        public GameObject cameraGO;
+        public Camera camera;
+
+        private void Awake()
+        {
+            //viewableSize = camera.orthographicSize; //orthographicSize is half the size of the vertical viewing volume. 
+            init();
+        }
+
+        // get the viewable range of the camera as x,y tuple.
+        public OpenMetaverse.Vector2 getRange()
+        {
+            return new Vector2(getHorzRange(), getVertRange());
+        }
+
+        // get the vertical height of the camera as float.
+        public float getVertHeight()
+        {
+            return camera.orthographicSize;
+        }
+        // set the vertical height of the camera as float.
+        public void setVertHeight(float height)
+        {
+            camera.orthographicSize = height;
+            return;
+        }
+
+        private float getVertRange()
+        {
+            return camera.orthographicSize * 2;
+        }
+        private float getHorzRange()
+        {
+            return camera.orthographicSize * 2 * camera.aspect;
+        }
+
+        ////these coordinate differences are quite condfusing.
+        //// update cam to look at specified grid's location 
+        //private void _updateCameraPos(int gridX , int gridY)
+        //{
+        //    int north_south = gridX;
+        //    int east_west = gridY;
+        //    var uepos = new UnityEngine.Vector3(east_west, cameraHeight,north_south);
+        //    camera.transform.position = uepos;
+        //}
+
+        ////sets the camera to look at this particular simulator texture.
+        //public void setPos(int gridX, int gridY)
+        //{
+        //    _updateCameraPos(gridX,gridY);
+
+        //}
+
+
+        ////reset to look at a sane location
+        //internal void _resetCameraPos()
+        //{
+        //    moveToGridCoord(1000,1000); //Daboom?
+        //}
+
+        //private void moveToGridCoord(int gridX, int gridY)
+        //{
+        //    gridPositionX = gridX;  //north
+        //    gridPositionY = gridY;  //east west
+        //    _updateCameraPos(gridX, gridY);
+        //}
+
+        internal void init()
+        {
+            if (cameraGO == null || !cameraGO.GetComponent<Camera>())
+            {
+                Debug.LogError("no cam assigned to map camera presenter.");
+                //camera = this.gameObject.GetComponentInChildren<Camera>();
+                return;
+            }
+            camera = cameraGO.GetComponent<Camera>();
+
+            //cameraGO = new GameObject();
+            //camera = cameraGO.AddComponent<Camera>();
+
+            //camera.depth = 5;
+            //camera = cameraGO.GetComponent<Camera>();
+            //camera.orthographic = true;
+            //camera.clearFlags = CameraClearFlags.SolidColor;
+            //camera.backgroundColor = Color.black;
+            //camera.cullingMask = LayerMask.NameToLayer("Minimap"); //only render minimap layer.
+            //oriantetaion
+            //camera.transform.position = new UnityEngine.Vector3(0, cameraHeight, 0);
+            //camera.transform.forward = UnityEngine.Vector3.down;
+            //_resetCameraPos();
+
+            //camera.transform.SetParent(this.transform);
+
+
+            //make the camera from prefab.
+            //sceneCamera = UnityEngine.Object.Instantiate(cameraPrefab, new Vector3(0, 0, 0), Quaternion.identity);
+
+            //make ortho camera 
+
+        }
+    }
+}

Assets/Raindrop/UI/map/StationaryDownwardOrthoCameraPresenter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 70c86f72b7212fb4a8354a06349ebcec
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Raindrop/UI/testing/MapViewer.cs

@@ -0,0 +1,105 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System.IO;
+using Better.StreamingAssets;
+using System;
+using Raindrop;
+using UnityEngine.UI;
+using Raindrop.Presenters;
+using OpenMetaverse;
+using static Raindrop.MapDataPool;
+
+// lets you view the maps by choosing parameters.
+// use external API. does not need login.
+public class MapViewer : MonoBehaviour
+{
+    
+    [SerializeField]
+    public MapLogic.MapFetcher mapFetcher;
+
+    [SerializeField]
+    public GameObject mapTileGO;
+    private MapTileView iv;
+
+    [SerializeField]
+    public GameObject zoomSliderGO;
+    private Slider zoomSlider;
+
+    [SerializeField]
+    public GameObject mapMoverGO;
+    private MapMover mapMover;
+
+    private float timeStart;
+    private int imagesCount;
+    private int currentFileIndex;
+
+    bool needRepaint = false;
+
+    System.Threading.Timer repaint;
+    private void Awake()
+    {
+        //in main thread, before all uses.
+        //BetterStreamingAssets.Initialize();
+    } 
+    
+
+    private void Start()
+    {
+        InvokeRepeating("drawImage", 5f, 30f);
+
+        //get reference to the view.
+        iv = mapTileGO.GetComponent<MapTileView>();
+        if (iv == null)
+        {
+            throw new System.Exception("Imageview is fucked"); // fix exception type plz
+        }
+
+        //get reference to the view.
+        zoomSlider = zoomSliderGO.GetComponent<Slider>();
+        if (zoomSlider == null)
+        {
+            throw new System.Exception("slider is fucked"); // fix exception type plz
+        }
+
+        //get reference to the view.
+        mapMover = mapMoverGO.GetComponent<MapMover>();
+        if (mapMover == null)
+        {
+            throw new System.Exception("mapMoverGO is fucked"); // fix exception type plz
+        }
+
+        mapFetcher = new MapLogic.MapFetcher();
+    }
+
+    //call this to redraw everything based on new params
+    public void onRefresh()
+    {
+        ulong handle = mapMover.GetLookAt();
+        int zoom = (int)zoomSlider.value;
+        // how 2 convert look at floats into uints? (uints are gridpos * 256)
+        mapFetcher.GetRegionTileExternal(handle, zoom);
+        
+        needRepaint = true;
+
+        Debug.Log("refreshed internal images. fetching images if any..");
+        return;
+    }
+
+    private void drawImage( )
+    {
+        onRefresh(); //hacky
+
+        if (needRepaint)
+        {
+            needRepaint = false;
+        } else
+        {
+            return;
+        }
+        ulong handle = mapMover.GetLookAt();
+        MapTile tex = mapFetcher.GetMapTile(handle, 1);
+        iv.setRawImage(tex.texture);
+        Debug.Log("drew images.");
+    }
+}

Assets/Raindrop/UI/testing/MapViewer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 94a035e39438d0e48b0e7c85961e829e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Raindrop/UI/testing/TGAFileViewerStreamingAssets.cs

@@ -3,25 +3,34 @@ using System.Collections.Generic;
 using UnityEngine;
 using System.IO;
 using Better.StreamingAssets;
+using System;
 
 public class TGAFileViewerStreamingAssets : MonoBehaviour
 {
     [SerializeField]
     private string pathToTGAFolder;
+    [SerializeField]
+    public bool useThreads; //run the extraction and GPU pumping in non-mainthread.
+
     [SerializeField]
     public GameObject rawImageGO;
     private RawImageView iv;
     [SerializeField]
-    public GameObject textGO;
+    public GameObject textPathGO;
+    [SerializeField]
+    public GameObject texttime1GO;
+    [SerializeField]
+    public GameObject texttime2GO;
+
     [SerializeField]
     public List<string> filesInStreamingAssets;//= new List<string> { "openmetaverse_data/blush_alpha.tga" };
     
     //private List<FileInfo> fileList;
     public int currentFileIndex = 0;
     private float timeStart;
-    private int imagesCount = 5;
+    private int imagesCount;
 
-    private string[] paths;
+    public string[] paths;
     private byte[] poolItemBytes; //a object just to pool memory?
 
     private void Awake()
@@ -38,6 +47,7 @@ public class TGAFileViewerStreamingAssets : MonoBehaviour
         {
             throw new System.Exception("Imageview is fucked"); // fix exception type plz
         }
+          
 
         //check if the path is exist.
         if (!BetterStreamingAssets.DirectoryExists(pathToTGAFolder))
@@ -49,7 +59,7 @@ public class TGAFileViewerStreamingAssets : MonoBehaviour
         //get all files.
         
         paths = BetterStreamingAssets.GetFiles(pathToTGAFolder, "*.tga", SearchOption.AllDirectories);
-
+        imagesCount = paths.Length;
 
         ////get list of .tgas
         //DirectoryInfo d = new DirectoryInfo(pathToTGAFolder);
@@ -63,7 +73,7 @@ public class TGAFileViewerStreamingAssets : MonoBehaviour
 
         currentFileIndex++;
         currentFileIndex %= imagesCount;
-        ReadAndSetImage(currentFileIndex);
+        ReadAndSetImageOpenStream(currentFileIndex);
 
 
         return;
@@ -74,36 +84,66 @@ public class TGAFileViewerStreamingAssets : MonoBehaviour
         currentFileIndex--;
         currentFileIndex += imagesCount; //not sure if necessary -- prevent negative modulo
         currentFileIndex %= imagesCount;
-        ReadAndSetImage(currentFileIndex);
+        ReadAndSetImageOpenStream(currentFileIndex);
          
 
         return;
     }
 
-    private void ReadAndSetImage(int _currentFileIndex)
+    private void ReadAndSetImageOpenStream(int _currentFileIndex)
     {
         string filepath = paths[_currentFileIndex];
-        textGO.GetComponent<TextView>().setText(filepath);
 
         float timeStart = Time.realtimeSinceStartup;
+        float timeEndStreamOpen;
         Texture2D tex;
         using (var stream = BetterStreamingAssets.OpenRead(filepath))
         {
-             tex = OpenMetaverse.Imaging.LoadTGAClass.LoadTGA(stream);
+            timeEndStreamOpen = Time.realtimeSinceStartup;
+            tex = OpenMetaverse.Imaging.LoadTGAClass.LoadTGA(stream);
         }
 
         //StreamAssetsReader.read(filepath, poolItemBytes); // new allocation deep inside here.
         //var tex = OpenMetaverse.Imaging.LoadTGAClass.LoadTGA(poolItemBytes);
-        float timeEnd = Time.realtimeSinceStartup;
+        float timeEndTex = Time.realtimeSinceStartup;
         if (tex == null)
         {
             Debug.Log("reading of TGA at path " + filepath + " failed");
             return;
         }
-        Debug.Log("reading of TGA at path " + filepath + " SUCCESS! \nTook: " + (timeEnd - timeStart) + "seconds");
+        
-
 
         iv.setRawImage(tex);
+        setTextPath(filepath);
+        setTextTime1(timeEndStreamOpen - timeStart);
+        setTextTime2(timeEndTex - timeStart);
+    }
+
+    private void setTextTime2(float v)
+    {
+        var text = texttime2GO.GetComponent<TextView>();
+        if (text != null)
+        {
+            text.setText((v * 1000).ToString() + " ms");
+        }
+    }
+
+    private void setTextTime1(float v)
+    {
+        var text = texttime1GO.GetComponent<TextView>();
+        if (text != null)
+        {
+            text.setText((v*1000).ToString() + " ms");
+        }
+    }
+
+    private void setTextPath(string filepath)
+    {
+        var text = textPathGO.GetComponent<TextView>();
+        if (text != null)
+        {
+            text.setText(filepath);
+        }
     }
 
 

Assets/Raindrop/UI/testing/TestTextureFetcher.cs

@@ -0,0 +1,42 @@
+using OpenMetaverse;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Raindrop
+{
+    class TestTextureFetcher : MonoBehaviour
+    {
+        [SerializeField]
+        public MapLogic.MapFetcher mapFetcher;
+
+        private void Awake()
+        {
+
+            mapFetcher = new MapLogic.MapFetcher();
+        }
+
+
+        public void testfetch()
+        {
+
+
+            //HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://www.google.com");
+            //request.BeginGetResponse(new AsyncCallback(Finish), request);;
+
+            var handle = Utils.UIntsToLong(256 * 1000, 256 * 1000);
+            mapFetcher.GetRegionTileExternal(handle, 1);
+        }
+
+
+
+        private void Finish(IAsyncResult result)
+        {
+            Debug.Log("FINISH"); 
+        }
+    }
+}

Assets/Raindrop/UI/testing/TestTextureFetcher.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d43fa4d05196d7d45b7f29c0fba49650
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Raindrop/UI/views.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ead2ebb6c53976d4295bae40ef81c523
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Raindrop/UI/views/RawImageView.cs

@@ -4,6 +4,7 @@ using UnityEngine;
 using System.IO;
 using UnityEngine.UI;
 
+// An implementation of rawimage view. Attach to GO that has rawimage.
 [RequireComponent(typeof(RawImage))]
 public class RawImageView  : MonoBehaviour
 

Assets/Raindrop/UI/views/TextView.cs

@@ -1,19 +1,20 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
+// An implementation of view. Attach to GO that has TMP_text.
 [RequireComponent(typeof(TMPro.TMP_Text))]
 public class TextView : MonoBehaviour
 {
-    // Start is called before the first frame update
-    void Start()
-    {
-        
-    }
-
 
     public void setText(string text)
     {
         this.GetComponent<TMPro.TMP_Text>().text = text;
     }
+
+    internal void setText(float v)
+    {
+        throw new NotImplementedException();
+    }
 }

Assets/Raindrop/Unity3D/MapImageCameraPresenter.cs

@@ -1,85 +0,0 @@
-using OpenMetaverse;
-using System;
-using UnityEngine;
-using Vector2 = OpenMetaverse.Vector2;
-
-namespace Raindrop.Presenters
-{
-    //this just moves the camera around.
-    internal class MapImageCameraPresenter : MonoBehaviour
-    {
-        //public MapImageManager mapmanager;
-        public Camera camera;
-        public GameObject cameraGO;
-
-        internal int gridPositionX; //grid index
-        internal int gridPositionY;
-        internal int gridOffsetX; //inside grid
-        internal int gridOffsetY;
-
-        private int cameraHeight = 10;
-
-        //these coordinate differences are quite condfusing.
-        private void _updateCameraPos(int gridX , int gridY)
-        {
-            int north_south = gridX;
-            int east_west = gridY;
-            var uepos = new UnityEngine.Vector3(east_west, cameraHeight,north_south);
-            camera.transform.position = uepos;
-        }
-
-        //sets the camera to look at this particular simulator texture.
-        public void setPos(int gridX, int gridY)
-        {
-            _updateCameraPos(gridX,gridY);
-
-        }
-
-
-        //reset to look at a sane location
-        internal void _resetCameraPos()
-        {
-            moveToGridCoord(1000,1000); //Daboom?
-        }
-
-        private void moveToGridCoord(int gridX, int gridY)
-        {
-            gridPositionX = gridX;  //north
-            gridPositionY = gridY;  //east west
-            _updateCameraPos(gridX, gridY);
-        }
-
-        internal void init()
-        {
-            if (camera == null)
-            {
-                camera = this.gameObject.GetComponentInChildren<Camera>();
-                cameraGO = camera.gameObject;
-
-            }
-
-            //cameraGO = new GameObject();
-            //camera = cameraGO.AddComponent<Camera>();
-
-            //camera.depth = 5;
-            //camera = cameraGO.GetComponent<Camera>();
-            //camera.orthographic = true;
-            //camera.clearFlags = CameraClearFlags.SolidColor;
-            //camera.backgroundColor = Color.black;
-            //camera.cullingMask = LayerMask.NameToLayer("Minimap"); //only render minimap layer.
-            //oriantetaion
-            camera.transform.position = new UnityEngine.Vector3(0, cameraHeight, 0);
-            camera.transform.forward = UnityEngine.Vector3.down;
-            _resetCameraPos();
-
-            camera.transform.SetParent(this.transform);
-
-
-            //make the camera from prefab.
-            //sceneCamera = UnityEngine.Object.Instantiate(cameraPrefab, new Vector3(0, 0, 0), Quaternion.identity);
-
-            //make ortho camera 
-
-        }
-    }
-}

Assets/Raindrop/Unity3D/MapImageManager.cs

@@ -1,163 +0,0 @@
-using OpenMetaverse;
-using OpenMetaverse.Assets;
-using OpenMetaverse.Imaging;
-using Raindrop.Netcom;
-using System;
-using System.Collections.Generic;
-using UniRx;
-using Unity;
-using UnityEngine;
-using UnityEngine.UI;
-using Vector2 = UnityEngine.Vector2;
-using Vector3 = UnityEngine.Vector3;
-
-namespace Raindrop.Presenters
-{
-    //map texture module
-    // this manages the 2d texture objects in the map texture layer
-    //[RequireComponent(typeof(Image))]
-    public class MapImageManager:MonoBehaviour
-    {
-        //[SerializeField]
-        //private RawImage Image;        //the unity ui component
-        //private Texture2D map_tex;   //the unity engine texture.
-
-        //private Vector2Int mapCoord;
-
-        private Dictionary<Vector2Int, GameObject> map_collection;
-
-        private SimTexture st;
-
-        private OpenMetaverse.Vector2 viewableLow;
-        private OpenMetaverse.Vector2 viewableHigh;
-
-        private MapImageCameraPresenter cameraPresenter;
-
-        private RaindropInstance instance { get { return ServiceLocator.ServiceLocator.Instance.Get<RaindropInstance>(); } }
-        private RaindropNetcom netcom { get { return instance.Netcom; } }
-        private GridClient client { get { return instance.Client; } }
-
-
-        public GameObject Avatar;
-
-        public void Start()
-        {
-            //reset camera to a sane lcoation
-            //cameraPresenter.reset(); 
-            cameraPresenter = this.gameObject.AddComponent<MapImageCameraPresenter>();
-            cameraPresenter.init(); 
-
-            //set the camera to render to the intended render texture
-
-            instance.Client.Network.SimChanged += Network_OnCurrentSimChanged;
-
-        }
-
-        //x and y in OSL positions
-        public void lookAtGridPos(int x, int y)
-        {
-            cameraPresenter.setPos(x, y);
-
-        }
-
-        //public OpenMetaverse.Vector2 getLookAtGridPos()
-        //{
-        //    return cameraPresenter.gridPosition;
-        //}
-
-         
-
-        private void Network_OnCurrentSimChanged(object sender, SimChangedEventArgs e)
-        {
-
-            if (client.Network.Connected) return;
-
-            Debug.Log("Network_OnCurrentSimChanged");
-
-            GridRegion region;
-            if (client.Grid.GetGridRegion(client.Network.CurrentSim.Name, GridLayerType.Objects, out region))
-            {
-
-                Texture2D _new_MapLayer = null; // LOL! its unity texture btw.
-
-                UUID _MapImageID = region.MapImageID;
-                Vector2Int regionPos = new Vector2Int(region.X,region.Y);
-                ManagedImage nullImage;
-
-                Debug.Log("requesting map image.");
-
-                client.Assets.RequestImage(_MapImageID, ImageType.Baked,
-                    delegate (TextureRequestState state, AssetTexture asset)
-                    {
-                        if (state == TextureRequestState.Finished)
-                        {
-                            Debug.Log("minimap texture fetched, decoding it!");
-                            OpenJPEG.DecodeToImage(asset.AssetData, out nullImage, out _new_MapLayer); //this call interally calls to another function 'DecodeToImage(byte[] encoded, out ManagedImage managedImage)'
-
-                            UnityMainThreadDispatcher.Instance().Enqueue(() =>
-                            {
-                                SetMapLayer(_new_MapLayer, regionPos);
-                            });
-                        }
-                        else
-                            Debug.LogWarning("minimap failed to DL texture.");
-                    });
-            }
-
-        }
-
-        //sets a ,map block that is 256pic * 256pic
-        private void SetMapLayer(Texture2D new_texture, Vector2Int regionXY)
-        {
-            Debug.Log("setting the image to the new gameobject");
-            if (map_collection.ContainsKey(regionXY))
-            {
-                //update the region.
-                //MonoBehaviour theGO;
-                //map_collection.TryGetValue(regionXY, out theGO);
-
-                //Destroy(theGO.map_tex); //delete the tex2d that is no longer (?) used.
-            } else
-            {
-                GameObject mapGO = new GameObject();
-                mapGO.transform.SetParent(this.transform);
-
-                var MR = mapGO.AddComponent<MeshRenderer>();
-                MR.sharedMaterial = new UnityEngine.Material(Shader.Find("Standard"));
-                //MR.
-                var MF = mapGO.AddComponent<MeshFilter>();
-
-                //generate the plane.
-                Mesh m = new Mesh();
-                var width = 1;
-                var height = 1;
-                m.vertices = new Vector3[]{
-                                new Vector3(0, 0, 0),
-                                new Vector3(width, 0, 0),
-                                new Vector3(width, height, 0),
-                                new Vector3(0, height, 0)
-                };
-                m.uv = new Vector2[]{
-                    new Vector2(0, 0),
-                    new Vector2(0, 1),
-                    new Vector2(1, 1),
-                    new Vector2(1, 0),
-                };
-                m.triangles = new int[] { 0, 2, 1, 0, 3, 2 }; //clockwise?
-                MF.mesh = m;
-                m.RecalculateBounds();
-                m.RecalculateNormals();
-
-                MR.material.mainTexture = new_texture;
-
-                map_collection.Add(regionXY, mapGO);
-
-            }
-
-
-        }
-
-
-
-    }
-}

Assets/Raindrop/Unity3D/SimTexture.cs

@@ -1,6 +0,0 @@
-namespace Raindrop.Presenters
-{
-    internal class SimTexture
-    {
-    }
-}

Assets/Scenes/TGALoaderTest.unity

@@ -38,7 +38,7 @@ RenderSettings:
   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.44657826, g: 0.49641263, b: 0.57481676, a: 1}
+  m_IndirectSpecularColor: {r: 0.44657898, g: 0.4964133, b: 0.5748178, a: 1}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
@@ -153,6 +153,153 @@ Transform:
   m_Father: {fileID: 0}
   m_RootOrder: 4
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &544256932
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 544256933}
+  - component: {fileID: 544256936}
+  - component: {fileID: 544256935}
+  - component: {fileID: 544256934}
+  m_Layer: 5
+  m_Name: time2
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &544256933
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 544256932}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 2142188249}
+  m_RootOrder: 6
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: -645, y: -78}
+  m_SizeDelta: {x: 394.3123, y: 125.91}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &544256934
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 544256932}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 6105e38874b5073449c30ca3f57b4204, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+--- !u!114 &544256935
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 544256932}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_text: New Text
+  m_isRightToLeft: 0
+  m_fontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_sharedMaterial: {fileID: 2180264, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_fontSharedMaterials: []
+  m_fontMaterial: {fileID: 0}
+  m_fontMaterials: []
+  m_fontColor32:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_fontColor: {r: 1, g: 1, b: 1, a: 1}
+  m_enableVertexGradient: 0
+  m_colorMode: 3
+  m_fontColorGradient:
+    topLeft: {r: 1, g: 1, b: 1, a: 1}
+    topRight: {r: 1, g: 1, b: 1, a: 1}
+    bottomLeft: {r: 1, g: 1, b: 1, a: 1}
+    bottomRight: {r: 1, g: 1, b: 1, a: 1}
+  m_fontColorGradientPreset: {fileID: 0}
+  m_spriteAsset: {fileID: 0}
+  m_tintAllSprites: 0
+  m_StyleSheet: {fileID: 0}
+  m_TextStyleHashCode: -1183493901
+  m_overrideHtmlColors: 0
+  m_faceColor:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_fontSize: 48.64
+  m_fontSizeBase: 48.64
+  m_fontWeight: 400
+  m_enableAutoSizing: 0
+  m_fontSizeMin: 18
+  m_fontSizeMax: 72
+  m_fontStyle: 0
+  m_HorizontalAlignment: 1
+  m_VerticalAlignment: 256
+  m_textAlignment: 65535
+  m_characterSpacing: 0
+  m_wordSpacing: 0
+  m_lineSpacing: 0
+  m_lineSpacingMax: 0
+  m_paragraphSpacing: 0
+  m_charWidthMaxAdj: 0
+  m_enableWordWrapping: 1
+  m_wordWrappingRatios: 0.4
+  m_overflowMode: 0
+  m_linkedTextComponent: {fileID: 0}
+  parentLinkedComponent: {fileID: 0}
+  m_enableKerning: 1
+  m_enableExtraPadding: 0
+  checkPaddingRequired: 0
+  m_isRichText: 1
+  m_parseCtrlCharacters: 1
+  m_isOrthographic: 1
+  m_isCullingEnabled: 0
+  m_horizontalMapping: 0
+  m_verticalMapping: 0
+  m_uvLineOffset: 0
+  m_geometrySortingOrder: 0
+  m_IsTextObjectScaleStatic: 0
+  m_VertexBufferAutoSizeReduction: 0
+  m_useMaxVisibleDescender: 1
+  m_pageToDisplay: 1
+  m_margin: {x: 0, y: 0, z: 0, w: 0}
+  m_isUsingLegacyAnimationComponent: 0
+  m_isVolumetricText: 0
+  m_hasFontAssetChanged: 0
+  m_baseMaterial: {fileID: 0}
+  m_maskOffset: {x: 0, y: 0, z: 0, w: 0}
+--- !u!222 &544256936
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 544256932}
+  m_CullTransparentMesh: 1
 --- !u!1 &616826257
 GameObject:
   m_ObjectHideFlags: 0
@@ -1289,6 +1436,153 @@ CanvasRenderer:
   m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 1546686509}
   m_CullTransparentMesh: 1
+--- !u!1 &1612631376
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1612631377}
+  - component: {fileID: 1612631380}
+  - component: {fileID: 1612631379}
+  - component: {fileID: 1612631378}
+  m_Layer: 5
+  m_Name: time1
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &1612631377
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1612631376}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 2142188249}
+  m_RootOrder: 5
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_AnchorMin: {x: 0.5, y: 0.5}
+  m_AnchorMax: {x: 0.5, y: 0.5}
+  m_AnchoredPosition: {x: -645, y: 134}
+  m_SizeDelta: {x: 394.3123, y: 125.91}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &1612631378
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1612631376}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 6105e38874b5073449c30ca3f57b4204, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+--- !u!114 &1612631379
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1612631376}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f4688fdb7df04437aeb418b961361dc5, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_RaycastPadding: {x: 0, y: 0, z: 0, w: 0}
+  m_Maskable: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+  m_text: New Text
+  m_isRightToLeft: 0
+  m_fontAsset: {fileID: 11400000, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_sharedMaterial: {fileID: 2180264, guid: 8f586378b4e144a9851e7b34d9b748ee, type: 2}
+  m_fontSharedMaterials: []
+  m_fontMaterial: {fileID: 0}
+  m_fontMaterials: []
+  m_fontColor32:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_fontColor: {r: 1, g: 1, b: 1, a: 1}
+  m_enableVertexGradient: 0
+  m_colorMode: 3
+  m_fontColorGradient:
+    topLeft: {r: 1, g: 1, b: 1, a: 1}
+    topRight: {r: 1, g: 1, b: 1, a: 1}
+    bottomLeft: {r: 1, g: 1, b: 1, a: 1}
+    bottomRight: {r: 1, g: 1, b: 1, a: 1}
+  m_fontColorGradientPreset: {fileID: 0}
+  m_spriteAsset: {fileID: 0}
+  m_tintAllSprites: 0
+  m_StyleSheet: {fileID: 0}
+  m_TextStyleHashCode: -1183493901
+  m_overrideHtmlColors: 0
+  m_faceColor:
+    serializedVersion: 2
+    rgba: 4294967295
+  m_fontSize: 48.64
+  m_fontSizeBase: 48.64
+  m_fontWeight: 400
+  m_enableAutoSizing: 0
+  m_fontSizeMin: 18
+  m_fontSizeMax: 72
+  m_fontStyle: 0
+  m_HorizontalAlignment: 1
+  m_VerticalAlignment: 256
+  m_textAlignment: 65535
+  m_characterSpacing: 0
+  m_wordSpacing: 0
+  m_lineSpacing: 0
+  m_lineSpacingMax: 0
+  m_paragraphSpacing: 0
+  m_charWidthMaxAdj: 0
+  m_enableWordWrapping: 1
+  m_wordWrappingRatios: 0.4
+  m_overflowMode: 0
+  m_linkedTextComponent: {fileID: 0}
+  parentLinkedComponent: {fileID: 0}
+  m_enableKerning: 1
+  m_enableExtraPadding: 0
+  checkPaddingRequired: 0
+  m_isRichText: 1
+  m_parseCtrlCharacters: 1
+  m_isOrthographic: 1
+  m_isCullingEnabled: 0
+  m_horizontalMapping: 0
+  m_verticalMapping: 0
+  m_uvLineOffset: 0
+  m_geometrySortingOrder: 0
+  m_IsTextObjectScaleStatic: 0
+  m_VertexBufferAutoSizeReduction: 0
+  m_useMaxVisibleDescender: 1
+  m_pageToDisplay: 1
+  m_margin: {x: 0, y: 0, z: 0, w: 0}
+  m_isUsingLegacyAnimationComponent: 0
+  m_isVolumetricText: 0
+  m_hasFontAssetChanged: 0
+  m_baseMaterial: {fileID: 0}
+  m_maskOffset: {x: 0, y: 0, z: 0, w: 0}
+--- !u!222 &1612631380
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1612631376}
+  m_CullTransparentMesh: 1
 --- !u!1 &1815988572
 GameObject:
   m_ObjectHideFlags: 0
@@ -1487,6 +1781,8 @@ RectTransform:
   - {fileID: 1815988573}
   - {fileID: 1135645758}
   - {fileID: 1052896851}
+  - {fileID: 1612631377}
+  - {fileID: 544256933}
   m_Father: {fileID: 974969038}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
@@ -1509,7 +1805,9 @@ MonoBehaviour:
   m_EditorClassIdentifier: 
   pathToTGAFolder: openmetaverse_data
   rawImageGO: {fileID: 926232951}
-  textGO: {fileID: 1135645757}
+  textPathGO: {fileID: 1135645757}
+  texttime1GO: {fileID: 1612631376}
+  texttime2GO: {fileID: 544256932}
   filesInStreamingAssets: []
   currentFileIndex: 0
 --- !u!114 &2142188251

Assets/Scenes/UI/GamePnl.prefab

@@ -372,7 +372,7 @@ GameObject:
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 0
+  m_IsActive: 1
 --- !u!224 &746450086375120214
 RectTransform:
   m_ObjectHideFlags: 0

Assets/Scenes/UI/UIscene.unity

@@ -38,7 +38,7 @@ RenderSettings:
   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.37311918, g: 0.3807398, b: 0.35872716, a: 1}
+  m_IndirectSpecularColor: {r: 0.37311953, g: 0.38074014, b: 0.3587274, a: 1}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
@@ -237,10 +237,10 @@ RectTransform:
   m_Father: {fileID: 892152801}
   m_RootOrder: 1
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 0}
-  m_AnchoredPosition: {x: 839.2689, y: -96.44946}
+  m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: 1638.5378, y: 152.89893}
+  m_SizeDelta: {x: 0, y: 0}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &49835070
 MonoBehaviour:
@@ -510,7 +510,7 @@ RectTransform:
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 1, y: 1}
+  m_AnchorMax: {x: 0, y: 0}
   m_AnchoredPosition: {x: 0, y: 0}
   m_SizeDelta: {x: 20, y: 20}
   m_Pivot: {x: 0.5, y: 0.5}
@@ -758,10 +758,10 @@ RectTransform:
   m_Father: {fileID: 403228334}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 0}
-  m_AnchoredPosition: {x: 819.2689, y: -276.9932}
+  m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: 1598.5378, y: 513.9864}
+  m_SizeDelta: {x: 0, y: 0}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &337535311
 MonoBehaviour:
@@ -886,9 +886,9 @@ RectTransform:
   m_RootOrder: 2
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 1, y: 0}
-  m_AnchorMax: {x: 1, y: 1}
+  m_AnchorMax: {x: 1, y: 0}
   m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: 20, y: -17}
+  m_SizeDelta: {x: 20, y: 0}
   m_Pivot: {x: 1, y: 1}
 --- !u!114 &349949370
 MonoBehaviour:
@@ -933,8 +933,8 @@ MonoBehaviour:
   m_TargetGraphic: {fileID: 1245426832}
   m_HandleRect: {fileID: 1245426831}
   m_Direction: 2
-  m_Value: 0.42614174
+  m_Value: 0.4460357
-  m_Size: 0.22026287
+  m_Size: 0.19226104
   m_NumberOfSteps: 0
   m_OnValueChanged:
     m_PersistentCalls:
@@ -1094,13 +1094,12 @@ MonoBehaviour:
   m_GameObject: {fileID: 367179950}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 3aa7a5a5fc2f14a4da5a09383ddb6712, type: 3}
+  m_Script: {fileID: 11500000, guid: 17ba502de0318504394f00ba4d1e3af2, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  genericModalPresenter: {fileID: 0}
+  eulaModal: {fileID: 0}
-  eulaModal: {fileID: 892152805}
+  loggingInStatusModal: {fileID: 0}
-  loggingInStatusModal: {fileID: 1542315699}
+  GenericModalPrefab: {fileID: 0}
-  GenericModalPrefab: {fileID: 5679691462565561898, guid: 9a2ef4f42b30e66428e2f77ec82b1614, type: 3}
 --- !u!1 &394034789
 GameObject:
   m_ObjectHideFlags: 0
@@ -1220,10 +1219,10 @@ RectTransform:
   m_Father: {fileID: 892152801}
   m_RootOrder: 2
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 0}
-  m_AnchoredPosition: {x: 839.2689, y: -509.89212}
+  m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: 1638.5378, y: 673.9864}
+  m_SizeDelta: {x: 0, y: 0}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &403228335
 MonoBehaviour:
@@ -1748,6 +1747,30 @@ PrefabInstance:
   m_Modification:
     m_TransformParent: {fileID: 904771131}
     m_Modifications:
+    - target: {fileID: 361051093761253961, guid: b48e30ed103c4324a9e537dd82576993, type: 3}
+      propertyPath: onClick.m_PersistentCalls.m_Calls.Array.data[0].m_Mode
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 361051093761253961, guid: b48e30ed103c4324a9e537dd82576993, type: 3}
+      propertyPath: onClick.m_PersistentCalls.m_Calls.Array.data[0].m_Target
+      value: 
+      objectReference: {fileID: 904771132}
+    - target: {fileID: 361051093761253961, guid: b48e30ed103c4324a9e537dd82576993, type: 3}
+      propertyPath: onClick.m_PersistentCalls.m_Calls.Array.data[1].m_Target
+      value: 
+      objectReference: {fileID: 904771132}
+    - target: {fileID: 361051093761253961, guid: b48e30ed103c4324a9e537dd82576993, type: 3}
+      propertyPath: onClick.m_PersistentCalls.m_Calls.Array.data[0].m_MethodName
+      value: popCanvas
+      objectReference: {fileID: 0}
+    - target: {fileID: 361051093761253961, guid: b48e30ed103c4324a9e537dd82576993, type: 3}
+      propertyPath: onClick.m_PersistentCalls.m_Calls.Array.data[1].m_MethodName
+      value: pushCanvas
+      objectReference: {fileID: 0}
+    - target: {fileID: 361051093761253961, guid: b48e30ed103c4324a9e537dd82576993, type: 3}
+      propertyPath: onClick.m_PersistentCalls.m_Calls.Array.data[0].m_Arguments.m_StringArgument
+      value: Login
+      objectReference: {fileID: 0}
     - target: {fileID: 361051093936432735, guid: b48e30ed103c4324a9e537dd82576993, type: 3}
       propertyPath: m_AnchorMax.y
       value: 0
@@ -1764,6 +1787,14 @@ PrefabInstance:
       propertyPath: m_AnchoredPosition.y
       value: 0
       objectReference: {fileID: 0}
+    - target: {fileID: 361051094640251304, guid: b48e30ed103c4324a9e537dd82576993, type: 3}
+      propertyPath: onClick.m_PersistentCalls.m_Calls.Array.data[0].m_Target
+      value: 
+      objectReference: {fileID: 367179950}
+    - target: {fileID: 361051094640251304, guid: b48e30ed103c4324a9e537dd82576993, type: 3}
+      propertyPath: onClick.m_PersistentCalls.m_Calls.Array.data[0].m_MethodName
+      value: 
+      objectReference: {fileID: 0}
     - target: {fileID: 361051095339570462, guid: b48e30ed103c4324a9e537dd82576993, type: 3}
       propertyPath: m_Pivot.x
       value: 0.5
@@ -1910,8 +1941,8 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 818.1792, y: -20}
+  m_AnchoredPosition: {x: 878.15027, y: -20}
-  m_SizeDelta: {x: 1596.3584, y: 0}
+  m_SizeDelta: {x: 1716.3005, y: 0}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &775592848
 MonoBehaviour:
@@ -2103,10 +2134,10 @@ RectTransform:
   m_Father: {fileID: 892152801}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 0}
-  m_AnchoredPosition: {x: 839.2689, y: -20}
+  m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: 1638.5378, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &865909122
 MonoBehaviour:
@@ -2295,7 +2326,7 @@ GameObject:
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 0
+  m_IsActive: 1
 --- !u!224 &892152801
 RectTransform:
   m_ObjectHideFlags: 0
@@ -2884,8 +2915,8 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 798.1792, y: -571.9049}
+  m_AnchoredPosition: {x: 858.15027, y: -511.15356}
-  m_SizeDelta: {x: 1556.3584, y: 164.15239}
+  m_SizeDelta: {x: 1676.3005, y: 159.29228}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &939971690
 MonoBehaviour:
@@ -3141,7 +3172,7 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 389.0896, y: -82.076195}
+  m_AnchoredPosition: {x: 419.07513, y: -79.64614}
   m_SizeDelta: {x: 500, y: 125}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &1049033201
@@ -3526,8 +3557,8 @@ RectTransform:
   m_Father: {fileID: 151857395}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 0.33227858}
+  m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 1, y: 0.55254143}
+  m_AnchorMax: {x: 0, y: 0}
   m_AnchoredPosition: {x: 0, y: 0}
   m_SizeDelta: {x: 20, y: 20}
   m_Pivot: {x: 0.5, y: 0.5}
@@ -3638,10 +3669,10 @@ RectTransform:
   m_Father: {fileID: 2114563880}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 0}
-  m_AnchoredPosition: {x: 1582.3718, y: -1128.1665}
+  m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: 1582.3718, y: 1128.1665}
+  m_SizeDelta: {x: 1582.3718, y: 0}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &1253076628
 MonoBehaviour:
@@ -4053,10 +4084,10 @@ RectTransform:
   m_Father: {fileID: 403228334}
   m_RootOrder: 1
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 1}
+  m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 0, y: 1}
+  m_AnchorMax: {x: 0, y: 0}
-  m_AnchoredPosition: {x: 819.2689, y: -593.9864}
+  m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: 1598.5378, y: 120}
+  m_SizeDelta: {x: 0, y: 0}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &1344033181
 MonoBehaviour:
@@ -4321,9 +4352,9 @@ RectTransform:
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 1, y: 1}
+  m_AnchorMax: {x: 0, y: 0}
   m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: -17, y: -17}
+  m_SizeDelta: {x: 0, y: 0}
   m_Pivot: {x: 0, y: 1}
 --- !u!114 &1413528313
 MonoBehaviour:
@@ -4693,8 +4724,8 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 798.1792, y: -254.91435}
+  m_AnchoredPosition: {x: 858.15027, y: -225.75371}
-  m_SizeDelta: {x: 1556.3584, y: 469.8287}
+  m_SizeDelta: {x: 1676.3005, y: 411.50742}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &1540897338
 MonoBehaviour:
@@ -4880,6 +4911,7 @@ GameObject:
   m_Component:
   - component: {fileID: 1542315698}
   - component: {fileID: 1542315699}
+  - component: {fileID: 1542315700}
   m_Layer: 5
   m_Name: Modal
   m_TagString: Untagged
@@ -4926,6 +4958,24 @@ MonoBehaviour:
   modal: {fileID: 1542315697}
   CloseButton: {fileID: 1418630377}
   BackgroundButton: {fileID: 2046282083}
+--- !u!114 &1542315700
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1542315697}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 062fe3ce8e16c8e44a64b704ea6ff397, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  titletext: {fileID: 0}
+  contenttext: {fileID: 0}
+  actionText: {fileID: 0}
+  modal: {fileID: 0}
+  CloseButton: {fileID: 0}
+  BackgroundButton: {fileID: 0}
 --- !u!1 &1577540112
 GameObject:
   m_ObjectHideFlags: 0
@@ -4988,7 +5038,7 @@ RectTransform:
   m_Father: {fileID: 2006338897}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_AnchorMin: {x: 0, y: 0.7993077}
+  m_AnchorMin: {x: 0, y: 0.8251555}
   m_AnchorMax: {x: 1, y: 1}
   m_AnchoredPosition: {x: 0, y: 0}
   m_SizeDelta: {x: 20, y: 20}
@@ -5068,8 +5118,8 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 818.1792, y: -96.44945}
+  m_AnchoredPosition: {x: 878.15027, y: -96.2899}
-  m_SizeDelta: {x: 1596.3584, y: 152.8989}
+  m_SizeDelta: {x: 1716.3005, y: 152.5798}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &1641462276
 MonoBehaviour:
@@ -5436,9 +5486,9 @@ RectTransform:
   m_RootOrder: 1
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 0}
-  m_AnchorMax: {x: 1, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
   m_AnchoredPosition: {x: 0, y: 0}
-  m_SizeDelta: {x: -17, y: 20}
+  m_SizeDelta: {x: 0, y: 20}
   m_Pivot: {x: 0, y: 0}
 --- !u!114 &1705436871
 MonoBehaviour:
@@ -6304,8 +6354,8 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 818.1792, y: -509.88943}
+  m_AnchoredPosition: {x: 878.15027, y: -477.97964}
-  m_SizeDelta: {x: 1596.3584, y: 673.9811}
+  m_SizeDelta: {x: 1716.3005, y: 610.7997}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &2015226333
 MonoBehaviour:
@@ -6688,7 +6738,7 @@ MonoBehaviour:
   m_HandleRect: {fileID: 1586289128}
   m_Direction: 2
   m_Value: 1
-  m_Size: 0.20069233
+  m_Size: 0.1748445
   m_NumberOfSteps: 0
   m_OnValueChanged:
     m_PersistentCalls:
@@ -6767,7 +6817,7 @@ RectTransform:
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
-  m_AnchoredPosition: {x: 1167.2688, y: -82.076195}
+  m_AnchoredPosition: {x: 1257.2253, y: -79.64614}
   m_SizeDelta: {x: 500, y: 125}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &2026891405

Assets/icons/drop-of-liquid2.png.meta

@@ -32,12 +32,12 @@ TextureImporter:
   maxTextureSize: 2048
   textureSettings:
     serializedVersion: 2
-    filterMode: -1
+    filterMode: 1
-    aniso: -1
+    aniso: 1
-    mipBias: -100
+    mipBias: 0
     wrapU: 1
     wrapV: 1
-    wrapW: -1
+    wrapW: 0
   nPOTScale: 0
   lightmap: 0
   compressionQuality: 50
@@ -49,7 +49,7 @@ TextureImporter:
   spritePixelsToUnits: 100
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spriteGenerateFallbackPhysicsShape: 1
-  alphaUsage: 0
+  alphaUsage: 1
   alphaIsTransparency: 1
   spriteTessellationDetail: -1
   textureType: 8

ProjectSettings/EditorBuildSettings.asset

@@ -5,18 +5,18 @@ EditorBuildSettings:
   m_ObjectHideFlags: 0
   serializedVersion: 2
   m_Scenes:
-  - enabled: 0
-    path: Assets/Scenes/mainBootstrapScene.unity
-    guid: a9f35cb3e179fef4389cf769af057e55
-  - enabled: 0
-    path: Assets/Scenes/UI/UIscene.unity
-    guid: a72b6cd7ea683e5459da82491579217e
-  - enabled: 0
-    path: Assets/Scenes/3Dscene.unity
-    guid: e4b15a01227c10445b0a25ca88394bb4
   - enabled: 1
     path: Assets/Scenes/TGALoaderTest.unity
     guid: 6dda257986255e74db736b4c0567afd2
+  - enabled: 1
+    path: Assets/Scenes/mainBootstrapScene.unity
+    guid: a9f35cb3e179fef4389cf769af057e55
+  - enabled: 1
+    path: Assets/Scenes/UI/UIscene.unity
+    guid: a72b6cd7ea683e5459da82491579217e
+  - enabled: 1
+    path: Assets/Scenes/3Dscene.unity
+    guid: e4b15a01227c10445b0a25ca88394bb4
   - enabled: 0
     path: Assets/Plugins/BetterStreamingAssets/BSA_TestScene.unity
     guid: 2bef88fd675ce3f4fa61ff5f18aa8242

ProjectSettings/ProjectVersion.txt

@@ -1,2 +1,2 @@
-m_EditorVersion: 2020.3.6f1
+m_EditorVersion: 2020.3.8f1
-m_EditorVersionWithRevision: 2020.3.6f1 (338bb68529b2)
+m_EditorVersionWithRevision: 2020.3.8f1 (507919d4fff5)