+1.57

1 files changed, 333 insertions, 0 deletions

diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshFusionSource.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshFusionSource.cs
new file mode 100644
index 0000000..555f9e8
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshFusionSource.cs
@@ -0,0 +1,333 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+[DisallowMultipleComponent]
+public abstract class MeshFusionSource : MonoBehaviour
+{
+	private RuntimeMeshFusion _controller;
+
+	private int _combinedSourcesCount;
+
+	private int _failedSourcesCount;
+
+	private int _totalSourcesCount;
+
+	[field: SerializeField]
+	public SourceCombineStatus CombineStatus { get; private set; }
+
+	[field: SerializeField]
+	public int ControllerIndex { get; set; }
+
+	[field: SerializeField]
+	[field: HideInInspector]
+	public bool CombineAtStart { get; set; } = true;
+
+
+	[field: SerializeField]
+	[field: HideInInspector]
+	public CombineErrorStrategy CombineErrorStrategy { get; set; }
+
+	[field: SerializeField]
+	public AfterCombineAction AfterCombineAction { get; set; }
+
+	[field: SerializeField]
+	public bool IsIncompatible { get; private set; }
+
+	[field: SerializeField]
+	public string IncompatibilityReason { get; private set; }
+
+	[field: SerializeField]
+	public bool HasCombineErrors { get; private set; }
+
+	[field: SerializeField]
+	public string CombineErrors { get; private set; }
+
+	public event Action<MeshFusionSource, IEnumerable<ICombinedObjectPart>> onCombineFinished;
+
+	private void Reset()
+	{
+		CheckCompatibility();
+	}
+
+	private void Start()
+	{
+		if (CombineAtStart)
+		{
+			AssignToController();
+		}
+	}
+
+	private void OnDestroy()
+	{
+		Unfreeze();
+	}
+
+	public void Unfreeze()
+	{
+		if (CombineStatus == SourceCombineStatus.AssignedToController)
+		{
+			UnassignFromController();
+		}
+		ClearSourcesAndUnsubscribe();
+	}
+
+	public abstract bool TryGetBounds(ref Bounds bounds);
+
+	public bool CheckCompatibility()
+	{
+		try
+		{
+			string incompatibilityReason;
+			bool flag = CheckCompatibilityAndGetComponents(out incompatibilityReason);
+			IsIncompatible = !flag;
+			IncompatibilityReason = incompatibilityReason;
+			return flag;
+		}
+		catch (Exception ex)
+		{
+			IsIncompatible = true;
+			IncompatibilityReason += $"\n{ex.Message}{ex.StackTrace}";
+			return false;
+		}
+	}
+
+	public bool AssignToController()
+	{
+		try
+		{
+			if (CombineStatus != 0)
+			{
+				return false;
+			}
+			if (!CheckCompatibility())
+			{
+				return false;
+			}
+			_controller = RuntimeMeshFusion.FindByIndex(ControllerIndex);
+			if (_controller == null)
+			{
+				throw new NullReferenceException("RuntimeMeshFusion with index " + ControllerIndex + " not found");
+			}
+			CreateSourcesAndSubscribe();
+			HasCombineErrors = false;
+			CombineErrors = "";
+			_combinedSourcesCount = 0;
+			_failedSourcesCount = 0;
+			_totalSourcesCount = 0;
+			foreach (ICombineSource combineSource in GetCombineSources())
+			{
+				_totalSourcesCount++;
+				_controller.AddSource(combineSource);
+			}
+			CombineStatus = SourceCombineStatus.AssignedToController;
+			return true;
+		}
+		catch (Exception ex)
+		{
+			HasCombineErrors = true;
+			CombineErrors += $"\n{ex.Message}\n{ex.StackTrace}";
+			UnassignFromController();
+			CombineStatus = SourceCombineStatus.FailedToCombine;
+			return false;
+		}
+	}
+
+	public void UndoCombine()
+	{
+		try
+		{
+			foreach (ICombinedObjectPart combinedPart in GetCombinedParts())
+			{
+				combinedPart.Destroy();
+			}
+			foreach (ICombineSource combineSource in GetCombineSources())
+			{
+				combineSource.onCombined += delegate(ICombinedObject root, ICombinedObjectPart part)
+				{
+					part.Destroy();
+				};
+			}
+			UnassignFromController();
+			ClearSourcesAndUnsubscribe();
+			ClearParts();
+			_combinedSourcesCount = 0;
+			_failedSourcesCount = 0;
+			ToggleComponents(enabled: true);
+			CombineStatus = SourceCombineStatus.NotCombined;
+		}
+		catch (Exception ex)
+		{
+			HasCombineErrors = true;
+			CombineErrors += $"\n{ex.Message}\n{ex.StackTrace}";
+			CombineStatus = SourceCombineStatus.FailedToCombine;
+		}
+	}
+
+	private void CreateSourcesAndSubscribe()
+	{
+		CreateSources();
+		foreach (ICombineSource combineSource in GetCombineSources())
+		{
+			combineSource.onCombined += OnSourceCombinedHandler;
+			combineSource.onCombineError += OnCombineErrorHandler;
+			combineSource.onCombineFailed += OnFailedCombineSourceHandler;
+		}
+	}
+
+	private void ClearSourcesAndUnsubscribe()
+	{
+		foreach (ICombineSource combineSource in GetCombineSources())
+		{
+			combineSource.onCombined -= OnSourceCombinedHandler;
+			combineSource.onCombineError -= OnCombineErrorHandler;
+			combineSource.onCombineFailed -= OnFailedCombineSourceHandler;
+		}
+		ClearSources();
+	}
+
+	private void UnassignFromController()
+	{
+		if (_controller != null)
+		{
+			foreach (ICombineSource combineSource in GetCombineSources())
+			{
+				_controller.RemoveSource(combineSource);
+			}
+		}
+		_controller = null;
+	}
+
+	private void OnSourceCombinedHandler(ICombinedObject root, ICombinedObjectPart part)
+	{
+		CombineStatus = SourceCombineStatus.CombinedPartially;
+		_combinedSourcesCount++;
+		OnSourceCombinedInternal(root, part);
+		if (_combinedSourcesCount + _failedSourcesCount == _totalSourcesCount)
+		{
+			OnCombineFinishedHandler();
+		}
+	}
+
+	private void OnCombineErrorHandler(ICombinedObject root, string errorMessage)
+	{
+		HasCombineErrors = true;
+		CombineErrors = CombineErrors + errorMessage + "\n";
+		OnCombineErrorInternal(root, errorMessage);
+		if (CombineErrorStrategy == CombineErrorStrategy.UndoCombining)
+		{
+			UndoCombine();
+		}
+	}
+
+	private void OnFailedCombineSourceHandler(ICombinedObject root)
+	{
+		_failedSourcesCount++;
+		OnFailedCombineSourceInternal(root);
+		if (_combinedSourcesCount + _failedSourcesCount == _totalSourcesCount)
+		{
+			OnCombineFinishedHandler();
+		}
+	}
+
+	private void OnCombineFinishedHandler()
+	{
+		ClearSourcesAndUnsubscribe();
+		if (_combinedSourcesCount == _totalSourcesCount)
+		{
+			CombineStatus = SourceCombineStatus.Combined;
+		}
+		else if (_failedSourcesCount == _totalSourcesCount)
+		{
+			CombineStatus = SourceCombineStatus.FailedToCombine;
+			return;
+		}
+		OnCombineFinishedInternal();
+		this.onCombineFinished?.Invoke(this, GetCombinedParts());
+		if (AfterCombineAction == AfterCombineAction.DisableComponents)
+		{
+			ToggleComponents(enabled: false);
+		}
+		else if (AfterCombineAction == AfterCombineAction.DestroyGameObject)
+		{
+			UnityEngine.Object.Destroy(base.gameObject);
+		}
+	}
+
+	protected virtual void OnSourceCombinedInternal(ICombinedObject root, ICombinedObjectPart part)
+	{
+	}
+
+	protected virtual void OnCombineErrorInternal(ICombinedObject root, string errorMessage)
+	{
+	}
+
+	protected virtual void OnFailedCombineSourceInternal(ICombinedObject root)
+	{
+	}
+
+	protected virtual void OnCombineFinishedInternal()
+	{
+	}
+
+	protected bool CanCreateCombineSource(GameObject go, ref string incompatibilityReason, ref MeshRenderer renderer, ref MeshFilter filter, ref Mesh mesh)
+	{
+		if (renderer == null)
+		{
+			renderer = go.GetComponent<MeshRenderer>();
+		}
+		if (renderer == null)
+		{
+			incompatibilityReason = "MeshRenderer not found";
+			return false;
+		}
+		if (renderer.isPartOfStaticBatch)
+		{
+			incompatibilityReason = "MeshRenderer is PartOfStaticBatching\nDisable Static Batching";
+			return false;
+		}
+		if (filter == null)
+		{
+			filter = go.GetComponent<MeshFilter>();
+		}
+		if (filter == null)
+		{
+			incompatibilityReason = "MeshFilter not found";
+			return false;
+		}
+		mesh = filter.sharedMesh;
+		if (mesh == null)
+		{
+			incompatibilityReason = "Mesh not found";
+			return false;
+		}
+		if (!mesh.isReadable)
+		{
+			incompatibilityReason = "Mesh is not readable. Enable Read/Write in import settings";
+			return false;
+		}
+		if (mesh.subMeshCount != renderer.sharedMaterials.Length)
+		{
+			incompatibilityReason = "Submesh count and Materials count isn't equal";
+			return false;
+		}
+		incompatibilityReason = "";
+		return true;
+	}
+
+	protected abstract bool CheckCompatibilityAndGetComponents(out string incompatibilityReason);
+
+	protected abstract void CreateSources();
+
+	protected abstract void ClearSources();
+
+	protected abstract void ClearParts();
+
+	protected abstract IEnumerable<ICombineSource> GetCombineSources();
+
+	protected abstract IEnumerable<ICombinedObjectPart> GetCombinedParts();
+
+	protected abstract void ToggleComponents(bool enabled);
+}