20240422

Unity/MeshGeneration/Factories/AbstractTileFactory.cs

@@ -0,0 +1,132 @@
+namespace Mapbox.Unity.MeshGeneration.Factories
+{
+	using Mapbox.Platform;
+	using Mapbox.Unity.MeshGeneration.Data;
+	using System;
+	using UnityEngine;
+	using Mapbox.Unity.Map;
+	using Mapbox.Map;
+	using System.Collections.Generic;
+
+	/// <summary>
+	/// Factories
+	/// Factories corresponds to Mapbox Api endpoints for the most part.Terrain factory uses terrain rgb api,
+	/// Image factory uses raster image api and vector tile factory uses vector data api.
+	/// Only exception to this at the moment is Directions factory, which is a monobehaviour in Drive demo scene
+	/// but we’ll probably rework that in the future as well.
+	/// Factories do the api calls.They are responsible for reporting progress and logging/reporting any network issue.
+	/// They can also keep track of tiles if necessary (i.e.update/refresh data after initial creation)
+	/// Factories processes the received data in different ways.
+	/// Terrain factories creates the mesh from the received data (or a flat terrain depending the settings)
+	/// MapImage factory applies received image to tile game object.
+	/// Vector Tile Factory deals with a much more complex and detailed data compared to other two so it doesn’t do the
+	/// whole processing itself and uses some subclasses (LayerVisualizers) to do it.
+	/// Creating a custom factory is a good idea if you want to fetch raw data and process is in a totally different
+	/// custom way, like creating terrain and then cut off water areas from terrain mesh.
+	/// Vector Tile factory, for example, is built to be flexible and work with multiple vector layers. But if you
+	/// don’t need that all, you can create a custom version of it and process what you need in a much more concrete
+	/// and performant way.
+	/// Another example here would be custom terrain mesh. Current terrain factories work with a custom sized grid
+	/// and apply height data on that. By creating a custom terrain factory, you can have a custom mesh instead of a grid,
+	/// optimize and minimize vertex count etc.
+	/// </summary>
+	public abstract class AbstractTileFactory : ScriptableObject
+	{
+		protected IFileSource _fileSource;
+
+		protected LayerProperties _options;
+
+		public LayerProperties Options
+		{
+			get { return _options; }
+		}
+
+		protected HashSet<UnityTile> _tilesWaitingResponse;
+		protected HashSet<UnityTile> _tilesWaitingProcessing;
+
+		public virtual void SetOptions(LayerProperties options)
+		{
+			_options = options;
+		}
+
+		protected virtual void OnErrorOccurred(UnityTile tile, TileErrorEventArgs e)
+		{
+			EventHandler<TileErrorEventArgs> handler = OnTileError;
+			if (handler != null)
+			{
+				handler(this, e);
+			}
+		}
+
+		public virtual void Initialize(IFileSource fileSource)
+		{
+			_fileSource = fileSource;
+			_tilesWaitingResponse = new HashSet<UnityTile>();
+			_tilesWaitingProcessing = new HashSet<UnityTile>();
+			OnInitialized();
+		}
+
+		public virtual void Register(UnityTile tile)
+		{
+			OnRegistered(tile);
+		}
+
+		public virtual void PostProcess(UnityTile tile)
+		{
+			OnPostProcess(tile);
+		}
+		public virtual void Unregister(UnityTile tile)
+		{
+			OnUnregistered(tile);
+		}
+
+		public virtual void UnbindEvents()
+		{
+			OnUnbindEvents();
+		}
+
+		public virtual void UpdateTileProperty(UnityTile tile, LayerUpdateArgs updateArgs)
+		{
+			updateArgs.property.UpdateProperty(tile);
+
+			if (updateArgs.property.NeedsForceUpdate())
+			{
+				Register(tile);
+			}
+		}
+
+		protected abstract void OnInitialized();
+
+		protected abstract void OnRegistered(UnityTile tile);
+		protected abstract void OnPostProcess(UnityTile tile);
+		protected abstract void OnUnregistered(UnityTile tile);
+		protected abstract void OnUnbindEvents();
+
+		#region Events
+		public event EventHandler<TileErrorEventArgs> OnTileError;
+		protected virtual void OnErrorOccurred(TileErrorEventArgs e)
+		{
+			EventHandler<TileErrorEventArgs> handler = OnTileError;
+			if (handler != null)
+			{
+				handler(this, e);
+			}
+		}
+
+		public event EventHandler TileFactoryHasChanged;
+		protected virtual void UpdateTileFactory(object sender, System.EventArgs args)
+		{
+			System.EventHandler handler = TileFactoryHasChanged;
+			if (handler != null)
+			{
+				handler(this, args);
+			}
+		}
+		#endregion
+
+		public virtual void Clear()
+		{
+
+		}
+	}
+}