+1.57

84 files changed, 5323 insertions, 0 deletions

diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/AfterCombineAction.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/AfterCombineAction.cs
new file mode 100644
index 0000000..f586b15
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/AfterCombineAction.cs
@@ -0,0 +1,8 @@
+namespace NGS.MeshFusionPro;
+
+public enum AfterCombineAction
+{
+	DisableComponents,
+	DestroyGameObject,
+	DoNothing
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BinaryTree.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BinaryTree.cs
new file mode 100644
index 0000000..b7eddf1
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BinaryTree.cs
@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public abstract class BinaryTree<TNode, TData> where TNode : BinaryTreeNode<TData>
+{
+	private Dictionary<TData, List<TNode>> _dataToNodes;
+
+	public IBinaryTreeNode Root => RootInternal;
+
+	public int Height { get; private set; }
+
+	protected TNode RootInternal { get; private set; }
+
+	public BinaryTree()
+	{
+		Height = 0;
+		_dataToNodes = new Dictionary<TData, List<TNode>>();
+	}
+
+	public void Add(TData data)
+	{
+		if (Root == null)
+		{
+			RootInternal = CreateRoot(data);
+			Height = 1;
+		}
+		if (!Includes(RootInternal, data))
+		{
+			GrowTreeUp(data);
+		}
+		AddData(RootInternal, data, 1);
+	}
+
+	public bool Remove(TData data)
+	{
+		if (!_dataToNodes.TryGetValue(data, out var value))
+		{
+			return false;
+		}
+		foreach (TNode item in value)
+		{
+			item.Remove(data);
+		}
+		return _dataToNodes.Remove(data);
+	}
+
+	protected void GrowTreeUp(TData target)
+	{
+		if (!Includes(RootInternal, target))
+		{
+			RootInternal = ExpandRoot(RootInternal, target);
+			Height++;
+			GrowTreeUp(target);
+		}
+	}
+
+	protected void GrowTreeDown(TNode node, TData target, int depth)
+	{
+		if (node.HasChilds)
+		{
+			throw new Exception("GrowTreeDown::" + depth + " node already has childs");
+		}
+		Bounds bounds = node.Bounds;
+		Vector3 vector;
+		Vector3 size;
+		if (bounds.size.x > bounds.size.y || bounds.size.x > bounds.size.z)
+		{
+			vector = new Vector3(bounds.size.x / 4f, 0f, 0f);
+			size = new Vector3(bounds.size.x / 2f, bounds.size.y, bounds.size.z);
+		}
+		else if (bounds.size.y > bounds.size.x || bounds.size.y > bounds.size.z)
+		{
+			vector = new Vector3(0f, bounds.size.y / 4f, 0f);
+			size = new Vector3(bounds.size.x, bounds.size.y / 2f, bounds.size.z);
+		}
+		else
+		{
+			vector = new Vector3(0f, 0f, bounds.size.z / 4f);
+			size = new Vector3(bounds.size.x, bounds.size.y, bounds.size.z / 2f);
+		}
+		bool flag = depth == Height;
+		TNode val = CreateNode(bounds.center - vector, size, flag);
+		TNode val2 = CreateNode(bounds.center + vector, size, flag);
+		node.SetChilds(val, val2);
+		if (!flag)
+		{
+			if (Intersects(val, target))
+			{
+				GrowTreeDown(val, target, depth + 1);
+			}
+			if (Intersects(val2, target))
+			{
+				GrowTreeDown(val2, target, depth + 1);
+			}
+		}
+	}
+
+	protected void AddData(TNode node, TData data, int depth)
+	{
+		if (node.IsLeaf)
+		{
+			node.Add(data);
+			if (!_dataToNodes.TryGetValue(data, out var value))
+			{
+				value = new List<TNode>();
+				_dataToNodes.Add(data, value);
+			}
+			if (!value.Contains(node))
+			{
+				value.Add(node);
+			}
+			return;
+		}
+		if (!node.HasChilds)
+		{
+			GrowTreeDown(node, data, depth + 1);
+		}
+		TNode node2 = (TNode)node.Left;
+		TNode node3 = (TNode)node.Right;
+		if (Intersects(node2, data))
+		{
+			AddData(node2, data, depth + 1);
+		}
+		if (Intersects(node3, data))
+		{
+			AddData(node3, data, depth + 1);
+		}
+	}
+
+	protected void TreeTraversal(Func<TNode, int, bool> func)
+	{
+		TreeTraversal(RootInternal, 1, func);
+	}
+
+	protected void TreeTraversal(TNode current, int depth, Func<TNode, int, bool> func)
+	{
+		if (func(current, depth) && current.HasChilds)
+		{
+			TreeTraversal((TNode)current.Left, depth + 1, func);
+			TreeTraversal((TNode)current.Right, depth + 1, func);
+		}
+	}
+
+	protected abstract TNode CreateRoot(TData data);
+
+	protected abstract TNode ExpandRoot(TNode root, TData target);
+
+	protected abstract TNode CreateNode(Vector3 center, Vector3 size, bool isLeaf);
+
+	protected abstract bool Intersects(TNode node, TData data);
+
+	protected abstract bool Includes(TNode node, TData data);
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BinaryTreeDrawer.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BinaryTreeDrawer.cs
new file mode 100644
index 0000000..87776a2
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BinaryTreeDrawer.cs
@@ -0,0 +1,22 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class BinaryTreeDrawer<TData>
+{
+	public void DrawGizmo(IBinaryTreeNode root, Color color)
+	{
+		Gizmos.color = color;
+		DrawNode(root);
+	}
+
+	private void DrawNode(IBinaryTreeNode node)
+	{
+		Gizmos.DrawWireCube(node.Center, node.Size);
+		if (node.HasChilds)
+		{
+			DrawNode(node.GetLeft());
+			DrawNode(node.GetRight());
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BinaryTreeNode.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BinaryTreeNode.cs
new file mode 100644
index 0000000..4558519
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BinaryTreeNode.cs
@@ -0,0 +1,48 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public abstract class BinaryTreeNode<TData> : IBinaryTreeNode
+{
+	public BinaryTreeNode<TData> Left { get; private set; }
+
+	public BinaryTreeNode<TData> Right { get; private set; }
+
+	public bool IsLeaf { get; private set; }
+
+	public bool HasChilds => Left != null;
+
+	public Vector3 Center { get; private set; }
+
+	public Vector3 Size { get; private set; }
+
+	public Bounds Bounds { get; private set; }
+
+	public BinaryTreeNode(Vector3 center, Vector3 size, bool isLeaf)
+	{
+		Center = center;
+		Size = size;
+		Bounds = new Bounds(center, size);
+		IsLeaf = isLeaf;
+	}
+
+	public IBinaryTreeNode GetLeft()
+	{
+		return Left;
+	}
+
+	public IBinaryTreeNode GetRight()
+	{
+		return Right;
+	}
+
+	public void SetChilds(BinaryTreeNode<TData> left, BinaryTreeNode<TData> right)
+	{
+		Left = left;
+		Right = right;
+	}
+
+	public abstract void Add(TData data);
+
+	public abstract void Remove(TData data);
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BoundsHelper.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BoundsHelper.cs
new file mode 100644
index 0000000..012a350
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/BoundsHelper.cs
@@ -0,0 +1,39 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public static class BoundsHelper
+{
+	public static Bounds Transform(this Bounds bounds, Matrix4x4 transform)
+	{
+		Vector3 min = bounds.min;
+		Vector3 max = bounds.max;
+		Vector4 column = transform.GetColumn(3);
+		Vector3 vector = column;
+		Vector3 vector2 = column;
+		for (int i = 0; i < 3; i++)
+		{
+			for (int j = 0; j < 3; j++)
+			{
+				float num = transform[i, j];
+				float num2 = num * min[j];
+				float num3 = num * max[j];
+				vector[i] += ((num2 < num3) ? num2 : num3);
+				vector2[i] += ((num2 < num3) ? num3 : num2);
+			}
+		}
+		Bounds result = default(Bounds);
+		result.center = transform.MultiplyPoint3x4(bounds.center);
+		result.size = vector2 - vector;
+		return result;
+	}
+
+	public static bool Contains(this Bounds bounds, Bounds target)
+	{
+		if (bounds.Contains(target.min))
+		{
+			return bounds.Contains(target.max);
+		}
+		return false;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineErrorStrategy.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineErrorStrategy.cs
new file mode 100644
index 0000000..89cfbe3
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineErrorStrategy.cs
@@ -0,0 +1,7 @@
+namespace NGS.MeshFusionPro;
+
+public enum CombineErrorStrategy
+{
+	UndoCombining,
+	Ignore
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineMethod.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineMethod.cs
new file mode 100644
index 0000000..e30d53e
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineMethod.cs
@@ -0,0 +1,6 @@
+namespace NGS.MeshFusionPro;
+
+public enum CombineMethod
+{
+	Simple
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineSource.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineSource.cs
new file mode 100644
index 0000000..f010062
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineSource.cs
@@ -0,0 +1,92 @@
+using System;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class CombineSource : ICombineSource<CombinedObject, CombinedObjectPart>, ICombineSource
+{
+	public Vector3 Position { get; private set; }
+
+	public Bounds Bounds { get; private set; }
+
+	public MeshCombineInfo CombineInfo { get; private set; }
+
+	public RendererSettings RendererSettings { get; private set; }
+
+	public event Action<ICombinedObject, ICombinedObjectPart> onCombined;
+
+	public event Action<ICombinedObject, string> onCombineError;
+
+	public event Action<ICombinedObject> onCombineFailed;
+
+	public event Action<CombinedObject, CombinedObjectPart> onCombinedTyped;
+
+	public event Action<CombinedObject, string> onCombineErrorTyped;
+
+	public event Action<CombinedObject> onCombineFailedTyped;
+
+	public CombineSource(GameObject go, int submeshIndex = 0)
+		: this(go.GetComponent<MeshFilter>().mesh, go.GetComponent<MeshRenderer>(), submeshIndex)
+	{
+	}
+
+	public CombineSource(Mesh mesh, MeshRenderer renderer, int submeshIndex = 0)
+	{
+		if (mesh == null)
+		{
+			throw new ArgumentException("Mesh is null");
+		}
+		if (renderer == null)
+		{
+			throw new ArgumentException("Mesh Renderer is null");
+		}
+		if (submeshIndex >= mesh.subMeshCount)
+		{
+			throw new ArgumentException("Submesh index is greater the submeshCount");
+		}
+		MeshCombineInfo info = new MeshCombineInfo(mesh, renderer.localToWorldMatrix, renderer.lightmapScaleOffset, renderer.realtimeLightmapScaleOffset, submeshIndex);
+		RendererSettings settings = new RendererSettings(renderer, submeshIndex);
+		Construct(info, settings, renderer.bounds);
+	}
+
+	public CombineSource(MeshCombineInfo info, RendererSettings settings)
+		: this(info, settings, info.mesh.bounds.Transform(info.transformMatrix))
+	{
+	}
+
+	public CombineSource(MeshCombineInfo info, RendererSettings settings, Bounds bounds)
+	{
+		Construct(info, settings, bounds);
+	}
+
+	private void Construct(MeshCombineInfo info, RendererSettings settings, Bounds bounds)
+	{
+		CombineInfo = info;
+		RendererSettings = settings;
+		Position = info.transformMatrix.GetTranslation();
+		Bounds = bounds;
+	}
+
+	public void Combined(CombinedObject root, CombinedObjectPart part)
+	{
+		this.onCombined?.Invoke(root, part);
+		this.onCombinedTyped?.Invoke(root, part);
+	}
+
+	public void CombineError(CombinedObject root, string errorMessage)
+	{
+		if (this.onCombineError == null && this.onCombinedTyped == null)
+		{
+			Debug.Log("Error during combine " + root.name + ", reason :" + errorMessage);
+			return;
+		}
+		this.onCombineError?.Invoke(root, errorMessage);
+		this.onCombineErrorTyped?.Invoke(root, errorMessage);
+	}
+
+	public void CombineFailed(CombinedObject root)
+	{
+		this.onCombineFailed?.Invoke(root);
+		this.onCombineFailedTyped?.Invoke(root);
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineTree.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineTree.cs
new file mode 100644
index 0000000..2fd39af
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineTree.cs
@@ -0,0 +1,112 @@
+using System;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class CombineTree : BinaryTree<CombineTreeNode, ICombineSource>
+{
+	private ICombinedMeshFactory _factory;
+
+	private float _leafSize;
+
+	private int _vertexLimit;
+
+	public float LeafSize => _leafSize;
+
+	public int VertexLimit => _vertexLimit;
+
+	public ICombinedMeshFactory CombinedMeshFactory => _factory;
+
+	public event Action<CombinedObject> onStaticCombinedObjectCreated;
+
+	public event Action<DynamicCombinedObject> onDynamicCombinedObjectCreated;
+
+	public event Action<CombinedLODGroup> onCombinedLODGroupCreated;
+
+	public CombineTree(ICombinedMeshFactory factory, float leafSize, int vertexLimit)
+	{
+		_factory = factory;
+		_leafSize = leafSize;
+		_vertexLimit = vertexLimit;
+	}
+
+	public void Combine()
+	{
+		TreeTraversal(delegate(CombineTreeNode node, int depth)
+		{
+			node.Combine();
+			return true;
+		});
+	}
+
+	protected override CombineTreeNode CreateRoot(ICombineSource source)
+	{
+		return CreateNode(source.Position, Vector3.one * _leafSize, isLeaf: true);
+	}
+
+	protected override CombineTreeNode CreateNode(Vector3 center, Vector3 size, bool isLeaf)
+	{
+		CombineTreeNode combineTreeNode = new CombineTreeNode(this, center, size, isLeaf);
+		combineTreeNode.onStaticCombinedObjectCreated += this.onStaticCombinedObjectCreated;
+		combineTreeNode.onDynamicCombinedObjectCreated += this.onDynamicCombinedObjectCreated;
+		combineTreeNode.onCombinedLODGroupCreated += this.onCombinedLODGroupCreated;
+		return combineTreeNode;
+	}
+
+	protected override CombineTreeNode ExpandRoot(CombineTreeNode root, ICombineSource target)
+	{
+		Bounds bounds = root.Bounds;
+		Bounds bounds2 = target.Bounds;
+		Vector3 center = Vector3.zero;
+		Vector3 size = Vector3.zero;
+		Vector3 center2 = Vector3.zero;
+		bool flag = false;
+		for (int i = 0; i < 3; i++)
+		{
+			if (bounds2.min[i] < bounds.min[i])
+			{
+				size = bounds.size;
+				size[i] *= 2f;
+				center = bounds.center;
+				center[i] -= bounds.size[i] / 2f;
+				center2 = bounds.center;
+				center2[i] -= bounds.size[i];
+				break;
+			}
+			if (bounds2.max[i] > bounds.max[i])
+			{
+				size = bounds.size;
+				size[i] *= 2f;
+				center = bounds.center;
+				center[i] += bounds.size[i] / 2f;
+				center2 = bounds.center;
+				center2[i] += bounds.size[i];
+				flag = true;
+				break;
+			}
+		}
+		CombineTreeNode combineTreeNode = CreateNode(center, size, isLeaf: false);
+		CombineTreeNode combineTreeNode2 = CreateNode(center2, bounds.size, root.IsLeaf);
+		if (flag)
+		{
+			combineTreeNode.SetChilds(base.RootInternal, combineTreeNode2);
+		}
+		else
+		{
+			combineTreeNode.SetChilds(combineTreeNode2, base.RootInternal);
+		}
+		return combineTreeNode;
+	}
+
+	protected override bool Includes(CombineTreeNode node, ICombineSource source)
+	{
+		Bounds bounds = node.Bounds;
+		Bounds bounds2 = source.Bounds;
+		return bounds.Contains(bounds2);
+	}
+
+	protected override bool Intersects(CombineTreeNode node, ICombineSource source)
+	{
+		return node.Bounds.Contains(source.Position);
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineTreeNode.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineTreeNode.cs
new file mode 100644
index 0000000..ca4c318
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombineTreeNode.cs
@@ -0,0 +1,45 @@
+using System;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class CombineTreeNode : BinaryTreeNode<ICombineSource>
+{
+	private CombineTree _tree;
+
+	private UniversalObjectsCombiner _combiner;
+
+	public event Action<CombinedObject> onStaticCombinedObjectCreated;
+
+	public event Action<DynamicCombinedObject> onDynamicCombinedObjectCreated;
+
+	public event Action<CombinedLODGroup> onCombinedLODGroupCreated;
+
+	public CombineTreeNode(CombineTree tree, Vector3 center, Vector3 size, bool isLeaf)
+		: base(center, size, isLeaf)
+	{
+		_tree = tree;
+	}
+
+	public override void Add(ICombineSource source)
+	{
+		if (_combiner == null)
+		{
+			_combiner = new UniversalObjectsCombiner(_tree.CombinedMeshFactory, _tree.VertexLimit);
+			_combiner.onStaticCombinedObjectCreated += this.onStaticCombinedObjectCreated;
+			_combiner.onDynamicCombinedObjectCreated += this.onDynamicCombinedObjectCreated;
+			_combiner.onCombinedLODGroupCreated += this.onCombinedLODGroupCreated;
+		}
+		_combiner.AddSource(source);
+	}
+
+	public override void Remove(ICombineSource source)
+	{
+		_combiner.RemoveSource(source);
+	}
+
+	public void Combine()
+	{
+		_combiner?.Combine();
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedLODGroup.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedLODGroup.cs
new file mode 100644
index 0000000..e5f2a93
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedLODGroup.cs
@@ -0,0 +1,265 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class CombinedLODGroup : MonoBehaviour, ICombinedObject<CombinedLODGroupPart, LODGroupCombineSource>, ICombinedObject
+{
+	private class LevelOfDetailCombiner : StaticObjectsCombiner
+	{
+		private Transform _transform;
+
+		private CombinedLODGroup _group;
+
+		private Renderer[] _renderers;
+
+		private int _level;
+
+		public LevelOfDetailCombiner(int level, CombinedLODGroup group, ICombinedMeshFactory factory, int vertexLimit)
+			: base(factory, vertexLimit)
+		{
+			_level = level;
+			_group = group;
+			_transform = new GameObject("LOD" + _level).transform;
+			_transform.parent = group.transform;
+			_transform.localPosition = Vector3.zero;
+		}
+
+		public Renderer[] GetRenderers()
+		{
+			if (_renderers == null || _renderers.Length != base.CombinedObjects.Count)
+			{
+				UpdateRenderersList();
+			}
+			return _renderers;
+		}
+
+		public Bounds CalculateBounds()
+		{
+			Bounds result = new Bounds(_group.transform.position, Vector3.zero);
+			GetRenderers();
+			for (int i = 0; i < _renderers.Length; i++)
+			{
+				if (base.CombinedObjects[i].Parts.Count > 0)
+				{
+					result.Encapsulate(_renderers[i].bounds);
+				}
+			}
+			return result;
+		}
+
+		protected override CombinedObject CreateCombinedObject(CombineSource source)
+		{
+			CombinedObject combinedObject = base.CreateCombinedObject(source);
+			combinedObject.transform.parent = _transform;
+			_group._updateLODs = true;
+			return combinedObject;
+		}
+
+		private void UpdateRenderersList()
+		{
+			_renderers = base.CombinedObjects.Select((CombinedObject r) => r.GetComponent<Renderer>()).ToArray();
+		}
+	}
+
+	private LODGroup _group;
+
+	private List<CombinedLODGroupPart> _parts;
+
+	private LevelOfDetailCombiner[] _levelCombiners;
+
+	private LOD[] _lods;
+
+	private Bounds _localBounds;
+
+	private int _lodCount;
+
+	private LODGroupSettings _originalSettings;
+
+	private float _originalBoundsSize;
+
+	private bool _updateLODs;
+
+	IReadOnlyList<ICombinedObjectPart> ICombinedObject.Parts => _parts;
+
+	public IReadOnlyList<CombinedLODGroupPart> Parts => _parts;
+
+	public LODGroupSettings Settings => _originalSettings;
+
+	public Bounds Bounds
+	{
+		get
+		{
+			Bounds localBounds = _localBounds;
+			localBounds.center += base.transform.position;
+			return localBounds;
+		}
+	}
+
+	public static CombinedLODGroup Create(MeshType meshType, CombineMethod combineMethod, LODGroupSettings settings, int vertexLimit = 45000)
+	{
+		return Create(new CombinedMeshFactory(meshType, combineMethod), settings, vertexLimit);
+	}
+
+	public static CombinedLODGroup Create(ICombinedMeshFactory factory, LODGroupSettings settings, int vertexLimit = 45000)
+	{
+		CombinedLODGroup combinedLODGroup = new GameObject("CombinedLODGroup").AddComponent<CombinedLODGroup>();
+		combinedLODGroup.Construct(settings, factory, vertexLimit);
+		return combinedLODGroup;
+	}
+
+	private void Construct(LODGroupSettings settings, ICombinedMeshFactory factory, int vertexLimit)
+	{
+		if (factory == null)
+		{
+			throw new ArgumentException("CombinedLODGroup::factory is null");
+		}
+		_group = base.gameObject.AddComponent<LODGroup>();
+		_parts = new List<CombinedLODGroupPart>();
+		_group.fadeMode = settings.fadeMode;
+		_group.animateCrossFading = settings.animateCrossFading;
+		_originalSettings = settings;
+		_lodCount = _originalSettings.lodCount;
+		_levelCombiners = new LevelOfDetailCombiner[_lodCount];
+		_lods = new LOD[_originalSettings.lodCount];
+		for (int i = 0; i < _originalSettings.lodCount; i++)
+		{
+			_levelCombiners[i] = new LevelOfDetailCombiner(i, this, factory, vertexLimit);
+			_lods[i] = new LOD
+			{
+				fadeTransitionWidth = _originalSettings.fadeTransitionsWidth[i],
+				screenRelativeTransitionHeight = _originalSettings.screenTransitionsHeight[i],
+				renderers = null
+			};
+		}
+	}
+
+	public void Combine(IEnumerable<ICombineSource> sources)
+	{
+		Combine(sources.Select((ICombineSource s) => (LODGroupCombineSource)s));
+	}
+
+	public void Combine(IEnumerable<LODGroupCombineSource> sourceGroups)
+	{
+		if (sourceGroups == null || sourceGroups.Count() == 0)
+		{
+			throw new ArgumentException("CombinedLODGroup::sources is null");
+		}
+		LODGroupCombineSource[] array = sourceGroups.ToArray();
+		if (_parts.Count == 0)
+		{
+			InitBeforeFirstCombine(array);
+		}
+		List<CombinedObjectPart>[] combinedParts = FillCombinersAndCreateBaseParts(array);
+		for (int i = 0; i < _lodCount; i++)
+		{
+			_levelCombiners[i].Combine();
+		}
+		RecalculateBounds();
+		if (_updateLODs)
+		{
+			UpdateLODs();
+			_updateLODs = false;
+		}
+		CreatePartsAndNotifySources(array, combinedParts);
+	}
+
+	public void Destroy(CombinedLODGroupPart part, IList<CombinedObjectPart> baseParts)
+	{
+		if (_parts.Remove(part))
+		{
+			for (int i = 0; i < baseParts.Count; i++)
+			{
+				baseParts[i].Destroy();
+			}
+			RecalculateBounds();
+		}
+	}
+
+	private void InitBeforeFirstCombine(LODGroupCombineSource[] sources)
+	{
+		Vector3 zero = Vector3.zero;
+		for (int i = 0; i < sources.Length; i++)
+		{
+			zero += sources[i].Position;
+		}
+		base.transform.position = zero / sources.Length;
+		_originalBoundsSize = sources[0].Bounds.size.magnitude;
+	}
+
+	private List<CombinedObjectPart>[] FillCombinersAndCreateBaseParts(LODGroupCombineSource[] sourceGroups)
+	{
+		List<CombinedObjectPart>[] parts = new List<CombinedObjectPart>[sourceGroups.Length];
+		for (int i = 0; i < sourceGroups.Length; i++)
+		{
+			LODGroupCombineSource sourceGroup = sourceGroups[i];
+			parts[i] = new List<CombinedObjectPart>();
+			for (int j = 0; j < _lodCount; j++)
+			{
+				CombineSource[] array = sourceGroup.BaseSources[j];
+				foreach (CombineSource obj in array)
+				{
+					int g = i;
+					obj.onCombinedTyped += delegate(CombinedObject o, CombinedObjectPart p)
+					{
+						parts[g].Add(p);
+					};
+					obj.onCombineErrorTyped += delegate(CombinedObject root, string msg)
+					{
+						sourceGroup.CombineError(this, msg);
+					};
+				}
+				_levelCombiners[j].AddSources(array);
+			}
+		}
+		return parts;
+	}
+
+	private void RecalculateBounds()
+	{
+		_localBounds = new Bounds(base.transform.position, Vector3.zero);
+		for (int i = 0; i < _levelCombiners.Length; i++)
+		{
+			_localBounds.Encapsulate(_levelCombiners[i].CalculateBounds());
+		}
+		_localBounds.center -= base.transform.position;
+	}
+
+	private void UpdateLODs()
+	{
+		float value = _localBounds.size.magnitude / _originalBoundsSize;
+		float num = 1f;
+		value = Mathf.Clamp(value, 1f, 100f);
+		for (int i = 0; i < _lodCount; i++)
+		{
+			LOD lOD = _lods[i];
+			lOD.renderers = _levelCombiners[i].GetRenderers();
+			lOD.screenRelativeTransitionHeight = _originalSettings.screenTransitionsHeight[i] * value;
+			if (lOD.screenRelativeTransitionHeight >= num)
+			{
+				num = (lOD.screenRelativeTransitionHeight = num - 0.03f);
+			}
+			_lods[i] = lOD;
+		}
+		_group.SetLODs(_lods);
+	}
+
+	private void CreatePartsAndNotifySources(LODGroupCombineSource[] sourceGroups, List<CombinedObjectPart>[] combinedParts)
+	{
+		for (int i = 0; i < sourceGroups.Length; i++)
+		{
+			LODGroupCombineSource lODGroupCombineSource = sourceGroups[i];
+			List<CombinedObjectPart> list = combinedParts[i];
+			if (list.Count == 0)
+			{
+				lODGroupCombineSource.CombineFailed(this);
+				continue;
+			}
+			CombinedLODGroupPart combinedLODGroupPart = new CombinedLODGroupPart(this, list);
+			_parts.Add(combinedLODGroupPart);
+			lODGroupCombineSource.Combined(this, combinedLODGroupPart);
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedLODGroupMatcher.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedLODGroupMatcher.cs
new file mode 100644
index 0000000..ef1b3c7
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedLODGroupMatcher.cs
@@ -0,0 +1,20 @@
+namespace NGS.MeshFusionPro;
+
+public class CombinedLODGroupMatcher : CombinedObjectMatcher<CombinedLODGroup, LODGroupCombineSource>
+{
+	private LODGroupSettings _settings;
+
+	public override void StartMatching(CombinedLODGroup combinedObject)
+	{
+		_settings = combinedObject.Settings;
+	}
+
+	public override bool CanAddSource(LODGroupCombineSource source)
+	{
+		return source.Settings.IsEqual(_settings, 0.01f, 0.01f);
+	}
+
+	public override void SourceAdded(LODGroupCombineSource source)
+	{
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedLODGroupPart.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedLODGroupPart.cs
new file mode 100644
index 0000000..95c9c00
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedLODGroupPart.cs
@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class CombinedLODGroupPart : ICombinedObjectPart<CombinedLODGroup>, ICombinedObjectPart
+{
+	private List<CombinedObjectPart> _baseParts;
+
+	private Bounds _localBounds;
+
+	ICombinedObject ICombinedObjectPart.Root => Root;
+
+	public CombinedLODGroup Root { get; private set; }
+
+	public Bounds LocalBounds => _localBounds;
+
+	public Bounds Bounds
+	{
+		get
+		{
+			Bounds localBounds = _localBounds;
+			localBounds.center += Root.transform.position;
+			return localBounds;
+		}
+	}
+
+	public CombinedLODGroupPart(CombinedLODGroup root, List<CombinedObjectPart> baseParts)
+	{
+		Root = root;
+		_baseParts = baseParts;
+		CalculateLocalBounds();
+	}
+
+	public void Destroy()
+	{
+		Root.Destroy(this, _baseParts);
+	}
+
+	private void CalculateLocalBounds()
+	{
+		_localBounds = _baseParts[0].Bounds;
+		for (int i = 1; i < _baseParts.Count; i++)
+		{
+			_localBounds.Encapsulate(_baseParts[i].Bounds);
+		}
+		_localBounds.center -= Root.transform.position;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMesh.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMesh.cs
new file mode 100644
index 0000000..fd9933b
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMesh.cs
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class CombinedMesh : IDisposable
+{
+	private Mesh _mesh;
+
+	private CombinedMeshDataInternal _meshData;
+
+	private IMeshCombiner _combiner;
+
+	private IMeshCutter _cutter;
+
+	public Mesh Mesh => _mesh;
+
+	public CombinedMeshData MeshData => _meshData;
+
+	public CombinedMesh(IMeshCombiner combiner, IMeshCutter cutter)
+	{
+		if (combiner == null)
+		{
+			throw new ArgumentNullException("MeshCombiner not assigned");
+		}
+		if (cutter == null)
+		{
+			throw new ArgumentNullException("MeshCutter not assigned");
+		}
+		_mesh = new Mesh();
+		_mesh.MarkDynamic();
+		_combiner = combiner;
+		_cutter = cutter;
+		_meshData = CreateMeshData();
+		_meshData.Initialize(this);
+	}
+
+	public CombinedMeshPart[] Combine(IList<MeshCombineInfo> infos)
+	{
+		_combiner.Combine(_mesh, infos);
+		return _meshData.CreateParts(infos);
+	}
+
+	public void Cut(IList<CombinedMeshPart> parts)
+	{
+		MeshCuttingInfo[] array = new MeshCuttingInfo[parts.Count];
+		for (int i = 0; i < parts.Count; i++)
+		{
+			CombinedMeshPart combinedMeshPart = parts[i];
+			array[i] = new MeshCuttingInfo
+			{
+				vertexStart = combinedMeshPart.VertexStart,
+				vertexCount = combinedMeshPart.VertexCount,
+				triangleStart = combinedMeshPart.TrianglesStart,
+				triangleCount = combinedMeshPart.TrianglesCount
+			};
+		}
+		_cutter.Cut(_mesh, array);
+		_meshData.RemoveParts(parts);
+	}
+
+	public void Dispose()
+	{
+		_meshData.Dispose();
+	}
+
+	protected virtual CombinedMeshDataInternal CreateMeshData()
+	{
+		return new CombinedMeshDataInternal();
+	}
+}
+public class CombinedMesh<TCombinedMeshData> : CombinedMesh where TCombinedMeshData : CombinedMeshDataInternal, new()
+{
+	public TCombinedMeshData MeshDataInternal => (TCombinedMeshData)base.MeshData;
+
+	public CombinedMesh(IMeshCombiner combiner, IMeshCutter cutter)
+		: base(combiner, cutter)
+	{
+	}
+
+	protected override CombinedMeshDataInternal CreateMeshData()
+	{
+		return new TCombinedMeshData();
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshData.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshData.cs
new file mode 100644
index 0000000..06afc2b
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshData.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public abstract class CombinedMeshData
+{
+	public abstract int PartsCount { get; }
+
+	public abstract int VertexCount { get; }
+
+	public abstract Bounds GetBounds();
+
+	public abstract Bounds GetBounds(CombinedMeshPart part);
+
+	public abstract IEnumerable<CombinedMeshPart> GetParts();
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshDataInternal.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshDataInternal.cs
new file mode 100644
index 0000000..c055f95
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshDataInternal.cs
@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class CombinedMeshDataInternal : CombinedMeshData, IDisposable
+{
+	private CombinedMesh _root;
+
+	private List<CombinedMeshPartInternal> _parts;
+
+	private int _vertexCount;
+
+	private int _trianglesCount;
+
+	private List<Bounds> _partsBounds;
+
+	private Bounds _boundingBox;
+
+	public override int PartsCount => _parts.Count;
+
+	public override int VertexCount => _vertexCount;
+
+	protected CombinedMesh Root => _root;
+
+	public void Initialize(CombinedMesh root)
+	{
+		_root = root;
+		_parts = new List<CombinedMeshPartInternal>();
+		OnInitialized();
+	}
+
+	public override Bounds GetBounds()
+	{
+		return _boundingBox;
+	}
+
+	public override Bounds GetBounds(CombinedMeshPart part)
+	{
+		return _partsBounds[part.Index];
+	}
+
+	public override IEnumerable<CombinedMeshPart> GetParts()
+	{
+		for (int i = 0; i < _parts.Count; i++)
+		{
+			yield return _parts[i];
+		}
+	}
+
+	public void Dispose()
+	{
+		OnDispose();
+	}
+
+	public CombinedMeshPart[] CreateParts(IList<MeshCombineInfo> infos)
+	{
+		CombinedMeshPart[] array = new CombinedMeshPart[infos.Count];
+		for (int i = 0; i < array.Length; i++)
+		{
+			MeshCombineInfo meshCombineInfo = infos[i];
+			Mesh mesh = meshCombineInfo.mesh;
+			Matrix4x4 transformMatrix = meshCombineInfo.transformMatrix;
+			int vertexCount = _vertexCount;
+			int vertexCount2 = meshCombineInfo.vertexCount;
+			int trianglesCount = _trianglesCount;
+			int trianglesCount2 = meshCombineInfo.trianglesCount;
+			CombinedMeshPartInternal combinedMeshPartInternal = new CombinedMeshPartInternal(_root, _parts.Count, vertexCount, vertexCount2, trianglesCount, trianglesCount2);
+			_parts.Add(combinedMeshPartInternal);
+			array[i] = combinedMeshPartInternal;
+			_vertexCount += vertexCount2;
+			_trianglesCount += trianglesCount2;
+			OnAddPart(combinedMeshPartInternal, mesh, transformMatrix);
+		}
+		OnMeshUpdated();
+		return array;
+	}
+
+	public void RemoveParts(IList<CombinedMeshPart> parts)
+	{
+		for (int i = 0; i < parts.Count; i++)
+		{
+			CombinedMeshPartInternal combinedMeshPartInternal = (CombinedMeshPartInternal)parts[i];
+			OnRemovePart(combinedMeshPartInternal);
+			int num = _parts.IndexOf(combinedMeshPartInternal);
+			int vertexCount = combinedMeshPartInternal.VertexCount;
+			int trianglesCount = combinedMeshPartInternal.TrianglesCount;
+			for (int j = num + 1; j < _parts.Count; j++)
+			{
+				CombinedMeshPartInternal combinedMeshPartInternal2 = _parts[j];
+				combinedMeshPartInternal2.Offset(newVertexStart: combinedMeshPartInternal2.VertexStart - vertexCount, newTrianglesStart: combinedMeshPartInternal2.TrianglesStart - trianglesCount, newIndex: combinedMeshPartInternal2.Index - 1);
+			}
+			_parts.Remove(combinedMeshPartInternal);
+			_vertexCount -= combinedMeshPartInternal.VertexCount;
+			_trianglesCount -= combinedMeshPartInternal.TrianglesCount;
+		}
+		OnMeshUpdated();
+	}
+
+	protected virtual void OnInitialized()
+	{
+		_partsBounds = new List<Bounds>();
+	}
+
+	protected virtual void OnAddPart(CombinedMeshPart part, Mesh mesh, Matrix4x4 transform)
+	{
+		_partsBounds.Add(mesh.bounds.Transform(transform));
+	}
+
+	protected virtual void OnRemovePart(CombinedMeshPart part)
+	{
+		_partsBounds.RemoveAt(part.Index);
+	}
+
+	protected virtual void OnMeshUpdated()
+	{
+		_boundingBox = _root.Mesh.bounds;
+	}
+
+	protected virtual void OnDispose()
+	{
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshFactory.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshFactory.cs
new file mode 100644
index 0000000..850efd8
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshFactory.cs
@@ -0,0 +1,43 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class CombinedMeshFactory : ICombinedMeshFactory
+{
+	private IMeshToolsFactory _tools;
+
+	private IMovableCombinedMeshFactory _movableMeshFactory;
+
+	public CombinedMeshFactory(MeshType meshType, CombineMethod combineMethod, MoveMethod moveMethod = MoveMethod.Simple)
+	{
+		if (meshType == MeshType.Standard)
+		{
+			_tools = new SimpleToolsSTDFactory();
+			if (moveMethod == MoveMethod.Simple)
+			{
+				_movableMeshFactory = new SimpleMovableMeshSTDFactory(_tools);
+			}
+			else
+			{
+				_movableMeshFactory = new JobsMovableMeshSTDFactory(_tools);
+			}
+			return;
+		}
+		_tools = new SimpleToolsLWFactory();
+		if (moveMethod == MoveMethod.Simple)
+		{
+			Debug.Log("Simple mover not implemented yet for lightweight meshes. Jobs mover will be used instead");
+		}
+		_movableMeshFactory = new JobsMovableMeshLWFactory(_tools);
+	}
+
+	public CombinedMesh CreateCombinedMesh()
+	{
+		return new CombinedMesh(_tools.CreateMeshCombiner(), _tools.CreateMeshCutter());
+	}
+
+	public CombinedMesh CreateMovableCombinedMesh(out ICombinedMeshMover mover)
+	{
+		return _movableMeshFactory.CreateMovableMesh(out mover);
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshPart.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshPart.cs
new file mode 100644
index 0000000..9034a26
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshPart.cs
@@ -0,0 +1,26 @@
+namespace NGS.MeshFusionPro;
+
+public class CombinedMeshPart
+{
+	public CombinedMesh Root { get; private set; }
+
+	public int Index { get; protected set; }
+
+	public int VertexStart { get; protected set; }
+
+	public int VertexCount { get; protected set; }
+
+	public int TrianglesStart { get; protected set; }
+
+	public int TrianglesCount { get; protected set; }
+
+	public CombinedMeshPart(CombinedMesh root, int index, int vertexStart, int vertexCount, int trianglesStart, int trianglesCount)
+	{
+		Root = root;
+		Index = index;
+		VertexStart = vertexStart;
+		VertexCount = vertexCount;
+		TrianglesStart = trianglesStart;
+		TrianglesCount = trianglesCount;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshPartInternal.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshPartInternal.cs
new file mode 100644
index 0000000..9bc07cd
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedMeshPartInternal.cs
@@ -0,0 +1,16 @@
+namespace NGS.MeshFusionPro;
+
+public class CombinedMeshPartInternal : CombinedMeshPart
+{
+	public CombinedMeshPartInternal(CombinedMesh root, int index, int vertexStart, int vertexCount, int trianglesStart, int trianglesCount)
+		: base(root, index, vertexStart, vertexCount, trianglesStart, trianglesCount)
+	{
+	}
+
+	public void Offset(int newIndex, int newVertexStart, int newTrianglesStart)
+	{
+		base.Index = newIndex;
+		base.VertexStart = newVertexStart;
+		base.TrianglesStart = newTrianglesStart;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedObject.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedObject.cs
new file mode 100644
index 0000000..5a7bc43
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedObject.cs
@@ -0,0 +1,209 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class CombinedObject : MonoBehaviour, ICombinedObject<CombinedObjectPart, CombineSource>, ICombinedObject
+{
+	private CombinedMesh _combinedMesh;
+
+	private CombinedMeshDataInternal _meshData;
+
+	private List<CombinedObjectPart> _parts;
+
+	private List<CombinedMeshPart> _destroyedMeshParts;
+
+	private RendererSettings _rendererSettings;
+
+	private bool _updating;
+
+	IReadOnlyList<ICombinedObjectPart> ICombinedObject.Parts => _parts;
+
+	public IReadOnlyList<CombinedObjectPart> Parts => _parts;
+
+	public RendererSettings RendererSettings => _rendererSettings;
+
+	public Bounds Bounds
+	{
+		get
+		{
+			Bounds localBounds = LocalBounds;
+			localBounds.center += base.transform.position;
+			return localBounds;
+		}
+	}
+
+	public Bounds LocalBounds => _combinedMesh.MeshData.GetBounds();
+
+	public int VertexCount => _combinedMesh.MeshData.VertexCount;
+
+	public bool Updating
+	{
+		get
+		{
+			return _updating;
+		}
+		set
+		{
+			_updating = value;
+			base.enabled = value;
+		}
+	}
+
+	private void Update()
+	{
+		if (!Updating)
+		{
+			base.enabled = false;
+			return;
+		}
+		ForceUpdate();
+		base.enabled = false;
+	}
+
+	private void OnDestroy()
+	{
+		_combinedMesh.Dispose();
+	}
+
+	public static CombinedObject Create(MeshType meshType, CombineMethod combineType, RendererSettings settings)
+	{
+		return Create(new CombinedMeshFactory(meshType, combineType), settings);
+	}
+
+	public static CombinedObject Create(ICombinedMeshFactory factory, RendererSettings settings)
+	{
+		return Create(factory.CreateCombinedMesh(), settings);
+	}
+
+	public static CombinedObject Create(CombinedMesh combinedMesh, RendererSettings settings)
+	{
+		CombinedObject combinedObject = new GameObject("Combined Object").AddComponent<CombinedObject>();
+		combinedObject.Construct(combinedMesh, settings);
+		return combinedObject;
+	}
+
+	private void Construct(CombinedMesh combinedMesh, RendererSettings settings)
+	{
+		_combinedMesh = combinedMesh;
+		_meshData = (CombinedMeshDataInternal)_combinedMesh.MeshData;
+		_parts = new List<CombinedObjectPart>();
+		_destroyedMeshParts = new List<CombinedMeshPart>();
+		_rendererSettings = settings;
+		_updating = true;
+		if (combinedMesh.MeshData.PartsCount > 0)
+		{
+			foreach (CombinedMeshPart part in combinedMesh.MeshData.GetParts())
+			{
+				_parts.Add(new CombinedObjectPart(this, part));
+			}
+		}
+		CreateMeshFilter(_combinedMesh.Mesh);
+		CreateMeshRenderer(settings);
+	}
+
+	public void ForceUpdate()
+	{
+		if (_destroyedMeshParts.Count > 0)
+		{
+			_combinedMesh.Cut(_destroyedMeshParts);
+			_destroyedMeshParts.Clear();
+		}
+	}
+
+	public Bounds GetLocalBounds(CombinedObjectPart part)
+	{
+		return _meshData.GetBounds(part.MeshPart);
+	}
+
+	public Bounds GetBounds(CombinedObjectPart part)
+	{
+		Bounds localBounds = GetLocalBounds(part);
+		localBounds.center += base.transform.position;
+		return localBounds;
+	}
+
+	public void Combine(IEnumerable<ICombineSource> sources)
+	{
+		Combine(sources.Select((ICombineSource s) => (CombineSource)s));
+	}
+
+	public void Combine(IEnumerable<CombineSource> sources)
+	{
+		if (_parts.Count == 0)
+		{
+			base.transform.position = GetAveragePosition(sources);
+		}
+		Vector3 position = base.transform.position;
+		int num = sources.Count();
+		int num2 = 0;
+		MeshCombineInfo[] array = new MeshCombineInfo[num];
+		foreach (CombineSource source in sources)
+		{
+			MeshCombineInfo combineInfo = source.CombineInfo;
+			combineInfo.transformMatrix = combineInfo.transformMatrix.SetTranslation(source.Position - position);
+			array[num2++] = combineInfo;
+		}
+		try
+		{
+			CombinedMeshPart[] array2 = _combinedMesh.Combine(array);
+			num2 = 0;
+			foreach (CombineSource source2 in sources)
+			{
+				CombinedObjectPart combinedObjectPart = new CombinedObjectPart(this, array2[num2]);
+				_parts.Add(combinedObjectPart);
+				source2.Combined(this, combinedObjectPart);
+				num2++;
+			}
+		}
+		catch (Exception ex)
+		{
+			string errorMessage = ex.Message + ex.StackTrace;
+			foreach (CombineSource source3 in sources)
+			{
+				source3.CombineError(this, errorMessage);
+				source3.CombineFailed(this);
+			}
+		}
+	}
+
+	public void Destroy(CombinedObjectPart part)
+	{
+		if (_parts.Remove(part))
+		{
+			_destroyedMeshParts.Add(part.MeshPart);
+			base.enabled = true;
+		}
+	}
+
+	private void CreateMeshFilter(Mesh mesh)
+	{
+		base.gameObject.AddComponent<MeshFilter>().sharedMesh = mesh;
+	}
+
+	private void CreateMeshRenderer(RendererSettings settings)
+	{
+		MeshRenderer meshRenderer = base.gameObject.AddComponent<MeshRenderer>();
+		meshRenderer.sharedMaterial = settings.material;
+		meshRenderer.shadowCastingMode = settings.shadowMode;
+		meshRenderer.receiveShadows = settings.receiveShadows;
+		meshRenderer.lightmapIndex = settings.lightmapIndex;
+		meshRenderer.realtimeLightmapIndex = settings.realtimeLightmapIndex;
+		meshRenderer.tag = settings.tag;
+		meshRenderer.gameObject.layer = settings.layer;
+	}
+
+	private Vector3 GetAveragePosition(IEnumerable<CombineSource> sources)
+	{
+		Vector3 zero = Vector3.zero;
+		int num = 0;
+		foreach (CombineSource source in sources)
+		{
+			zero += source.Position;
+			num++;
+		}
+		return zero / num;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedObjectMatcher.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedObjectMatcher.cs
new file mode 100644
index 0000000..57e39b7
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedObjectMatcher.cs
@@ -0,0 +1,10 @@
+namespace NGS.MeshFusionPro;
+
+public abstract class CombinedObjectMatcher<TCombinedObject, TCombineSource> where TCombinedObject : ICombinedObject where TCombineSource : ICombineSource
+{
+	public abstract void StartMatching(TCombinedObject combinedObject);
+
+	public abstract bool CanAddSource(TCombineSource source);
+
+	public abstract void SourceAdded(TCombineSource source);
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedObjectPart.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedObjectPart.cs
new file mode 100644
index 0000000..ca434ff
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/CombinedObjectPart.cs
@@ -0,0 +1,35 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class CombinedObjectPart : ICombinedObjectPart<CombinedObject>, ICombinedObjectPart
+{
+	private bool _destroyed;
+
+	ICombinedObject ICombinedObjectPart.Root => Root;
+
+	public CombinedObject Root { get; private set; }
+
+	public CombinedMeshPart MeshPart { get; private set; }
+
+	public Bounds LocalBounds => Root.GetLocalBounds(this);
+
+	public Bounds Bounds => Root.GetBounds(this);
+
+	public CombinedObjectPart(CombinedObject root, CombinedMeshPart meshPart)
+	{
+		Root = root;
+		MeshPart = meshPart;
+	}
+
+	public void Destroy()
+	{
+		if (_destroyed)
+		{
+			Debug.Log("CombinedPart already destroyed");
+			return;
+		}
+		Root.Destroy(this);
+		_destroyed = true;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombineSource.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombineSource.cs
new file mode 100644
index 0000000..dcbf244
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombineSource.cs
@@ -0,0 +1,70 @@
+using System;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class DynamicCombineSource : ICombineSource<DynamicCombinedObject, DynamicCombinedObjectPart>, ICombineSource
+{
+	private CombineSource _base;
+
+	public CombineSource Base => _base;
+
+	public Vector3 Position => _base.Position;
+
+	public Bounds Bounds => _base.Bounds;
+
+	public event Action<ICombinedObject, ICombinedObjectPart> onCombined;
+
+	public event Action<ICombinedObject, string> onCombineError;
+
+	public event Action<ICombinedObject> onCombineFailed;
+
+	public event Action<DynamicCombinedObject, DynamicCombinedObjectPart> onCombinedTyped;
+
+	public event Action<DynamicCombinedObject, string> onCombineErrorTyped;
+
+	public event Action<DynamicCombinedObject> onCombineFailedTyped;
+
+	public DynamicCombineSource(GameObject go, int submeshIndex = 0)
+	{
+		_base = new CombineSource(go, submeshIndex);
+	}
+
+	public DynamicCombineSource(Mesh mesh, MeshRenderer renderer, int submeshIndex = 0)
+	{
+		_base = new CombineSource(mesh, renderer, submeshIndex);
+	}
+
+	public DynamicCombineSource(MeshCombineInfo info, RendererSettings settings)
+	{
+		_base = new CombineSource(info, settings);
+	}
+
+	public DynamicCombineSource(MeshCombineInfo info, RendererSettings settings, Bounds bounds)
+	{
+		_base = new CombineSource(info, settings, bounds);
+	}
+
+	public void Combined(DynamicCombinedObject root, DynamicCombinedObjectPart part)
+	{
+		this.onCombined?.Invoke(root, part);
+		this.onCombinedTyped?.Invoke(root, part);
+	}
+
+	public void CombineError(DynamicCombinedObject root, string errorMessage)
+	{
+		if (this.onCombineError == null && this.onCombineErrorTyped == null)
+		{
+			Debug.Log("Error during combine " + root.name + ", reason :" + errorMessage);
+			return;
+		}
+		this.onCombineError?.Invoke(root, errorMessage);
+		this.onCombineErrorTyped?.Invoke(root, errorMessage);
+	}
+
+	public void CombineFailed(DynamicCombinedObject root)
+	{
+		this.onCombineFailed?.Invoke(root);
+		this.onCombineFailedTyped?.Invoke(root);
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObject.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObject.cs
new file mode 100644
index 0000000..464bee8
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObject.cs
@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class DynamicCombinedObject : MonoBehaviour, ICombinedObject<DynamicCombinedObjectPart, DynamicCombineSource>, ICombinedObject
+{
+	private CombinedObject _baseObject;
+
+	private List<DynamicCombinedObjectPart> _parts;
+
+	private ICombinedMeshMover _meshMover;
+
+	private List<DynamicCombinedObjectPartInternal> _movedParts;
+
+	private List<PartMoveInfo> _movedPartsData;
+
+	private bool _partsMoved;
+
+	IReadOnlyList<ICombinedObjectPart> ICombinedObject.Parts => _parts;
+
+	public IReadOnlyList<DynamicCombinedObjectPart> Parts => _parts;
+
+	public RendererSettings RendererSettings => _baseObject.RendererSettings;
+
+	public Bounds Bounds => _baseObject.Bounds;
+
+	public Bounds LocalBounds => _baseObject.LocalBounds;
+
+	public int VertexCount => _baseObject.VertexCount;
+
+	private void Update()
+	{
+		if (_movedParts.Count > 0)
+		{
+			if (_meshMover is IAsyncCombinedMeshMover asyncCombinedMeshMover)
+			{
+				asyncCombinedMeshMover.MovePartsAsync(_movedPartsData);
+			}
+			else
+			{
+				_meshMover.MoveParts(_movedPartsData);
+			}
+			for (int i = 0; i < _movedParts.Count; i++)
+			{
+				_movedParts[i].PositionUpdated();
+			}
+			_movedParts.Clear();
+			_movedPartsData.Clear();
+			_partsMoved = true;
+		}
+	}
+
+	private void LateUpdate()
+	{
+		if (_partsMoved)
+		{
+			if (_meshMover is IAsyncCombinedMeshMover asyncCombinedMeshMover)
+			{
+				asyncCombinedMeshMover.FinishAsyncMoving();
+			}
+			_meshMover.ApplyData();
+			_partsMoved = false;
+		}
+		_baseObject.ForceUpdate();
+		if (_movedParts.Count == 0)
+		{
+			base.enabled = false;
+		}
+	}
+
+	private void OnDestroy()
+	{
+		if (_meshMover is IDisposable disposable)
+		{
+			disposable.Dispose();
+		}
+	}
+
+	public static DynamicCombinedObject Create(MeshType meshType, CombineMethod combineMethod, MoveMethod moveMethod, RendererSettings settings)
+	{
+		return Create(new CombinedMeshFactory(meshType, combineMethod, moveMethod), settings);
+	}
+
+	public static DynamicCombinedObject Create(ICombinedMeshFactory factory, RendererSettings settings)
+	{
+		ICombinedMeshMover mover;
+		CombinedObject combinedObject = CombinedObject.Create(factory.CreateMovableCombinedMesh(out mover), settings);
+		DynamicCombinedObject dynamicCombinedObject = combinedObject.gameObject.AddComponent<DynamicCombinedObject>();
+		dynamicCombinedObject.Construct(combinedObject, mover);
+		return dynamicCombinedObject;
+	}
+
+	private void Construct(CombinedObject baseObject, ICombinedMeshMover mover)
+	{
+		base.gameObject.name = "Dynamic Combined Object";
+		_baseObject = baseObject;
+		_meshMover = mover;
+		_parts = new List<DynamicCombinedObjectPart>();
+		_movedParts = new List<DynamicCombinedObjectPartInternal>();
+		_movedPartsData = new List<PartMoveInfo>();
+		_baseObject.Updating = false;
+	}
+
+	public void Combine(IEnumerable<ICombineSource> sources)
+	{
+		Combine(sources.Select((ICombineSource s) => (DynamicCombineSource)s));
+	}
+
+	public void Combine(IEnumerable<DynamicCombineSource> sources)
+	{
+		int num = sources.Count();
+		CombineSource[] array = new CombineSource[num];
+		_ = new DynamicCombinedObjectPart[num];
+		int num2 = 0;
+		foreach (DynamicCombineSource source in sources)
+		{
+			CombineSource baseSource = source.Base;
+			array[num2++] = baseSource;
+			baseSource.onCombinedTyped += delegate(CombinedObject root, CombinedObjectPart part)
+			{
+				DynamicCombinedObjectPart dynamicCombinedObjectPart = new DynamicCombinedObjectPartInternal(this, part, baseSource.CombineInfo.transformMatrix);
+				_parts.Add(dynamicCombinedObjectPart);
+				source.Combined(this, dynamicCombinedObjectPart);
+			};
+			baseSource.onCombineErrorTyped += delegate(CombinedObject root, string message)
+			{
+				source.CombineError(this, message);
+			};
+			baseSource.onCombineFailedTyped += delegate
+			{
+				source.CombineFailed(this);
+			};
+		}
+		_baseObject.Combine(array);
+	}
+
+	public void UpdatePart(DynamicCombinedObjectPartInternal part)
+	{
+		_movedParts.Add(part);
+		_movedPartsData.Add(part.CreateMoveInfo());
+		base.enabled = true;
+	}
+
+	public void Destroy(DynamicCombinedObjectPart dynamicPart, CombinedObjectPart basePart)
+	{
+		if (_parts.Remove(dynamicPart))
+		{
+			basePart.Destroy();
+			base.enabled = true;
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObjectMatcher.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObjectMatcher.cs
new file mode 100644
index 0000000..cf76052
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObjectMatcher.cs
@@ -0,0 +1,39 @@
+namespace NGS.MeshFusionPro;
+
+public class DynamicCombinedObjectMatcher : CombinedObjectMatcher<DynamicCombinedObject, DynamicCombineSource>
+{
+	private RendererSettings _settings;
+
+	private int _vertexCount;
+
+	private int _vertexLimit;
+
+	public DynamicCombinedObjectMatcher(int vertexLimit)
+	{
+		_vertexLimit = vertexLimit;
+	}
+
+	public override void StartMatching(DynamicCombinedObject combinedObject)
+	{
+		_settings = combinedObject.RendererSettings;
+		_vertexCount = combinedObject.VertexCount;
+	}
+
+	public override bool CanAddSource(DynamicCombineSource source)
+	{
+		if (!_settings.Equals(source.Base.RendererSettings))
+		{
+			return false;
+		}
+		if (_vertexCount + source.Base.CombineInfo.vertexCount > _vertexLimit)
+		{
+			return false;
+		}
+		return true;
+	}
+
+	public override void SourceAdded(DynamicCombineSource source)
+	{
+		_vertexCount += source.Base.CombineInfo.vertexCount;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObjectPart.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObjectPart.cs
new file mode 100644
index 0000000..c2ff95d
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObjectPart.cs
@@ -0,0 +1,44 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public abstract class DynamicCombinedObjectPart : ICombinedObjectPart<DynamicCombinedObject>, ICombinedObjectPart
+{
+	protected DynamicCombinedObject _root;
+
+	protected CombinedObjectPart _basePart;
+
+	private bool _destroyed;
+
+	ICombinedObject ICombinedObjectPart.Root => Root;
+
+	public DynamicCombinedObject Root => _root;
+
+	public Bounds LocalBounds => _basePart.LocalBounds;
+
+	public Bounds Bounds => _basePart.Bounds;
+
+	public DynamicCombinedObjectPart(DynamicCombinedObject root, CombinedObjectPart basePart, Matrix4x4 transformMatrix)
+	{
+		_root = root;
+		_basePart = basePart;
+	}
+
+	public abstract void Move(Vector3 position, Quaternion rotation, Vector3 scale);
+
+	public abstract void Move(Matrix4x4 transform);
+
+	public abstract void MoveLocal(Matrix4x4 localTransform);
+
+	public void Destroy()
+	{
+		if (_destroyed)
+		{
+			Debug.Log("Part already destroyed");
+		}
+		else
+		{
+			_root.Destroy(this, _basePart);
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObjectPartInternal.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObjectPartInternal.cs
new file mode 100644
index 0000000..d7a0c1c
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicCombinedObjectPartInternal.cs
@@ -0,0 +1,61 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class DynamicCombinedObjectPartInternal : DynamicCombinedObjectPart
+{
+	private Matrix4x4 _localTransform;
+
+	private Matrix4x4 _targetLocalTransform;
+
+	private Matrix4x4 _worldToLocalMatrix;
+
+	private bool _inMove;
+
+	public DynamicCombinedObjectPartInternal(DynamicCombinedObject root, CombinedObjectPart basePart, Matrix4x4 transformMatrix)
+		: base(root, basePart, transformMatrix)
+	{
+		Vector3 pos = transformMatrix.GetTranslation() - root.transform.position;
+		_localTransform = transformMatrix.SetTranslation(pos);
+		_worldToLocalMatrix = base.Root.transform.worldToLocalMatrix;
+	}
+
+	public override void Move(Vector3 position, Quaternion rotation, Vector3 scale)
+	{
+		Move(Matrix4x4.TRS(position, rotation, scale));
+	}
+
+	public override void Move(Matrix4x4 transform)
+	{
+		Matrix4x4 localTransform = _worldToLocalMatrix * transform;
+		MoveLocal(localTransform);
+	}
+
+	public override void MoveLocal(Matrix4x4 localTransform)
+	{
+		if (!_inMove)
+		{
+			_targetLocalTransform = localTransform;
+			_root.UpdatePart(this);
+			_inMove = true;
+		}
+	}
+
+	public PartMoveInfo CreateMoveInfo()
+	{
+		CombinedMeshPart meshPart = _basePart.MeshPart;
+		PartMoveInfo result = default(PartMoveInfo);
+		result.partIndex = meshPart.Index;
+		result.vertexStart = meshPart.VertexStart;
+		result.vertexCount = meshPart.VertexCount;
+		result.currentTransform = _localTransform;
+		result.targetTransform = _targetLocalTransform;
+		return result;
+	}
+
+	public void PositionUpdated()
+	{
+		_localTransform = _targetLocalTransform;
+		_inMove = false;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicMeshFusionSource.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicMeshFusionSource.cs
new file mode 100644
index 0000000..bf92aec
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicMeshFusionSource.cs
@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class DynamicMeshFusionSource : MeshFusionSource
+{
+	[SerializeField]
+	[HideInInspector]
+	private MeshRenderer _renderer;
+
+	[SerializeField]
+	[HideInInspector]
+	private MeshFilter _filter;
+
+	[SerializeField]
+	[HideInInspector]
+	private Mesh _mesh;
+
+	private DynamicCombineSource[] _sources;
+
+	private DynamicCombinedObjectPart[] _parts;
+
+	public override bool TryGetBounds(ref Bounds bounds)
+	{
+		if (_renderer != null)
+		{
+			bounds = _renderer.bounds;
+			return true;
+		}
+		return false;
+	}
+
+	protected override void OnSourceCombinedInternal(ICombinedObject root, ICombinedObjectPart part)
+	{
+		for (int i = 0; i < _parts.Length; i++)
+		{
+			if (_parts[i] == null)
+			{
+				_parts[i] = (DynamicCombinedObjectPart)part;
+				return;
+			}
+		}
+		throw new Exception("Unexpected Behaviour");
+	}
+
+	protected override bool CheckCompatibilityAndGetComponents(out string incompatibilityReason)
+	{
+		incompatibilityReason = "";
+		return CanCreateCombineSource(base.gameObject, ref incompatibilityReason, ref _renderer, ref _filter, ref _mesh);
+	}
+
+	protected override void CreateSources()
+	{
+		if (_sources == null)
+		{
+			_sources = new DynamicCombineSource[_mesh.subMeshCount];
+		}
+		if (_parts == null)
+		{
+			_parts = new DynamicCombinedObjectPart[_mesh.subMeshCount];
+		}
+		for (int i = 0; i < _sources.Length; i++)
+		{
+			_sources[i] = new DynamicCombineSource(_mesh, _renderer, i);
+		}
+	}
+
+	protected override IEnumerable<ICombineSource> GetCombineSources()
+	{
+		if (_sources == null)
+		{
+			yield break;
+		}
+		for (int i = 0; i < _sources.Length; i++)
+		{
+			DynamicCombineSource dynamicCombineSource = _sources[i];
+			if (dynamicCombineSource == null)
+			{
+				break;
+			}
+			yield return dynamicCombineSource;
+		}
+	}
+
+	protected override IEnumerable<ICombinedObjectPart> GetCombinedParts()
+	{
+		if (_parts == null)
+		{
+			yield break;
+		}
+		for (int i = 0; i < _parts.Length; i++)
+		{
+			DynamicCombinedObjectPart dynamicCombinedObjectPart = _parts[i];
+			if (dynamicCombinedObjectPart == null)
+			{
+				break;
+			}
+			yield return dynamicCombinedObjectPart;
+		}
+	}
+
+	protected override void ClearSources()
+	{
+		if (_sources != null)
+		{
+			for (int i = 0; i < _sources.Length && _sources[i] != null; i++)
+			{
+				_sources[i] = null;
+			}
+		}
+	}
+
+	protected override void ClearParts()
+	{
+		if (_parts != null)
+		{
+			for (int i = 0; i < _parts.Length; i++)
+			{
+				_parts[i] = null;
+			}
+		}
+	}
+
+	protected override void ToggleComponents(bool enabled)
+	{
+		_renderer.enabled = enabled;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicObjectsCombiner.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicObjectsCombiner.cs
new file mode 100644
index 0000000..a7d6115
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/DynamicObjectsCombiner.cs
@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+
+namespace NGS.MeshFusionPro;
+
+public class DynamicObjectsCombiner : ObjectsCombiner<DynamicCombinedObject, DynamicCombineSource>
+{
+	private ICombinedMeshFactory _factory;
+
+	private DynamicCombinedObjectMatcher _matcher;
+
+	private int _vertexLimit;
+
+	public DynamicObjectsCombiner(ICombinedMeshFactory factory, int vertexLimit)
+	{
+		_factory = factory;
+		_matcher = new DynamicCombinedObjectMatcher(vertexLimit);
+		_vertexLimit = vertexLimit;
+	}
+
+	public override void AddSource(DynamicCombineSource source)
+	{
+		if (source.Base.CombineInfo.vertexCount < _vertexLimit)
+		{
+			base.AddSource(source);
+		}
+	}
+
+	protected override void CombineSources(DynamicCombinedObject root, IList<DynamicCombineSource> sources)
+	{
+		root.Combine(sources);
+	}
+
+	protected override DynamicCombinedObject CreateCombinedObject(DynamicCombineSource source)
+	{
+		return DynamicCombinedObject.Create(_factory, source.Base.RendererSettings);
+	}
+
+	protected override CombinedObjectMatcher<DynamicCombinedObject, DynamicCombineSource> GetMatcher()
+	{
+		return _matcher;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IAsyncCombinedMeshMover.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IAsyncCombinedMeshMover.cs
new file mode 100644
index 0000000..07f0de8
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IAsyncCombinedMeshMover.cs
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace NGS.MeshFusionPro;
+
+public interface IAsyncCombinedMeshMover : ICombinedMeshMover
+{
+	void MovePartsAsync(IList<PartMoveInfo> moveInfos);
+
+	void FinishAsyncMoving();
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IBinaryTreeNode.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IBinaryTreeNode.cs
new file mode 100644
index 0000000..c25beae
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IBinaryTreeNode.cs
@@ -0,0 +1,20 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public interface IBinaryTreeNode
+{
+	Vector3 Center { get; }
+
+	Vector3 Size { get; }
+
+	Bounds Bounds { get; }
+
+	bool HasChilds { get; }
+
+	bool IsLeaf { get; }
+
+	IBinaryTreeNode GetLeft();
+
+	IBinaryTreeNode GetRight();
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombineSource.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombineSource.cs
new file mode 100644
index 0000000..2b147b7
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombineSource.cs
@@ -0,0 +1,25 @@
+using System;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public interface ICombineSource
+{
+	Vector3 Position { get; }
+
+	Bounds Bounds { get; }
+
+	event Action<ICombinedObject, ICombinedObjectPart> onCombined;
+
+	event Action<ICombinedObject, string> onCombineError;
+
+	event Action<ICombinedObject> onCombineFailed;
+}
+public interface ICombineSource<TCombinedObject, TCombinedPart> : ICombineSource where TCombinedObject : ICombinedObject where TCombinedPart : ICombinedObjectPart
+{
+	event Action<TCombinedObject, TCombinedPart> onCombinedTyped;
+
+	event Action<TCombinedObject, string> onCombineErrorTyped;
+
+	event Action<TCombinedObject> onCombineFailedTyped;
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedMeshFactory.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedMeshFactory.cs
new file mode 100644
index 0000000..98d71f7
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedMeshFactory.cs
@@ -0,0 +1,8 @@
+namespace NGS.MeshFusionPro;
+
+public interface ICombinedMeshFactory
+{
+	CombinedMesh CreateCombinedMesh();
+
+	CombinedMesh CreateMovableCombinedMesh(out ICombinedMeshMover mover);
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedMeshMover.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedMeshMover.cs
new file mode 100644
index 0000000..05560a1
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedMeshMover.cs
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace NGS.MeshFusionPro;
+
+public interface ICombinedMeshMover
+{
+	void MoveParts(IList<PartMoveInfo> moveInfos);
+
+	void ApplyData();
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedObject.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedObject.cs
new file mode 100644
index 0000000..5c2bb55
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedObject.cs
@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace NGS.MeshFusionPro;
+
+public interface ICombinedObject
+{
+	IReadOnlyList<ICombinedObjectPart> Parts { get; }
+
+	void Combine(IEnumerable<ICombineSource> sources);
+}
+public interface ICombinedObject<TCombinedPart, TCombinedSource> : ICombinedObject where TCombinedPart : ICombinedObjectPart where TCombinedSource : ICombineSource
+{
+	new IReadOnlyList<TCombinedPart> Parts { get; }
+
+	void Combine(IEnumerable<TCombinedSource> sources);
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedObjectPart.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedObjectPart.cs
new file mode 100644
index 0000000..b5a0f08
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ICombinedObjectPart.cs
@@ -0,0 +1,18 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public interface ICombinedObjectPart
+{
+	ICombinedObject Root { get; }
+
+	Bounds Bounds { get; }
+
+	Bounds LocalBounds { get; }
+
+	void Destroy();
+}
+public interface ICombinedObjectPart<TCombinedObject> : ICombinedObjectPart where TCombinedObject : ICombinedObject
+{
+	new TCombinedObject Root { get; }
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMeshCombiner.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMeshCombiner.cs
new file mode 100644
index 0000000..ccd84ce
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMeshCombiner.cs
@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public interface IMeshCombiner
+{
+	void Combine(Mesh mesh, IList<MeshCombineInfo> combineInfos);
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMeshCutter.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMeshCutter.cs
new file mode 100644
index 0000000..f9af704
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMeshCutter.cs
@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public interface IMeshCutter
+{
+	void Cut(Mesh mesh, MeshCuttingInfo cuttingInfo);
+
+	void Cut(Mesh mesh, IList<MeshCuttingInfo> cuttingInfos);
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMeshToolsFactory.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMeshToolsFactory.cs
new file mode 100644
index 0000000..2d670e2
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMeshToolsFactory.cs
@@ -0,0 +1,8 @@
+namespace NGS.MeshFusionPro;
+
+public interface IMeshToolsFactory
+{
+	IMeshCombiner CreateMeshCombiner();
+
+	IMeshCutter CreateMeshCutter();
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMovableCombinedMeshFactory.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMovableCombinedMeshFactory.cs
new file mode 100644
index 0000000..555d632
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/IMovableCombinedMeshFactory.cs
@@ -0,0 +1,6 @@
+namespace NGS.MeshFusionPro;
+
+public interface IMovableCombinedMeshFactory
+{
+	CombinedMesh CreateMovableMesh(out ICombinedMeshMover mover);
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ISourceTrackingStrategy.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ISourceTrackingStrategy.cs
new file mode 100644
index 0000000..ba5db36
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ISourceTrackingStrategy.cs
@@ -0,0 +1,6 @@
+namespace NGS.MeshFusionPro;
+
+public interface ISourceTrackingStrategy
+{
+	bool OnUpdate();
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMeshMoverLW.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMeshMoverLW.cs
new file mode 100644
index 0000000..b2ea31d
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMeshMoverLW.cs
@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Jobs;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class JobsMeshMoverLW : IAsyncCombinedMeshMover, ICombinedMeshMover, IDisposable
+{
+	[BurstCompile]
+	private struct MovePartsJob : IJobParallelFor
+	{
+		[NativeDisableParallelForRestriction]
+		public NativeArray<LightweightVertex> vertices;
+
+		[ReadOnly]
+		public NativeArray<LightweightVertex> localVertices;
+
+		[WriteOnly]
+		[NativeDisableParallelForRestriction]
+		public NativeArray<Bounds> bounds;
+
+		[ReadOnly]
+		[NativeDisableParallelForRestriction]
+		public NativeArray<Bounds> localBounds;
+
+		[ReadOnly]
+		public NativeList<PartMoveInfo> moveInfos;
+
+		public void Execute(int idx)
+		{
+			PartMoveInfo partMoveInfo = moveInfos[idx];
+			int partIndex = partMoveInfo.partIndex;
+			int vertexStart = partMoveInfo.vertexStart;
+			int num = vertexStart + partMoveInfo.vertexCount;
+			Matrix4x4 targetTransform = partMoveInfo.targetTransform;
+			for (int i = vertexStart; i < num; i++)
+			{
+				LightweightVertex lightweightVertex = localVertices[i];
+				float w = lightweightVertex.tanW;
+				Vector3 normalized = targetTransform.MultiplyVector(lightweightVertex.Normal).normalized;
+				Vector4 tangent = targetTransform.MultiplyVector(lightweightVertex.Tangent).normalized;
+				tangent.w = w;
+				LightweightVertex lightweightVertex2 = default(LightweightVertex);
+				lightweightVertex2.Position = targetTransform.MultiplyPoint3x4(lightweightVertex.Position);
+				lightweightVertex2.Normal = normalized;
+				lightweightVertex2.Tangent = tangent;
+				lightweightVertex2.uv = lightweightVertex.uv;
+				lightweightVertex2.uv2 = lightweightVertex.uv2;
+				LightweightVertex value = lightweightVertex2;
+				vertices[i] = value;
+			}
+			bounds[partIndex] = localBounds[partIndex].Transform(targetTransform);
+		}
+	}
+
+	[BurstCompile]
+	private struct RecalculateBoundsJob : IJob
+	{
+		public NativeArray<Bounds> bounds;
+
+		public NativeArray<Bounds> boundingBox;
+
+		public void Execute()
+		{
+			Bounds value = boundingBox[0];
+			value.size = Vector3.zero;
+			for (int i = 0; i < bounds.Length; i++)
+			{
+				value.Encapsulate(bounds[i]);
+			}
+			boundingBox[0] = value;
+		}
+	}
+
+	private MeshDataNativeArraysLW _meshData;
+
+	private NativeList<PartMoveInfo> _moveInfos;
+
+	private JobHandle _handle;
+
+	public JobsMeshMoverLW(MeshDataNativeArraysLW meshData)
+	{
+		_meshData = meshData;
+		_moveInfos = new NativeList<PartMoveInfo>(Allocator.Persistent);
+	}
+
+	public void MoveParts(IList<PartMoveInfo> moveInfos)
+	{
+		MovePartsAsync(moveInfos);
+		FinishAsyncMoving();
+	}
+
+	public void MovePartsAsync(IList<PartMoveInfo> moveInfos)
+	{
+		NativeArray<Bounds> bounds = _meshData.Bounds;
+		bounds[0] = new Bounds(_meshData.GetBounds().center, Vector3.zero);
+		_moveInfos.Clear();
+		for (int i = 0; i < moveInfos.Count; i++)
+		{
+			ref NativeList<PartMoveInfo> moveInfos2 = ref _moveInfos;
+			PartMoveInfo value = moveInfos[i];
+			moveInfos2.Add(in value);
+		}
+		MovePartsJob movePartsJob = default(MovePartsJob);
+		movePartsJob.vertices = _meshData.Vertices;
+		movePartsJob.bounds = _meshData.PartsBounds;
+		movePartsJob.localVertices = _meshData.VerticesLocal;
+		movePartsJob.localBounds = _meshData.PartsBoundsLocal;
+		movePartsJob.moveInfos = _moveInfos;
+		MovePartsJob jobData = movePartsJob;
+		RecalculateBoundsJob recalculateBoundsJob = default(RecalculateBoundsJob);
+		recalculateBoundsJob.bounds = _meshData.PartsBounds;
+		recalculateBoundsJob.boundingBox = bounds;
+		RecalculateBoundsJob jobData2 = recalculateBoundsJob;
+		_handle = jobData2.Schedule(IJobParallelForExtensions.Schedule(jobData, _moveInfos.Length, 4));
+	}
+
+	public void FinishAsyncMoving()
+	{
+		_handle.Complete();
+	}
+
+	public void ApplyData()
+	{
+		if (!_handle.IsCompleted)
+		{
+			FinishAsyncMoving();
+		}
+		_meshData.ApplyDataToMesh();
+	}
+
+	public void Dispose()
+	{
+		_moveInfos.Dispose();
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMeshMoverSTD.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMeshMoverSTD.cs
new file mode 100644
index 0000000..535b8af
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMeshMoverSTD.cs
@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Jobs;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class JobsMeshMoverSTD : IAsyncCombinedMeshMover, ICombinedMeshMover, IDisposable
+{
+	[BurstCompile]
+	private struct MovePartsJob : IJobParallelFor
+	{
+		[NativeDisableParallelForRestriction]
+		public NativeArray<Vector3> vertices;
+
+		[NativeDisableParallelForRestriction]
+		public NativeArray<Vector3> normals;
+
+		[NativeDisableParallelForRestriction]
+		public NativeArray<Vector4> tangents;
+
+		[WriteOnly]
+		[NativeDisableParallelForRestriction]
+		public NativeArray<Bounds> bounds;
+
+		[ReadOnly]
+		[NativeDisableParallelForRestriction]
+		public NativeArray<Bounds> localBounds;
+
+		[ReadOnly]
+		public NativeList<PartMoveInfo> moveInfos;
+
+		public void Execute(int idx)
+		{
+			PartMoveInfo partMoveInfo = moveInfos[idx];
+			int partIndex = partMoveInfo.partIndex;
+			int vertexStart = partMoveInfo.vertexStart;
+			int num = vertexStart + partMoveInfo.vertexCount;
+			Matrix4x4 targetTransform = partMoveInfo.targetTransform;
+			Matrix4x4 inverse = partMoveInfo.currentTransform.inverse;
+			for (int i = vertexStart; i < num; i++)
+			{
+				Vector3 point = vertices[i];
+				Vector3 vector = normals[i];
+				Vector4 vector2 = tangents[i];
+				float w = vector2.w;
+				point = inverse.MultiplyPoint3x4(point);
+				point = targetTransform.MultiplyPoint3x4(point);
+				vector = inverse.MultiplyVector(vector);
+				vector = targetTransform.MultiplyVector(vector);
+				vector2 = inverse.MultiplyVector(vector2);
+				vector2 = targetTransform.MultiplyVector(vector2);
+				vector2.w = w;
+				vertices[i] = point;
+				normals[i] = vector;
+				tangents[i] = vector2;
+			}
+			bounds[partIndex] = localBounds[partIndex].Transform(targetTransform);
+		}
+	}
+
+	[BurstCompile]
+	private struct RecalculateBoundsJob : IJob
+	{
+		public NativeArray<Bounds> bounds;
+
+		public NativeArray<Bounds> boundingBox;
+
+		public void Execute()
+		{
+			Bounds value = boundingBox[0];
+			for (int i = 0; i < bounds.Length; i++)
+			{
+				value.Encapsulate(bounds[i]);
+			}
+			boundingBox[0] = value;
+		}
+	}
+
+	private MeshDataNativeArraysSTD _meshData;
+
+	private NativeList<PartMoveInfo> _moveInfos;
+
+	private JobHandle _handle;
+
+	public JobsMeshMoverSTD(MeshDataNativeArraysSTD meshData)
+	{
+		_meshData = meshData;
+		_moveInfos = new NativeList<PartMoveInfo>(Allocator.Persistent);
+	}
+
+	public void MoveParts(IList<PartMoveInfo> moveInfos)
+	{
+		MovePartsAsync(moveInfos);
+		FinishAsyncMoving();
+	}
+
+	public void MovePartsAsync(IList<PartMoveInfo> moveInfos)
+	{
+		NativeArray<Bounds> bounds = _meshData.Bounds;
+		bounds[0] = new Bounds(_meshData.GetBounds().center, Vector3.zero);
+		_moveInfos.Clear();
+		for (int i = 0; i < moveInfos.Count; i++)
+		{
+			ref NativeList<PartMoveInfo> moveInfos2 = ref _moveInfos;
+			PartMoveInfo value = moveInfos[i];
+			moveInfos2.Add(in value);
+		}
+		MovePartsJob movePartsJob = default(MovePartsJob);
+		movePartsJob.vertices = _meshData.Vertices;
+		movePartsJob.normals = _meshData.Normals;
+		movePartsJob.tangents = _meshData.Tangents;
+		movePartsJob.bounds = _meshData.PartsBounds;
+		movePartsJob.localBounds = _meshData.PartsBoundsLocal;
+		movePartsJob.moveInfos = _moveInfos;
+		MovePartsJob jobData = movePartsJob;
+		RecalculateBoundsJob recalculateBoundsJob = default(RecalculateBoundsJob);
+		recalculateBoundsJob.bounds = _meshData.PartsBounds;
+		recalculateBoundsJob.boundingBox = bounds;
+		RecalculateBoundsJob jobData2 = recalculateBoundsJob;
+		_handle = jobData2.Schedule(IJobParallelForExtensions.Schedule(jobData, _moveInfos.Length, 4));
+	}
+
+	public void FinishAsyncMoving()
+	{
+		_handle.Complete();
+	}
+
+	public void ApplyData()
+	{
+		if (!_handle.IsCompleted)
+		{
+			FinishAsyncMoving();
+		}
+		_meshData.ApplyDataToMesh();
+	}
+
+	public void Dispose()
+	{
+		_moveInfos.Dispose();
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMovableMeshLWFactory.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMovableMeshLWFactory.cs
new file mode 100644
index 0000000..4790976
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMovableMeshLWFactory.cs
@@ -0,0 +1,18 @@
+namespace NGS.MeshFusionPro;
+
+public class JobsMovableMeshLWFactory : IMovableCombinedMeshFactory
+{
+	private IMeshToolsFactory _tools;
+
+	public JobsMovableMeshLWFactory(IMeshToolsFactory tools)
+	{
+		_tools = tools;
+	}
+
+	public CombinedMesh CreateMovableMesh(out ICombinedMeshMover mover)
+	{
+		CombinedMesh<MeshDataNativeArraysLW> combinedMesh = new CombinedMesh<MeshDataNativeArraysLW>(_tools.CreateMeshCombiner(), _tools.CreateMeshCutter());
+		mover = new JobsMeshMoverLW(combinedMesh.MeshDataInternal);
+		return combinedMesh;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMovableMeshSTDFactory.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMovableMeshSTDFactory.cs
new file mode 100644
index 0000000..36402f5
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/JobsMovableMeshSTDFactory.cs
@@ -0,0 +1,18 @@
+namespace NGS.MeshFusionPro;
+
+public class JobsMovableMeshSTDFactory : IMovableCombinedMeshFactory
+{
+	private IMeshToolsFactory _tools;
+
+	public JobsMovableMeshSTDFactory(IMeshToolsFactory tools)
+	{
+		_tools = tools;
+	}
+
+	public CombinedMesh CreateMovableMesh(out ICombinedMeshMover mover)
+	{
+		CombinedMesh<MeshDataNativeArraysSTD> combinedMesh = new CombinedMesh<MeshDataNativeArraysSTD>(_tools.CreateMeshCombiner(), _tools.CreateMeshCutter());
+		mover = new JobsMeshMoverSTD(combinedMesh.MeshDataInternal);
+		return combinedMesh;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODGroupCombineSource.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODGroupCombineSource.cs
new file mode 100644
index 0000000..66c640b
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODGroupCombineSource.cs
@@ -0,0 +1,106 @@
+using System;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class LODGroupCombineSource : ICombineSource<CombinedLODGroup, CombinedLODGroupPart>, ICombineSource
+{
+	private Bounds _bounds;
+
+	private LODGroupSettings _settings;
+
+	private CombineSource[][] _sources;
+
+	public Vector3 Position { get; private set; }
+
+	public Bounds Bounds => _bounds;
+
+	public LODGroup LODGroup { get; private set; }
+
+	public LODGroupSettings Settings => _settings;
+
+	public CombineSource[][] BaseSources => _sources;
+
+	public event Action<ICombinedObject, ICombinedObjectPart> onCombined;
+
+	public event Action<ICombinedObject, string> onCombineError;
+
+	public event Action<ICombinedObject> onCombineFailed;
+
+	public event Action<CombinedLODGroup, CombinedLODGroupPart> onCombinedTyped;
+
+	public event Action<CombinedLODGroup, string> onCombineErrorTyped;
+
+	public event Action<CombinedLODGroup> onCombineFailedTyped;
+
+	public LODGroupCombineSource(LODGroup group)
+	{
+		LODGroup = group;
+		Position = group.transform.position;
+		LOD[] lODs = group.GetLODs();
+		_settings = new LODGroupSettings(group);
+		_sources = new CombineSource[_settings.lodCount][];
+		_bounds = new Bounds(group.localReferencePoint + Position, Vector3.zero);
+		for (int i = 0; i < lODs.Length; i++)
+		{
+			Renderer[] renderers = lODs[i].renderers;
+			CreateSourcesArray(i, renderers);
+			FillSources(i, renderers);
+		}
+	}
+
+	public void Combined(CombinedLODGroup root, CombinedLODGroupPart part)
+	{
+		this.onCombined?.Invoke(root, part);
+		this.onCombinedTyped?.Invoke(root, part);
+	}
+
+	public void CombineError(CombinedLODGroup root, string errorMessage)
+	{
+		if (this.onCombineError == null && this.onCombineErrorTyped == null)
+		{
+			Debug.Log("Combine error occured : " + root.name + ", reason : " + errorMessage);
+			return;
+		}
+		this.onCombineError?.Invoke(root, errorMessage);
+		this.onCombineErrorTyped?.Invoke(root, errorMessage);
+	}
+
+	public void CombineFailed(CombinedLODGroup root)
+	{
+		this.onCombineFailed?.Invoke(root);
+		this.onCombineFailedTyped?.Invoke(root);
+	}
+
+	private void CreateSourcesArray(int level, Renderer[] renderers)
+	{
+		int num = 0;
+		for (int i = 0; i < renderers.Length; i++)
+		{
+			if (!(renderers[i] == null))
+			{
+				num += renderers[i].sharedMaterials.Length;
+			}
+		}
+		_sources[level] = new CombineSource[num];
+	}
+
+	private void FillSources(int level, Renderer[] renderers)
+	{
+		int num = 0;
+		for (int i = 0; i < renderers.Length; i++)
+		{
+			MeshRenderer meshRenderer = (MeshRenderer)renderers[i];
+			if (!(meshRenderer == null))
+			{
+				Mesh sharedMesh = meshRenderer.GetComponent<MeshFilter>().sharedMesh;
+				for (int j = 0; j < sharedMesh.subMeshCount; j++)
+				{
+					_sources[level][num] = new CombineSource(sharedMesh, meshRenderer, j);
+					num++;
+				}
+				_bounds.Encapsulate(meshRenderer.bounds);
+			}
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODGroupSettings.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODGroupSettings.cs
new file mode 100644
index 0000000..b0d123f
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODGroupSettings.cs
@@ -0,0 +1,63 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public struct LODGroupSettings
+{
+	public float size;
+
+	public int lodCount;
+
+	public LODFadeMode fadeMode;
+
+	public bool animateCrossFading;
+
+	public float[] screenTransitionsHeight;
+
+	public float[] fadeTransitionsWidth;
+
+	public LODGroupSettings(LODGroup group)
+	{
+		size = group.size;
+		lodCount = group.lodCount;
+		fadeMode = group.fadeMode;
+		animateCrossFading = group.animateCrossFading;
+		screenTransitionsHeight = new float[lodCount];
+		fadeTransitionsWidth = new float[lodCount];
+		LOD[] lODs = group.GetLODs();
+		for (int i = 0; i < lodCount; i++)
+		{
+			LOD lOD = lODs[i];
+			screenTransitionsHeight[i] = lOD.screenRelativeTransitionHeight;
+			fadeTransitionsWidth[i] = lOD.fadeTransitionWidth;
+		}
+	}
+
+	public bool IsEqual(LODGroupSettings settings, float screenHeightThreshold = 0.0001f, float fadeWidthThreshold = 0.0001f)
+	{
+		if (lodCount != settings.lodCount)
+		{
+			return false;
+		}
+		if (fadeMode != settings.fadeMode)
+		{
+			return false;
+		}
+		if (animateCrossFading != settings.animateCrossFading)
+		{
+			return false;
+		}
+		for (int i = 0; i < lodCount; i++)
+		{
+			if (Mathf.Abs(screenTransitionsHeight[i] - settings.screenTransitionsHeight[i]) > screenHeightThreshold)
+			{
+				return false;
+			}
+			if (Mathf.Abs(fadeTransitionsWidth[i] - settings.fadeTransitionsWidth[i]) > fadeWidthThreshold)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODGroupsCombiner.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODGroupsCombiner.cs
new file mode 100644
index 0000000..961bf28
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODGroupsCombiner.cs
@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+
+namespace NGS.MeshFusionPro;
+
+public class LODGroupsCombiner : ObjectsCombiner<CombinedLODGroup, LODGroupCombineSource>
+{
+	private ICombinedMeshFactory _factory;
+
+	private CombinedLODGroupMatcher _matcher;
+
+	private int _vertexLimit;
+
+	public LODGroupsCombiner(ICombinedMeshFactory factory, int vertexLimit)
+	{
+		_factory = factory;
+		_matcher = new CombinedLODGroupMatcher();
+		_vertexLimit = vertexLimit;
+	}
+
+	protected override CombinedLODGroup CreateCombinedObject(LODGroupCombineSource source)
+	{
+		return CombinedLODGroup.Create(_factory, source.Settings, _vertexLimit);
+	}
+
+	protected override void CombineSources(CombinedLODGroup root, IList<LODGroupCombineSource> sources)
+	{
+		root.Combine(sources);
+	}
+
+	protected override CombinedObjectMatcher<CombinedLODGroup, LODGroupCombineSource> GetMatcher()
+	{
+		return _matcher;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODMeshFusionSource.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODMeshFusionSource.cs
new file mode 100644
index 0000000..4b941b9
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LODMeshFusionSource.cs
@@ -0,0 +1,141 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class LODMeshFusionSource : MeshFusionSource
+{
+	[SerializeField]
+	[HideInInspector]
+	private LODGroup _group;
+
+	private LODGroupCombineSource _source;
+
+	private CombinedLODGroupPart _part;
+
+	private Bounds? _savedBounds;
+
+	public override bool TryGetBounds(ref Bounds bounds)
+	{
+		if (_source != null)
+		{
+			bounds = _source.Bounds;
+			return true;
+		}
+		if (_part != null)
+		{
+			bounds = _part.Bounds;
+			return true;
+		}
+		if (_savedBounds.HasValue)
+		{
+			bounds = _savedBounds.Value;
+			return true;
+		}
+		if (base.IsIncompatible)
+		{
+			return false;
+		}
+		LOD[] lODs = _group.GetLODs();
+		bounds = new Bounds(base.transform.position, Vector3.zero);
+		for (int i = 0; i < lODs.Length; i++)
+		{
+			Renderer[] renderers = lODs[i].renderers;
+			for (int j = 0; j < renderers.Length; j++)
+			{
+				if (!(renderers[j] == null))
+				{
+					bounds.Encapsulate(renderers[j].bounds);
+				}
+			}
+		}
+		_savedBounds = bounds;
+		return true;
+	}
+
+	protected override void OnSourceCombinedInternal(ICombinedObject root, ICombinedObjectPart part)
+	{
+		_part = (CombinedLODGroupPart)part;
+	}
+
+	protected override bool CheckCompatibilityAndGetComponents(out string incompatibilityReason)
+	{
+		if (_group == null)
+		{
+			_group = GetComponent<LODGroup>();
+		}
+		if (_group == null)
+		{
+			incompatibilityReason = "LODGroup not found";
+			return false;
+		}
+		incompatibilityReason = "";
+		MeshFilter filter = null;
+		Mesh mesh = null;
+		LOD[] lODs = _group.GetLODs();
+		for (int i = 0; i < lODs.Length; i++)
+		{
+			Renderer[] renderers = lODs[i].renderers;
+			for (int j = 0; j < renderers.Length; j++)
+			{
+				MeshRenderer renderer = renderers[j] as MeshRenderer;
+				if (!(renderer == null) && !CanCreateCombineSource(renderer.gameObject, ref incompatibilityReason, ref renderer, ref filter, ref mesh))
+				{
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	protected override void CreateSources()
+	{
+		_source = new LODGroupCombineSource(_group);
+	}
+
+	protected override IEnumerable<ICombineSource> GetCombineSources()
+	{
+		if (_source != null)
+		{
+			yield return _source;
+		}
+	}
+
+	protected override IEnumerable<ICombinedObjectPart> GetCombinedParts()
+	{
+		if (_part != null)
+		{
+			yield return _part;
+		}
+	}
+
+	protected override void ClearSources()
+	{
+		if (_source != null)
+		{
+			_source = null;
+		}
+	}
+
+	protected override void ClearParts()
+	{
+		if (_part != null)
+		{
+			_part = null;
+		}
+	}
+
+	protected override void ToggleComponents(bool enabled)
+	{
+		LOD[] lODs = _group.GetLODs();
+		for (int i = 0; i < lODs.Length; i++)
+		{
+			Renderer[] renderers = lODs[i].renderers;
+			for (int j = 0; j < renderers.Length; j++)
+			{
+				renderers[j].enabled = enabled;
+			}
+		}
+		_group.enabled = enabled;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LightweightVertex.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LightweightVertex.cs
new file mode 100644
index 0000000..5c5de9e
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/LightweightVertex.cs
@@ -0,0 +1,95 @@
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public struct LightweightVertex
+{
+	public float3 pos;
+
+	public sbyte normX;
+
+	public sbyte normY;
+
+	public sbyte normZ;
+
+	public sbyte normW;
+
+	public sbyte tanX;
+
+	public sbyte tanY;
+
+	public sbyte tanZ;
+
+	public sbyte tanW;
+
+	public half2 uv;
+
+	public half2 uv2;
+
+	public Vector3 Position
+	{
+		get
+		{
+			return pos;
+		}
+		set
+		{
+			pos = value;
+		}
+	}
+
+	public Vector3 Normal
+	{
+		get
+		{
+			return new Vector3((float)normX / 127f, (float)normY / 127f, (float)normZ / 127f);
+		}
+		set
+		{
+			normX = (sbyte)(value.x * 127f);
+			normY = (sbyte)(value.y * 127f);
+			normZ = (sbyte)(value.z * 127f);
+			normW = 1;
+		}
+	}
+
+	public Vector4 Tangent
+	{
+		get
+		{
+			return new Vector4((float)tanX / 127f, (float)tanY / 127f, (float)tanZ / 127f, (float)tanW / 127f);
+		}
+		set
+		{
+			tanX = (sbyte)(value.x * 127f);
+			tanY = (sbyte)(value.y * 127f);
+			tanZ = (sbyte)(value.z * 127f);
+			tanW = (sbyte)(value.w * 127f);
+		}
+	}
+
+	public Vector2 UV
+	{
+		get
+		{
+			return new Vector2(uv.x, uv.y);
+		}
+		set
+		{
+			uv = new half2((half)value.x, (half)value.y);
+		}
+	}
+
+	public Vector2 UV2
+	{
+		get
+		{
+			return new Vector2(uv2.x, uv2.y);
+		}
+		set
+		{
+			uv2 = new half2((half)value.x, (half)value.y);
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MatrixHelper.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MatrixHelper.cs
new file mode 100644
index 0000000..feb92b1
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MatrixHelper.cs
@@ -0,0 +1,18 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public static class MatrixHelper
+{
+	public static Vector3 GetTranslation(this Matrix4x4 matrix)
+	{
+		return matrix.GetColumn(3);
+	}
+
+	public static Matrix4x4 SetTranslation(this Matrix4x4 matrix, Vector3 pos)
+	{
+		Matrix4x4 result = matrix;
+		result.SetColumn(3, new Vector4(pos.x, pos.y, pos.z, 1f));
+		return result;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombineInfo.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombineInfo.cs
new file mode 100644
index 0000000..ed879cb
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombineInfo.cs
@@ -0,0 +1,43 @@
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace NGS.MeshFusionPro;
+
+public struct MeshCombineInfo
+{
+	public Mesh mesh;
+
+	public Matrix4x4 transformMatrix;
+
+	public Vector4 lightmapScaleOffset;
+
+	public Vector4 realtimeLightmapScaleOffset;
+
+	public int submeshIndex;
+
+	public readonly int vertexCount;
+
+	public readonly int trianglesCount;
+
+	public MeshCombineInfo(Mesh mesh, int submeshIndex = 0)
+		: this(mesh, Matrix4x4.identity, submeshIndex)
+	{
+	}
+
+	public MeshCombineInfo(Mesh mesh, Matrix4x4 transformMatrix, int submeshIndex = 0)
+		: this(mesh, transformMatrix, new Vector4(1f, 1f, 0f, 0f), new Vector4(1f, 1f, 0f, 0f), submeshIndex)
+	{
+	}
+
+	public MeshCombineInfo(Mesh mesh, Matrix4x4 transformMatrix, Vector4 lightmapScaleOffset, Vector4 realtimeLightmapScaleOffset, int submeshIndex = 0)
+	{
+		this.mesh = mesh;
+		this.transformMatrix = transformMatrix;
+		this.lightmapScaleOffset = lightmapScaleOffset;
+		this.realtimeLightmapScaleOffset = realtimeLightmapScaleOffset;
+		this.submeshIndex = submeshIndex;
+		SubMeshDescriptor subMesh = mesh.GetSubMesh(submeshIndex);
+		vertexCount = subMesh.vertexCount;
+		trianglesCount = subMesh.indexCount;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombinerBase.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombinerBase.cs
new file mode 100644
index 0000000..34804fd
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombinerBase.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public abstract class MeshCombinerBase : IMeshCombiner
+{
+	public void Combine(Mesh mesh, IList<MeshCombineInfo> infos)
+	{
+		ValidateMesh(mesh);
+		ValidateCombineInfos(infos);
+		CombineInternal(mesh, infos);
+	}
+
+	protected abstract void CombineInternal(Mesh mesh, IList<MeshCombineInfo> infos);
+
+	protected virtual void ValidateMesh(Mesh mesh)
+	{
+		if (mesh == null)
+		{
+			throw new ArgumentNullException("mesh");
+		}
+		if (mesh.subMeshCount > 1)
+		{
+			throw new ArgumentException("BaseMeshCombiner::input 'mesh' should have 1 submesh");
+		}
+	}
+
+	protected virtual void ValidateCombineInfos(IList<MeshCombineInfo> infos)
+	{
+		if (infos == null)
+		{
+			throw new ArgumentNullException("MeshCombineInfos is null");
+		}
+		for (int i = 0; i < infos.Count; i++)
+		{
+			if (infos[i].mesh == null)
+			{
+				throw new ArgumentNullException("MeshCombineInfo.mesh is null");
+			}
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombinerSimpleLW.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombinerSimpleLW.cs
new file mode 100644
index 0000000..50e6031
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombinerSimpleLW.cs
@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class MeshCombinerSimpleLW : MeshCombinerBase
+{
+	private MeshCombinerSimpleSTD _stdCombiner;
+
+	public MeshCombinerSimpleLW()
+	{
+		_stdCombiner = new MeshCombinerSimpleSTD();
+	}
+
+	protected override void CombineInternal(Mesh mesh, IList<MeshCombineInfo> infos)
+	{
+		VertexBufferUtil.ToStandardBuffer(mesh);
+		try
+		{
+			_stdCombiner.Combine(mesh, infos);
+			VertexBufferUtil.ToLightweightBuffer(mesh);
+		}
+		catch
+		{
+			VertexBufferUtil.ToLightweightBuffer(mesh);
+			throw;
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombinerSimpleSTD.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombinerSimpleSTD.cs
new file mode 100644
index 0000000..3e9fb86
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCombinerSimpleSTD.cs
@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class MeshCombinerSimpleSTD : MeshCombinerBase
+{
+	private MeshSeparatorSimple _meshSeparator;
+
+	public MeshCombinerSimpleSTD()
+	{
+		_meshSeparator = new MeshSeparatorSimple();
+	}
+
+	protected override void CombineInternal(Mesh mesh, IList<MeshCombineInfo> infos)
+	{
+		CombineInstance[] array = new CombineInstance[infos.Count + 1];
+		Mesh mesh2 = Object.Instantiate(mesh);
+		array[0] = CreateCombineInstance(new MeshCombineInfo(mesh2));
+		for (int i = 0; i < infos.Count; i++)
+		{
+			array[i + 1] = CreateCombineInstance(infos[i]);
+		}
+		mesh.CombineMeshes(array, mergeSubMeshes: true, useMatrices: true, hasLightmapData: true);
+	}
+
+	private CombineInstance CreateCombineInstance(MeshCombineInfo info)
+	{
+		Mesh mesh = info.mesh;
+		if (mesh.subMeshCount > 1)
+		{
+			mesh = _meshSeparator.GetSubmesh(mesh, info.submeshIndex);
+		}
+		CombineInstance result = default(CombineInstance);
+		result.mesh = mesh;
+		result.subMeshIndex = 0;
+		result.transform = info.transformMatrix;
+		result.lightmapScaleOffset = info.lightmapScaleOffset;
+		result.realtimeLightmapScaleOffset = info.realtimeLightmapScaleOffset;
+		return result;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCutterSimpleLW.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCutterSimpleLW.cs
new file mode 100644
index 0000000..4a70c56
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCutterSimpleLW.cs
@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Unity.Collections;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class MeshCutterSimpleLW : IMeshCutter
+{
+	private static List<int> _triangles;
+
+	static MeshCutterSimpleLW()
+	{
+		_triangles = new List<int>();
+	}
+
+	public void Cut(Mesh mesh, MeshCuttingInfo info)
+	{
+		Cut(mesh, new MeshCuttingInfo[1] { info });
+	}
+
+	public void Cut(Mesh mesh, IList<MeshCuttingInfo> infos)
+	{
+		ValidateMeshOrThrowException(mesh);
+		mesh.GetTriangles(_triangles, 0);
+		using (Mesh.MeshDataArray meshDataArray = Mesh.AcquireReadOnlyMeshData(mesh))
+		{
+			NativeArray<LightweightVertex> other = meshDataArray[0].GetVertexData<LightweightVertex>();
+			NativeList<LightweightVertex> nativeList = new NativeList<LightweightVertex>(Allocator.Temp);
+			nativeList.CopyFrom(in other);
+			foreach (MeshCuttingInfo item in infos.OrderByDescending((MeshCuttingInfo i) => i.triangleStart))
+			{
+				nativeList.RemoveRange(item.vertexStart, item.vertexCount);
+				_triangles.RemoveRange(item.triangleStart, item.triangleCount);
+				OffsetTriangles(item);
+			}
+			mesh.SetTriangles(_triangles, 0);
+			mesh.SetVertexBufferData<LightweightVertex>(nativeList, 0, 0, nativeList.Length);
+		}
+		_triangles.Clear();
+	}
+
+	private void ValidateMeshOrThrowException(Mesh mesh)
+	{
+		if (mesh == null)
+		{
+			throw new ArgumentNullException("mesh");
+		}
+		if (mesh.subMeshCount > 1)
+		{
+			throw new ArgumentException("SimpleMeshCutter::'mesh' should has only 1 submesh");
+		}
+	}
+
+	private void OffsetTriangles(MeshCuttingInfo info)
+	{
+		int vertexCount = info.vertexCount;
+		int triangleStart = info.triangleStart;
+		int count = _triangles.Count;
+		for (int i = triangleStart; i < count; i++)
+		{
+			_triangles[i] -= vertexCount;
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCutterSimpleSTD.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCutterSimpleSTD.cs
new file mode 100644
index 0000000..950f0e9
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCutterSimpleSTD.cs
@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class MeshCutterSimpleSTD : IMeshCutter
+{
+	private static List<Vector3> _vertices;
+
+	private static List<Vector3> _normals;
+
+	private static List<Vector4> _tangents;
+
+	private static List<int> _triangles;
+
+	private static List<Vector2>[] _uvs;
+
+	private static int _maxUVsCount;
+
+	static MeshCutterSimpleSTD()
+	{
+		_maxUVsCount = 4;
+		_vertices = new List<Vector3>();
+		_normals = new List<Vector3>();
+		_tangents = new List<Vector4>();
+		_triangles = new List<int>();
+		_uvs = new List<Vector2>[_maxUVsCount];
+		for (int i = 0; i < _maxUVsCount; i++)
+		{
+			_uvs[i] = new List<Vector2>();
+		}
+	}
+
+	public void Cut(Mesh mesh, MeshCuttingInfo info)
+	{
+		Cut(mesh, new MeshCuttingInfo[1] { info });
+	}
+
+	public void Cut(Mesh mesh, IList<MeshCuttingInfo> infos)
+	{
+		ValidateMeshOrThrowException(mesh);
+		CollectData(mesh);
+		foreach (MeshCuttingInfo item in infos.OrderByDescending((MeshCuttingInfo i) => i.triangleStart))
+		{
+			RemoveData(item);
+			OffsetTriangles(item);
+		}
+		ApplyDataToMesh(mesh);
+		ClearData();
+	}
+
+	private void ValidateMeshOrThrowException(Mesh mesh)
+	{
+		if (mesh == null)
+		{
+			throw new ArgumentNullException("mesh is null");
+		}
+		if (mesh.subMeshCount > 1)
+		{
+			throw new ArgumentException("SimpleMeshCutter::'mesh' should has only 1 submesh");
+		}
+	}
+
+	private void CollectData(Mesh mesh)
+	{
+		mesh.GetVertices(_vertices);
+		mesh.GetNormals(_normals);
+		mesh.GetTangents(_tangents);
+		mesh.GetTriangles(_triangles, 0);
+		for (int i = 0; i < _maxUVsCount; i++)
+		{
+			mesh.GetUVs(i, _uvs[i]);
+		}
+	}
+
+	private void RemoveData(MeshCuttingInfo cuttingInfo)
+	{
+		int vertexStart = cuttingInfo.vertexStart;
+		int vertexCount = cuttingInfo.vertexCount;
+		_vertices.RemoveRange(vertexStart, vertexCount);
+		if (_normals.Count > 0)
+		{
+			_normals.RemoveRange(vertexStart, vertexCount);
+		}
+		if (_tangents.Count > 0)
+		{
+			_tangents.RemoveRange(vertexStart, vertexCount);
+		}
+		_triangles.RemoveRange(cuttingInfo.triangleStart, cuttingInfo.triangleCount);
+		for (int i = 0; i < _uvs.Length; i++)
+		{
+			if (_uvs[i].Count > 0)
+			{
+				_uvs[i].RemoveRange(vertexStart, vertexCount);
+			}
+		}
+	}
+
+	private void OffsetTriangles(MeshCuttingInfo info)
+	{
+		int vertexCount = info.vertexCount;
+		int triangleStart = info.triangleStart;
+		int count = _triangles.Count;
+		for (int i = triangleStart; i < count; i++)
+		{
+			_triangles[i] -= vertexCount;
+		}
+	}
+
+	private void ApplyDataToMesh(Mesh mesh)
+	{
+		mesh.SetTriangles(_triangles, 0);
+		mesh.SetVertices(_vertices);
+		mesh.SetNormals(_normals);
+		mesh.SetTangents(_tangents);
+		for (int i = 0; i < _maxUVsCount; i++)
+		{
+			if (_uvs[i].Count > 0)
+			{
+				mesh.SetUVs(i, _uvs[i]);
+			}
+		}
+	}
+
+	private void ClearData()
+	{
+		_vertices.Clear();
+		_normals.Clear();
+		_tangents.Clear();
+		_triangles.Clear();
+		for (int i = 0; i < _maxUVsCount; i++)
+		{
+			_uvs[i].Clear();
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCuttingInfo.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCuttingInfo.cs
new file mode 100644
index 0000000..a295571
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshCuttingInfo.cs
@@ -0,0 +1,20 @@
+namespace NGS.MeshFusionPro;
+
+public struct MeshCuttingInfo
+{
+	public int vertexStart;
+
+	public int vertexCount;
+
+	public int triangleStart;
+
+	public int triangleCount;
+
+	public MeshCuttingInfo(int vertexStart, int vertexCount, int triangleStart, int triangleCount)
+	{
+		this.vertexStart = vertexStart;
+		this.vertexCount = vertexCount;
+		this.triangleStart = triangleStart;
+		this.triangleCount = triangleCount;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshDataListsSTD.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshDataListsSTD.cs
new file mode 100644
index 0000000..1bf34eb
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshDataListsSTD.cs
@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class MeshDataListsSTD : CombinedMeshDataInternal
+{
+	private CombinedMesh _root;
+
+	private List<Vector3> _vertices;
+
+	private List<Vector3> _normals;
+
+	private List<Vector4> _tangents;
+
+	private List<Bounds> _partsBounds;
+
+	private List<Bounds> _partsBoundsLocal;
+
+	public List<Vector3> Vertices => _vertices;
+
+	public List<Vector3> Normals => _normals;
+
+	public List<Vector4> Tangents => _tangents;
+
+	public List<Bounds> PartsBounds => _partsBounds;
+
+	public List<Bounds> PartsBoundsLocal => _partsBoundsLocal;
+
+	public Bounds Bounds { get; set; }
+
+	public override Bounds GetBounds()
+	{
+		return Bounds;
+	}
+
+	public override Bounds GetBounds(CombinedMeshPart part)
+	{
+		return _partsBounds[part.Index];
+	}
+
+	public void ApplyDataToMesh()
+	{
+		Mesh mesh = _root.Mesh;
+		mesh.SetVertices(_vertices);
+		mesh.SetNormals(_normals);
+		mesh.SetTangents(_tangents);
+		mesh.bounds = Bounds;
+	}
+
+	protected override void OnInitialized()
+	{
+		_root = base.Root;
+		_vertices = new List<Vector3>();
+		_normals = new List<Vector3>();
+		_tangents = new List<Vector4>();
+		_partsBounds = new List<Bounds>();
+		_partsBoundsLocal = new List<Bounds>();
+	}
+
+	protected override void OnAddPart(CombinedMeshPart part, Mesh mesh, Matrix4x4 transform)
+	{
+		Bounds bounds = mesh.bounds;
+		Bounds item = bounds.Transform(transform);
+		_partsBounds.Add(item);
+		_partsBoundsLocal.Add(bounds);
+	}
+
+	protected override void OnRemovePart(CombinedMeshPart part)
+	{
+		_partsBounds.RemoveAt(part.Index);
+		_partsBoundsLocal.RemoveAt(part.Index);
+	}
+
+	protected override void OnMeshUpdated()
+	{
+		Mesh mesh = _root.Mesh;
+		mesh.GetVertices(_vertices);
+		mesh.GetNormals(_normals);
+		mesh.GetTangents(_tangents);
+		Bounds = mesh.bounds;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshDataNativeArraysLW.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshDataNativeArraysLW.cs
new file mode 100644
index 0000000..939d022
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshDataNativeArraysLW.cs
@@ -0,0 +1,131 @@
+using System.Collections.Generic;
+using Unity.Collections;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class MeshDataNativeArraysLW : CombinedMeshDataInternal
+{
+	private CombinedMesh _root;
+
+	private NativeList<LightweightVertex> _vertices;
+
+	private NativeList<Bounds> _partsBounds;
+
+	private NativeArray<Bounds> _bounds;
+
+	private NativeList<LightweightVertex> _verticesLocal;
+
+	private NativeList<Bounds> _partsBoundsLocal;
+
+	private List<Vector3> _tempVertices;
+
+	private List<Vector3> _tempNormals;
+
+	private List<Vector4> _tempTangents;
+
+	private List<Vector2> _tempUV;
+
+	private List<Vector2> _tempUV2;
+
+	public NativeArray<LightweightVertex> Vertices => _vertices;
+
+	public NativeArray<Bounds> PartsBounds => _partsBounds;
+
+	public NativeArray<Bounds> Bounds => _bounds;
+
+	public NativeArray<LightweightVertex> VerticesLocal => _verticesLocal;
+
+	public NativeArray<Bounds> PartsBoundsLocal => _partsBoundsLocal;
+
+	public override Bounds GetBounds()
+	{
+		return _bounds[0];
+	}
+
+	public override Bounds GetBounds(CombinedMeshPart part)
+	{
+		return _partsBounds[part.Index];
+	}
+
+	public void ApplyDataToMesh()
+	{
+		Mesh mesh = _root.Mesh;
+		mesh.SetVertexBufferData(Vertices, 0, 0, _vertices.Length);
+		mesh.bounds = _bounds[0];
+	}
+
+	protected override void OnInitialized()
+	{
+		_root = base.Root;
+		VertexBufferUtil.ToLightweightBuffer(_root.Mesh);
+		_vertices = new NativeList<LightweightVertex>(Allocator.Persistent);
+		_partsBounds = new NativeList<Bounds>(Allocator.Persistent);
+		_bounds = new NativeArray<Bounds>(1, Allocator.Persistent);
+		_verticesLocal = new NativeList<LightweightVertex>(Allocator.Persistent);
+		_partsBoundsLocal = new NativeList<Bounds>(Allocator.Persistent);
+		_tempVertices = new List<Vector3>();
+		_tempNormals = new List<Vector3>();
+		_tempTangents = new List<Vector4>();
+		_tempUV = new List<Vector2>();
+		_tempUV2 = new List<Vector2>();
+	}
+
+	protected override void OnAddPart(CombinedMeshPart part, Mesh mesh, Matrix4x4 transform)
+	{
+		Bounds value = mesh.bounds;
+		Bounds value2 = value.Transform(transform);
+		_partsBounds.Add(in value2);
+		_partsBoundsLocal.Add(in value);
+		mesh.GetVertices(_tempVertices);
+		mesh.GetNormals(_tempNormals);
+		mesh.GetTangents(_tempTangents);
+		mesh.GetUVs(0, _tempUV);
+		mesh.GetUVs(1, _tempUV2);
+		int vertexCount = mesh.vertexCount;
+		for (int i = 0; i < vertexCount; i++)
+		{
+			LightweightVertex value3 = default(LightweightVertex);
+			value3.Position = _tempVertices[i];
+			value3.Normal = _tempNormals[i];
+			value3.Tangent = _tempTangents[i];
+			if (_tempUV.Count > 0)
+			{
+				value3.UV = _tempUV[i];
+			}
+			if (_tempUV2.Count > 0)
+			{
+				value3.UV2 = _tempUV2[i];
+			}
+			_verticesLocal.Add(in value3);
+		}
+	}
+
+	protected override void OnRemovePart(CombinedMeshPart part)
+	{
+		_partsBounds.RemoveAt(part.Index);
+		_verticesLocal.RemoveRange(part.VertexStart, part.VertexCount);
+		_partsBoundsLocal.RemoveAt(part.Index);
+	}
+
+	protected override void OnMeshUpdated()
+	{
+		Mesh mesh = _root.Mesh;
+		using (Mesh.MeshDataArray meshDataArray = Mesh.AcquireReadOnlyMeshData(mesh))
+		{
+			Mesh.MeshData meshData = meshDataArray[0];
+			_vertices.Clear();
+			_vertices.AddRange(meshData.GetVertexData<LightweightVertex>());
+		}
+		_bounds[0] = mesh.bounds;
+	}
+
+	protected override void OnDispose()
+	{
+		_vertices.Dispose();
+		_partsBounds.Dispose();
+		_bounds.Dispose();
+		_verticesLocal.Dispose();
+		_partsBoundsLocal.Dispose();
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshDataNativeArraysSTD.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshDataNativeArraysSTD.cs
new file mode 100644
index 0000000..3063894
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshDataNativeArraysSTD.cs
@@ -0,0 +1,104 @@
+using Unity.Collections;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class MeshDataNativeArraysSTD : CombinedMeshDataInternal
+{
+	private CombinedMesh _root;
+
+	private NativeList<Vector3> _vertices;
+
+	private NativeList<Vector3> _normals;
+
+	private NativeList<Vector4> _tangents;
+
+	private NativeList<Bounds> _partsBounds;
+
+	private NativeList<Bounds> _partsBoundsLocal;
+
+	private NativeArray<Bounds> _bounds;
+
+	public NativeArray<Vector3> Vertices => _vertices;
+
+	public NativeArray<Vector3> Normals => _normals;
+
+	public NativeArray<Vector4> Tangents => _tangents;
+
+	public NativeArray<Bounds> PartsBounds => _partsBounds;
+
+	public NativeArray<Bounds> PartsBoundsLocal => _partsBoundsLocal;
+
+	public NativeArray<Bounds> Bounds => _bounds;
+
+	public override Bounds GetBounds()
+	{
+		return _bounds[0];
+	}
+
+	public override Bounds GetBounds(CombinedMeshPart part)
+	{
+		return _partsBounds[part.Index];
+	}
+
+	public void ApplyDataToMesh()
+	{
+		Mesh mesh = _root.Mesh;
+		mesh.SetVertices(Vertices);
+		mesh.SetNormals(Normals);
+		mesh.SetTangents(Tangents);
+		mesh.bounds = _bounds[0];
+	}
+
+	protected override void OnInitialized()
+	{
+		_root = base.Root;
+		_vertices = new NativeList<Vector3>(Allocator.Persistent);
+		_normals = new NativeList<Vector3>(Allocator.Persistent);
+		_tangents = new NativeList<Vector4>(Allocator.Persistent);
+		_partsBounds = new NativeList<Bounds>(Allocator.Persistent);
+		_partsBoundsLocal = new NativeList<Bounds>(Allocator.Persistent);
+		_bounds = new NativeArray<Bounds>(1, Allocator.Persistent);
+	}
+
+	protected override void OnAddPart(CombinedMeshPart part, Mesh mesh, Matrix4x4 transform)
+	{
+		Bounds value = mesh.bounds;
+		Bounds value2 = value.Transform(transform);
+		_partsBounds.Add(in value2);
+		_partsBoundsLocal.Add(in value);
+	}
+
+	protected override void OnRemovePart(CombinedMeshPart part)
+	{
+		_partsBounds.RemoveAt(part.Index);
+		_partsBoundsLocal.RemoveAt(part.Index);
+	}
+
+	protected override void OnMeshUpdated()
+	{
+		Mesh mesh = _root.Mesh;
+		int vertexCount = mesh.vertexCount;
+		_vertices.ResizeUninitialized(vertexCount);
+		_normals.ResizeUninitialized(vertexCount);
+		_tangents.ResizeUninitialized(vertexCount);
+		using (Mesh.MeshDataArray meshDataArray = Mesh.AcquireReadOnlyMeshData(mesh))
+		{
+			Mesh.MeshData meshData = meshDataArray[0];
+			meshData.GetVertices(_vertices);
+			meshData.GetNormals(_normals);
+			meshData.GetTangents(_tangents);
+		}
+		_bounds[0] = mesh.bounds;
+	}
+
+	protected override void OnDispose()
+	{
+		_vertices.Dispose();
+		_normals.Dispose();
+		_tangents.Dispose();
+		_partsBounds.Dispose();
+		_partsBoundsLocal.Dispose();
+		_bounds.Dispose();
+	}
+}
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);
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshSeparatorSimple.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshSeparatorSimple.cs
new file mode 100644
index 0000000..6c79a16
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshSeparatorSimple.cs
@@ -0,0 +1,130 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace NGS.MeshFusionPro;
+
+public class MeshSeparatorSimple
+{
+	private const int MAX_UV_CHANNELS = 4;
+
+	private static Dictionary<Mesh, Mesh[]> _meshToSubmeshes;
+
+	private static List<Vector3> _srcVertices;
+
+	private static List<Vector3> _srcNormals;
+
+	private static List<Vector4> _srcTangents;
+
+	private static List<Vector2> _srcUV;
+
+	private static List<int> _triangles;
+
+	private static List<Vector3> _vertices;
+
+	private static List<Vector3> _normals;
+
+	private static List<Vector4> _tangents;
+
+	private static List<Vector2> _uv;
+
+	static MeshSeparatorSimple()
+	{
+		_meshToSubmeshes = new Dictionary<Mesh, Mesh[]>();
+		_srcVertices = new List<Vector3>();
+		_srcNormals = new List<Vector3>();
+		_srcTangents = new List<Vector4>();
+		_srcUV = new List<Vector2>();
+		_triangles = new List<int>();
+		_vertices = new List<Vector3>();
+		_normals = new List<Vector3>();
+		_tangents = new List<Vector4>();
+		_uv = new List<Vector2>();
+	}
+
+	public Mesh GetSubmesh(Mesh source, int submesh)
+	{
+		if (!_meshToSubmeshes.TryGetValue(source, out var value))
+		{
+			value = Separate(source);
+			_meshToSubmeshes.Add(source, value);
+		}
+		return value[submesh];
+	}
+
+	private Mesh[] Separate(Mesh mesh)
+	{
+		int subMeshCount = mesh.subMeshCount;
+		Mesh[] array = new Mesh[subMeshCount];
+		CollectMeshData(mesh);
+		for (int i = 0; i < subMeshCount; i++)
+		{
+			array[i] = CreateFromSubmesh(mesh, i);
+		}
+		ClearData();
+		return array;
+	}
+
+	private void CollectMeshData(Mesh mesh)
+	{
+		mesh.GetVertices(_srcVertices);
+		mesh.GetNormals(_srcNormals);
+		mesh.GetTangents(_srcTangents);
+	}
+
+	private Mesh CreateFromSubmesh(Mesh mesh, int submesh)
+	{
+		SubMeshDescriptor subMesh = mesh.GetSubMesh(submesh);
+		Mesh mesh2 = new Mesh();
+		int indexCount = subMesh.indexCount;
+		int vertexCount = subMesh.vertexCount;
+		int firstVertex = subMesh.firstVertex;
+		int num = firstVertex + vertexCount;
+		_vertices.Clear();
+		_normals.Clear();
+		_tangents.Clear();
+		mesh.GetIndices(_triangles, submesh);
+		for (int i = firstVertex; i < num; i++)
+		{
+			_vertices.Add(_srcVertices[i]);
+			_normals.Add(_srcNormals[i]);
+			_tangents.Add(_srcTangents[i]);
+		}
+		for (int j = 0; j < indexCount; j++)
+		{
+			_triangles[j] -= firstVertex;
+		}
+		mesh2.SetVertices(_vertices);
+		mesh2.SetNormals(_normals);
+		mesh2.SetTangents(_tangents);
+		mesh2.SetTriangles(_triangles, 0, calculateBounds: false);
+		mesh2.bounds = subMesh.bounds;
+		for (int k = 0; k < 4; k++)
+		{
+			mesh.GetUVs(k, _srcUV);
+			if (_srcUV.Count != 0)
+			{
+				_uv.Clear();
+				for (int l = firstVertex; l < num; l++)
+				{
+					_uv.Add(_srcUV[l]);
+				}
+				mesh2.SetUVs(k, _uv);
+			}
+		}
+		return mesh2;
+	}
+
+	private void ClearData()
+	{
+		_srcVertices.Clear();
+		_srcNormals.Clear();
+		_srcTangents.Clear();
+		_srcUV.Clear();
+		_triangles.Clear();
+		_vertices.Clear();
+		_normals.Clear();
+		_tangents.Clear();
+		_uv.Clear();
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshType.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshType.cs
new file mode 100644
index 0000000..63cafe1
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MeshType.cs
@@ -0,0 +1,7 @@
+namespace NGS.MeshFusionPro;
+
+public enum MeshType
+{
+	Standard,
+	Lightweight
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MoveMethod.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MoveMethod.cs
new file mode 100644
index 0000000..27d690f
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/MoveMethod.cs
@@ -0,0 +1,7 @@
+namespace NGS.MeshFusionPro;
+
+public enum MoveMethod
+{
+	Simple,
+	Jobs
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ObjectsCombiner.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ObjectsCombiner.cs
new file mode 100644
index 0000000..6cf2299
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/ObjectsCombiner.cs
@@ -0,0 +1,155 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public abstract class ObjectsCombiner<TCombinedObject, TCombineSource> where TCombinedObject : ICombinedObject where TCombineSource : ICombineSource
+{
+	private List<TCombinedObject> _combinedObjects;
+
+	private List<TCombineSource> _sources;
+
+	private List<TCombineSource> _sourcesForCombine;
+
+	public IReadOnlyList<TCombinedObject> CombinedObjects => _combinedObjects;
+
+	public bool ContainSources => _sources.Count > 0;
+
+	public event Action<TCombinedObject> onCombinedObjectCreated;
+
+	protected ObjectsCombiner()
+	{
+		_sources = new List<TCombineSource>();
+		_combinedObjects = new List<TCombinedObject>();
+		_sourcesForCombine = new List<TCombineSource>();
+	}
+
+	public virtual void AddSource(TCombineSource source)
+	{
+		_sources.Add(source);
+	}
+
+	public void AddSources(IEnumerable<TCombineSource> sources)
+	{
+		foreach (TCombineSource source in sources)
+		{
+			AddSource(source);
+		}
+	}
+
+	public void RemoveSource(TCombineSource source)
+	{
+		_sources.Remove(source);
+	}
+
+	public void Combine()
+	{
+		if (_sources.Count != 0)
+		{
+			CleanEmptyData();
+			CombineInternal();
+			_sources.Clear();
+		}
+	}
+
+	private void CleanEmptyData()
+	{
+		int num = 0;
+		while (num < _combinedObjects.Count)
+		{
+			if (_combinedObjects[num] == null)
+			{
+				_combinedObjects.RemoveAt(num);
+			}
+			else
+			{
+				num++;
+			}
+		}
+		num = 0;
+		while (num < _sources.Count)
+		{
+			if (_sources[num] == null)
+			{
+				_sources.RemoveAt(num);
+			}
+			else
+			{
+				num++;
+			}
+		}
+	}
+
+	private void CombineInternal()
+	{
+		_sourcesForCombine.Clear();
+		int num = 0;
+		while (num <= _combinedObjects.Count && _sources.Count != 0)
+		{
+			bool flag = false;
+			TCombinedObject val;
+			if (num == _combinedObjects.Count)
+			{
+				try
+				{
+					val = CreateCombinedObject(_sources[0]);
+					_combinedObjects.Add(val);
+					flag = true;
+				}
+				catch (Exception ex)
+				{
+					Debug.Log("Unable to create CombinedObject : " + ex.Message + ex.StackTrace);
+					_sources.RemoveAt(0);
+					continue;
+				}
+			}
+			else
+			{
+				val = _combinedObjects[num];
+			}
+			CombinedObjectMatcher<TCombinedObject, TCombineSource> matcher = GetMatcher();
+			matcher.StartMatching(val);
+			int num2 = 0;
+			while (num2 < _sources.Count)
+			{
+				TCombineSource val2 = _sources[num2];
+				if (matcher.CanAddSource(val2))
+				{
+					_sourcesForCombine.Add(val2);
+					matcher.SourceAdded(val2);
+					_sources.RemoveAt(num2);
+				}
+				else
+				{
+					num2++;
+				}
+			}
+			if (_sourcesForCombine.Count > 0)
+			{
+				try
+				{
+					CombineSources(val, _sourcesForCombine);
+					_sourcesForCombine.Clear();
+				}
+				catch (Exception ex2)
+				{
+					Debug.Log("Unable to combine sources in ObjectsCombiner : " + ex2.Message + ex2.StackTrace);
+					_sourcesForCombine.Clear();
+					continue;
+				}
+			}
+			if (flag)
+			{
+				this.onCombinedObjectCreated?.Invoke(val);
+			}
+			num++;
+		}
+	}
+
+	protected abstract CombinedObjectMatcher<TCombinedObject, TCombineSource> GetMatcher();
+
+	protected abstract TCombinedObject CreateCombinedObject(TCombineSource source);
+
+	protected abstract void CombineSources(TCombinedObject root, IList<TCombineSource> sources);
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/PartMoveInfo.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/PartMoveInfo.cs
new file mode 100644
index 0000000..776f8ad
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/PartMoveInfo.cs
@@ -0,0 +1,16 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public struct PartMoveInfo
+{
+	public int partIndex;
+
+	public int vertexStart;
+
+	public int vertexCount;
+
+	public Matrix4x4 currentTransform;
+
+	public Matrix4x4 targetTransform;
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RendererHelper.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RendererHelper.cs
new file mode 100644
index 0000000..f513a90
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RendererHelper.cs
@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public static class RendererHelper
+{
+	private static List<Material> _materials;
+
+	static RendererHelper()
+	{
+		_materials = new List<Material>();
+	}
+
+	public static Material GetSharedMaterialWithoutAlloc(this Renderer renderer, int index)
+	{
+		renderer.GetSharedMaterials(_materials);
+		return _materials[index];
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RendererSettings.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RendererSettings.cs
new file mode 100644
index 0000000..8d29b8c
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RendererSettings.cs
@@ -0,0 +1,43 @@
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace NGS.MeshFusionPro;
+
+public struct RendererSettings
+{
+	public string tag;
+
+	public int layer;
+
+	public Material material;
+
+	public ShadowCastingMode shadowMode;
+
+	public bool receiveShadows;
+
+	public int lightmapIndex;
+
+	public int realtimeLightmapIndex;
+
+	public RendererSettings(Material material, ShadowCastingMode shadowMode = ShadowCastingMode.On, bool receiveShadows = true, int lightmapIndex = -1, int realtimeLightmapIndex = -1, string tag = "Untagged", int layer = 0)
+	{
+		this.material = material;
+		this.shadowMode = shadowMode;
+		this.receiveShadows = receiveShadows;
+		this.lightmapIndex = lightmapIndex;
+		this.realtimeLightmapIndex = realtimeLightmapIndex;
+		this.tag = tag;
+		this.layer = layer;
+	}
+
+	public RendererSettings(Renderer renderer, int materialIndex = 0)
+	{
+		material = renderer.GetSharedMaterialWithoutAlloc(materialIndex);
+		shadowMode = renderer.shadowCastingMode;
+		receiveShadows = renderer.receiveShadows;
+		lightmapIndex = renderer.lightmapIndex;
+		realtimeLightmapIndex = renderer.realtimeLightmapIndex;
+		tag = renderer.tag;
+		layer = renderer.gameObject.layer;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RigidbodyTrackingStrategy.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RigidbodyTrackingStrategy.cs
new file mode 100644
index 0000000..763f666
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RigidbodyTrackingStrategy.cs
@@ -0,0 +1,62 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class RigidbodyTrackingStrategy : ISourceTrackingStrategy
+{
+	private Rigidbody _rigidbody;
+
+	private Transform _transform;
+
+	private DynamicCombinedObjectPart[] _parts;
+
+	private float _velocityThreashold = 0.5f;
+
+	private float _angularVelocityThreashold = 0.3f;
+
+	public float VelocityThreashold
+	{
+		get
+		{
+			return _velocityThreashold;
+		}
+		set
+		{
+			_velocityThreashold = Mathf.Max(0f, value);
+		}
+	}
+
+	public float AngularVelocityThreashold
+	{
+		get
+		{
+			return _angularVelocityThreashold;
+		}
+		set
+		{
+			_angularVelocityThreashold = Mathf.Max(0f, value);
+		}
+	}
+
+	public RigidbodyTrackingStrategy(Rigidbody target, DynamicCombinedObjectPart[] parts)
+	{
+		_rigidbody = target;
+		_transform = target.transform;
+		_parts = parts;
+	}
+
+	public bool OnUpdate()
+	{
+		float magnitude = _rigidbody.velocity.magnitude;
+		float magnitude2 = _rigidbody.angularVelocity.magnitude;
+		if (magnitude > _velocityThreashold || magnitude2 > _angularVelocityThreashold)
+		{
+			for (int i = 0; i < _parts.Length; i++)
+			{
+				_parts[i].Move(_transform.localToWorldMatrix);
+			}
+			return true;
+		}
+		return false;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RuntimeMeshFusion.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RuntimeMeshFusion.cs
new file mode 100644
index 0000000..38c811b
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/RuntimeMeshFusion.cs
@@ -0,0 +1,197 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class RuntimeMeshFusion : MonoBehaviour
+{
+	private static List<RuntimeMeshFusion> _Instances;
+
+	[SerializeField]
+	[HideInInspector]
+	private int _controllerIndex;
+
+	[SerializeField]
+	[HideInInspector]
+	private bool _drawGizmo;
+
+	[SerializeField]
+	[HideInInspector]
+	private int _cellSize = 80;
+
+	[SerializeField]
+	[HideInInspector]
+	private int _maxVerticesPerObject = 40000;
+
+	[SerializeField]
+	[HideInInspector]
+	private MeshType _meshType;
+
+	[SerializeField]
+	[HideInInspector]
+	private MoveMethod _moveMethod = MoveMethod.Jobs;
+
+	private CombineTree _combineTree;
+
+	private bool _sourceAdded;
+
+	private BinaryTreeDrawer<ICombineSource> _treeDrawer;
+
+	public int ControllerIndex
+	{
+		get
+		{
+			return _controllerIndex;
+		}
+		set
+		{
+			if (!Application.isPlaying)
+			{
+				_controllerIndex = value;
+			}
+		}
+	}
+
+	public bool DrawGizmo
+	{
+		get
+		{
+			return _drawGizmo;
+		}
+		set
+		{
+			_drawGizmo = value;
+		}
+	}
+
+	public int CellSize
+	{
+		get
+		{
+			return _cellSize;
+		}
+		set
+		{
+			if (!Application.isPlaying)
+			{
+				_cellSize = Mathf.Max(1, value);
+			}
+		}
+	}
+
+	public int MaxVertices
+	{
+		get
+		{
+			return _maxVerticesPerObject;
+		}
+		set
+		{
+			if (!Application.isPlaying)
+			{
+				_maxVerticesPerObject = Mathf.Clamp(value, 500, 65000);
+			}
+		}
+	}
+
+	public MeshType MeshType
+	{
+		get
+		{
+			return _meshType;
+		}
+		set
+		{
+			if (!Application.isPlaying)
+			{
+				_meshType = value;
+			}
+		}
+	}
+
+	public MoveMethod MoveMethod
+	{
+		get
+		{
+			return _moveMethod;
+		}
+		set
+		{
+			if (!Application.isPlaying)
+			{
+				_moveMethod = value;
+			}
+		}
+	}
+
+	private void Awake()
+	{
+		if (_Instances == null)
+		{
+			_Instances = new List<RuntimeMeshFusion>();
+		}
+		_Instances.Add(this);
+		ICombinedMeshFactory factory = new CombinedMeshFactory(_meshType, CombineMethod.Simple, _moveMethod);
+		_combineTree = new CombineTree(factory, _cellSize, _maxVerticesPerObject);
+		_treeDrawer = new BinaryTreeDrawer<ICombineSource>();
+		Transform parent = new GameObject("CombinedObjects").transform;
+		_combineTree.onStaticCombinedObjectCreated += delegate(CombinedObject r)
+		{
+			r.transform.parent = parent;
+		};
+		_combineTree.onDynamicCombinedObjectCreated += delegate(DynamicCombinedObject r)
+		{
+			r.transform.parent = parent;
+		};
+		_combineTree.onCombinedLODGroupCreated += delegate(CombinedLODGroup r)
+		{
+			r.transform.parent = parent;
+		};
+	}
+
+	private void Update()
+	{
+		if (_sourceAdded)
+		{
+			_combineTree.Combine();
+			_sourceAdded = false;
+		}
+	}
+
+	private void OnDrawGizmos()
+	{
+		if (Application.isPlaying && _drawGizmo && _combineTree != null && _combineTree.Root != null)
+		{
+			_treeDrawer.DrawGizmo(_combineTree.Root, Color.white);
+		}
+	}
+
+	private void OnDestroy()
+	{
+		_Instances.Remove(this);
+	}
+
+	public static RuntimeMeshFusion FindByIndex(int index)
+	{
+		for (int i = 0; i < _Instances.Count; i++)
+		{
+			RuntimeMeshFusion runtimeMeshFusion = _Instances[i];
+			if (runtimeMeshFusion.ControllerIndex == index)
+			{
+				return runtimeMeshFusion;
+			}
+		}
+		throw new KeyNotFoundException("MeshFusionController with index : " + index + " not found");
+	}
+
+	public void AddSource(ICombineSource source)
+	{
+		_combineTree.Add(source);
+		_sourceAdded = true;
+	}
+
+	public void RemoveSource(ICombineSource source)
+	{
+		_combineTree.Remove(source);
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleMeshMoverSTD.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleMeshMoverSTD.cs
new file mode 100644
index 0000000..5a56ec3
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleMeshMoverSTD.cs
@@ -0,0 +1,62 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class SimpleMeshMoverSTD : ICombinedMeshMover
+{
+	private MeshDataListsSTD _meshData;
+
+	public SimpleMeshMoverSTD(MeshDataListsSTD meshData)
+	{
+		_meshData = meshData;
+	}
+
+	public void MoveParts(IList<PartMoveInfo> moveInfos)
+	{
+		List<Vector3> vertices = _meshData.Vertices;
+		List<Vector3> normals = _meshData.Normals;
+		List<Vector4> tangents = _meshData.Tangents;
+		List<Bounds> partsBounds = _meshData.PartsBounds;
+		List<Bounds> partsBoundsLocal = _meshData.PartsBoundsLocal;
+		Bounds bounds = _meshData.GetBounds();
+		bounds.size = Vector3.zero;
+		for (int i = 0; i < moveInfos.Count; i++)
+		{
+			PartMoveInfo partMoveInfo = moveInfos[i];
+			int partIndex = partMoveInfo.partIndex;
+			int vertexStart = partMoveInfo.vertexStart;
+			int num = vertexStart + partMoveInfo.vertexCount;
+			Matrix4x4 targetTransform = partMoveInfo.targetTransform;
+			Matrix4x4 inverse = partMoveInfo.currentTransform.inverse;
+			for (int j = vertexStart; j < num; j++)
+			{
+				Vector3 point = vertices[j];
+				Vector3 vector = normals[j];
+				Vector4 vector2 = tangents[j];
+				float w = vector2.w;
+				point = inverse.MultiplyPoint3x4(point);
+				point = targetTransform.MultiplyPoint3x4(point);
+				vector = inverse.MultiplyVector(vector);
+				vector = targetTransform.MultiplyVector(vector);
+				vector2 = inverse.MultiplyVector(vector2);
+				vector2 = targetTransform.MultiplyVector(vector2);
+				vector2.w = w;
+				vertices[j] = point;
+				normals[j] = vector;
+				tangents[j] = vector2;
+			}
+			partsBounds[partIndex] = partsBoundsLocal[partIndex].Transform(targetTransform);
+		}
+		for (int k = 0; k < partsBounds.Count; k++)
+		{
+			bounds.Encapsulate(partsBounds[k]);
+		}
+		_meshData.Bounds = bounds;
+	}
+
+	public void ApplyData()
+	{
+		_meshData.ApplyDataToMesh();
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleMovableMeshSTDFactory.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleMovableMeshSTDFactory.cs
new file mode 100644
index 0000000..3454e5e
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleMovableMeshSTDFactory.cs
@@ -0,0 +1,18 @@
+namespace NGS.MeshFusionPro;
+
+public class SimpleMovableMeshSTDFactory : IMovableCombinedMeshFactory
+{
+	private IMeshToolsFactory _tools;
+
+	public SimpleMovableMeshSTDFactory(IMeshToolsFactory tools)
+	{
+		_tools = tools;
+	}
+
+	public CombinedMesh CreateMovableMesh(out ICombinedMeshMover mover)
+	{
+		CombinedMesh<MeshDataListsSTD> combinedMesh = new CombinedMesh<MeshDataListsSTD>(_tools.CreateMeshCombiner(), _tools.CreateMeshCutter());
+		mover = new SimpleMeshMoverSTD(combinedMesh.MeshDataInternal);
+		return combinedMesh;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleToolsLWFactory.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleToolsLWFactory.cs
new file mode 100644
index 0000000..cedbde2
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleToolsLWFactory.cs
@@ -0,0 +1,14 @@
+namespace NGS.MeshFusionPro;
+
+public class SimpleToolsLWFactory : IMeshToolsFactory
+{
+	public IMeshCombiner CreateMeshCombiner()
+	{
+		return new MeshCombinerSimpleLW();
+	}
+
+	public IMeshCutter CreateMeshCutter()
+	{
+		return new MeshCutterSimpleLW();
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleToolsSTDFactory.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleToolsSTDFactory.cs
new file mode 100644
index 0000000..ee1ce77
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SimpleToolsSTDFactory.cs
@@ -0,0 +1,14 @@
+namespace NGS.MeshFusionPro;
+
+public class SimpleToolsSTDFactory : IMeshToolsFactory
+{
+	public IMeshCombiner CreateMeshCombiner()
+	{
+		return new MeshCombinerSimpleSTD();
+	}
+
+	public IMeshCutter CreateMeshCutter()
+	{
+		return new MeshCutterSimpleSTD();
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SourceCombineStatus.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SourceCombineStatus.cs
new file mode 100644
index 0000000..8aab0cd
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SourceCombineStatus.cs
@@ -0,0 +1,10 @@
+namespace NGS.MeshFusionPro;
+
+public enum SourceCombineStatus
+{
+	NotCombined,
+	AssignedToController,
+	CombinedPartially,
+	Combined,
+	FailedToCombine
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SourceTracker.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SourceTracker.cs
new file mode 100644
index 0000000..571d46d
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/SourceTracker.cs
@@ -0,0 +1,161 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+[DisallowMultipleComponent]
+[RequireComponent(typeof(MeshFusionSource))]
+public class SourceTracker : MonoBehaviour
+{
+	[SerializeField]
+	private MeshFusionSource _source;
+
+	[SerializeField]
+	private bool _isDynamicObject;
+
+	[SerializeField]
+	private Rigidbody _rigidbody;
+
+	private IEnumerable<ICombinedObjectPart> _parts;
+
+	private ISourceTrackingStrategy _trackingStrategy;
+
+	private float _idleTime;
+
+	private Action _updateFunc;
+
+	public bool IsDynamicObject => _isDynamicObject;
+
+	[field: SerializeField]
+	public TrackingTarget TrackingTarget { get; set; }
+
+	[field: SerializeField]
+	public bool DisableWhenIdle { get; set; } = true;
+
+
+	[field: SerializeField]
+	[field: Min(0.01f)]
+	public float MaxIdleTime { get; set; } = 5f;
+
+
+	[field: SerializeField]
+	public bool WakeUpWhenCollision { get; set; } = true;
+
+
+	[field: SerializeField]
+	public bool TrackingDestroy { get; set; } = true;
+
+
+	public void WakeUp()
+	{
+		base.enabled = true;
+		_idleTime = 0f;
+	}
+
+	private void Reset()
+	{
+		_source = GetComponent<MeshFusionSource>();
+		_isDynamicObject = _source is DynamicMeshFusionSource;
+		if (TryGetComponent<Rigidbody>(out _rigidbody))
+		{
+			TrackingTarget = TrackingTarget.Rigidbody;
+		}
+	}
+
+	private void Awake()
+	{
+		if (_source == null)
+		{
+			_source = GetComponent<MeshFusionSource>();
+			_isDynamicObject = _source is DynamicMeshFusionSource;
+		}
+		_source.onCombineFinished += OnCombineFinished;
+		base.enabled = false;
+	}
+
+	private void Update()
+	{
+		try
+		{
+			_updateFunc?.Invoke();
+		}
+		catch
+		{
+			if (!_isDynamicObject)
+			{
+				base.enabled = false;
+				return;
+			}
+			throw;
+		}
+	}
+
+	private void OnCollisionEnter(Collision collision)
+	{
+		if (_isDynamicObject && WakeUpWhenCollision && _parts != null)
+		{
+			WakeUp();
+		}
+	}
+
+	private void OnDestroy()
+	{
+		if (!base.gameObject.scene.isLoaded || !TrackingDestroy || _parts == null)
+		{
+			return;
+		}
+		foreach (ICombinedObjectPart part in _parts)
+		{
+			if (part != null && part.Root != null)
+			{
+				part.Destroy();
+			}
+		}
+	}
+
+	private void OnCombineFinished(MeshFusionSource source, IEnumerable<ICombinedObjectPart> parts)
+	{
+		_parts = parts;
+		_source.onCombineFinished -= OnCombineFinished;
+		if (!_isDynamicObject)
+		{
+			return;
+		}
+		_updateFunc = UpdateMoveTracker;
+		if (TrackingTarget == TrackingTarget.Rigidbody && _rigidbody != null)
+		{
+			_trackingStrategy = new RigidbodyTrackingStrategy(_rigidbody, parts.Select((ICombinedObjectPart p) => (DynamicCombinedObjectPart)p).ToArray());
+			if (DisableWhenIdle)
+			{
+				_updateFunc = UpdateMoveTrackerAndCheckIdle;
+			}
+		}
+		else
+		{
+			_trackingStrategy = new TransformTrackingStrategy(base.transform, parts.Select((ICombinedObjectPart p) => (DynamicCombinedObjectPart)p).ToArray());
+		}
+		base.enabled = true;
+	}
+
+	private void UpdateMoveTracker()
+	{
+		_trackingStrategy.OnUpdate();
+	}
+
+	private void UpdateMoveTrackerAndCheckIdle()
+	{
+		if (_trackingStrategy.OnUpdate())
+		{
+			_idleTime = 0f;
+			return;
+		}
+		_idleTime += Time.deltaTime;
+		if (_idleTime > MaxIdleTime)
+		{
+			_idleTime = 0f;
+			base.enabled = false;
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/StaticCombinedObjectMatcher.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/StaticCombinedObjectMatcher.cs
new file mode 100644
index 0000000..60ea49c
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/StaticCombinedObjectMatcher.cs
@@ -0,0 +1,39 @@
+namespace NGS.MeshFusionPro;
+
+public class StaticCombinedObjectMatcher : CombinedObjectMatcher<CombinedObject, CombineSource>
+{
+	private RendererSettings _settings;
+
+	private int _vertexCount;
+
+	private int _vertexLimit;
+
+	public StaticCombinedObjectMatcher(int vertexLimit)
+	{
+		_vertexLimit = vertexLimit;
+	}
+
+	public override void StartMatching(CombinedObject combinedObject)
+	{
+		_settings = combinedObject.RendererSettings;
+		_vertexCount = combinedObject.VertexCount;
+	}
+
+	public override bool CanAddSource(CombineSource source)
+	{
+		if (!_settings.Equals(source.RendererSettings))
+		{
+			return false;
+		}
+		if (_vertexCount + source.CombineInfo.vertexCount > _vertexLimit)
+		{
+			return false;
+		}
+		return true;
+	}
+
+	public override void SourceAdded(CombineSource source)
+	{
+		_vertexCount += source.CombineInfo.vertexCount;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/StaticMeshFusionSource.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/StaticMeshFusionSource.cs
new file mode 100644
index 0000000..fbd86b3
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/StaticMeshFusionSource.cs
@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class StaticMeshFusionSource : MeshFusionSource
+{
+	[SerializeField]
+	[HideInInspector]
+	private MeshRenderer _renderer;
+
+	[SerializeField]
+	[HideInInspector]
+	private MeshFilter _filter;
+
+	[SerializeField]
+	[HideInInspector]
+	private Mesh _mesh;
+
+	private CombineSource[] _sources;
+
+	private CombinedObjectPart[] _parts;
+
+	public override bool TryGetBounds(ref Bounds bounds)
+	{
+		if (_renderer != null)
+		{
+			bounds = _renderer.bounds;
+			return true;
+		}
+		return false;
+	}
+
+	protected override void OnSourceCombinedInternal(ICombinedObject root, ICombinedObjectPart part)
+	{
+		for (int i = 0; i < _parts.Length; i++)
+		{
+			if (_parts[i] == null)
+			{
+				_parts[i] = (CombinedObjectPart)part;
+				return;
+			}
+		}
+		throw new Exception("Unexpected Behaviour");
+	}
+
+	protected override bool CheckCompatibilityAndGetComponents(out string incompatibilityReason)
+	{
+		incompatibilityReason = "";
+		return CanCreateCombineSource(base.gameObject, ref incompatibilityReason, ref _renderer, ref _filter, ref _mesh);
+	}
+
+	protected override void CreateSources()
+	{
+		if (_sources == null)
+		{
+			_sources = new CombineSource[_mesh.subMeshCount];
+		}
+		if (_parts == null)
+		{
+			_parts = new CombinedObjectPart[_mesh.subMeshCount];
+		}
+		for (int i = 0; i < _sources.Length; i++)
+		{
+			CombineSource combineSource = new CombineSource(_mesh, _renderer, i);
+			_sources[i] = combineSource;
+		}
+	}
+
+	protected override IEnumerable<ICombineSource> GetCombineSources()
+	{
+		if (_sources == null)
+		{
+			yield break;
+		}
+		for (int i = 0; i < _sources.Length; i++)
+		{
+			CombineSource combineSource = _sources[i];
+			if (combineSource == null)
+			{
+				break;
+			}
+			yield return combineSource;
+		}
+	}
+
+	protected override IEnumerable<ICombinedObjectPart> GetCombinedParts()
+	{
+		if (_parts == null)
+		{
+			yield break;
+		}
+		for (int i = 0; i < _parts.Length; i++)
+		{
+			CombinedObjectPart combinedObjectPart = _parts[i];
+			if (combinedObjectPart == null)
+			{
+				break;
+			}
+			yield return combinedObjectPart;
+		}
+	}
+
+	protected override void ClearSources()
+	{
+		if (_sources != null)
+		{
+			for (int i = 0; i < _sources.Length; i++)
+			{
+				_sources[i] = null;
+			}
+		}
+	}
+
+	protected override void ClearParts()
+	{
+		if (_parts != null)
+		{
+			for (int i = 0; i < _parts.Length; i++)
+			{
+				_parts[i] = null;
+			}
+		}
+	}
+
+	protected override void ToggleComponents(bool enabled)
+	{
+		_renderer.enabled = enabled;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/StaticObjectsCombiner.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/StaticObjectsCombiner.cs
new file mode 100644
index 0000000..e1cc19a
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/StaticObjectsCombiner.cs
@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+
+namespace NGS.MeshFusionPro;
+
+public class StaticObjectsCombiner : ObjectsCombiner<CombinedObject, CombineSource>
+{
+	private ICombinedMeshFactory _factory;
+
+	private StaticCombinedObjectMatcher _matcher;
+
+	private int _vertexLimit;
+
+	public StaticObjectsCombiner(ICombinedMeshFactory factory, int vertexLimit)
+	{
+		_factory = factory;
+		_matcher = new StaticCombinedObjectMatcher(vertexLimit);
+		_vertexLimit = vertexLimit;
+	}
+
+	public override void AddSource(CombineSource source)
+	{
+		if (source.CombineInfo.vertexCount < _vertexLimit)
+		{
+			base.AddSource(source);
+		}
+	}
+
+	protected override void CombineSources(CombinedObject root, IList<CombineSource> sources)
+	{
+		root.Combine(sources);
+	}
+
+	protected override CombinedObject CreateCombinedObject(CombineSource source)
+	{
+		return CombinedObject.Create(_factory, source.RendererSettings);
+	}
+
+	protected override CombinedObjectMatcher<CombinedObject, CombineSource> GetMatcher()
+	{
+		return _matcher;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/TrackingTarget.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/TrackingTarget.cs
new file mode 100644
index 0000000..3c2276b
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/TrackingTarget.cs
@@ -0,0 +1,7 @@
+namespace NGS.MeshFusionPro;
+
+public enum TrackingTarget
+{
+	Transform,
+	Rigidbody
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/TransformTrackingStrategy.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/TransformTrackingStrategy.cs
new file mode 100644
index 0000000..2a5f282
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/TransformTrackingStrategy.cs
@@ -0,0 +1,30 @@
+using UnityEngine;
+
+namespace NGS.MeshFusionPro;
+
+public class TransformTrackingStrategy : ISourceTrackingStrategy
+{
+	private Transform _transform;
+
+	private DynamicCombinedObjectPart[] _parts;
+
+	public TransformTrackingStrategy(Transform target, DynamicCombinedObjectPart[] parts)
+	{
+		_transform = target;
+		_parts = parts;
+	}
+
+	public bool OnUpdate()
+	{
+		if (_transform.hasChanged)
+		{
+			for (int i = 0; i < _parts.Length; i++)
+			{
+				_parts[i].Move(_transform.localToWorldMatrix);
+			}
+			_transform.hasChanged = false;
+			return true;
+		}
+		return false;
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/UniversalObjectsCombiner.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/UniversalObjectsCombiner.cs
new file mode 100644
index 0000000..ae5189f
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/UniversalObjectsCombiner.cs
@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+
+namespace NGS.MeshFusionPro;
+
+public class UniversalObjectsCombiner
+{
+	private StaticObjectsCombiner _staticCombiner;
+
+	private DynamicObjectsCombiner _dynamicCombiner;
+
+	private LODGroupsCombiner _lodCombiner;
+
+	public event Action<CombinedObject> onStaticCombinedObjectCreated;
+
+	public event Action<DynamicCombinedObject> onDynamicCombinedObjectCreated;
+
+	public event Action<CombinedLODGroup> onCombinedLODGroupCreated;
+
+	public UniversalObjectsCombiner(ICombinedMeshFactory factory, int vertexLimit)
+	{
+		_staticCombiner = new StaticObjectsCombiner(factory, vertexLimit);
+		_dynamicCombiner = new DynamicObjectsCombiner(factory, vertexLimit);
+		_lodCombiner = new LODGroupsCombiner(factory, vertexLimit);
+		_staticCombiner.onCombinedObjectCreated += delegate(CombinedObject r)
+		{
+			this.onStaticCombinedObjectCreated?.Invoke(r);
+		};
+		_dynamicCombiner.onCombinedObjectCreated += delegate(DynamicCombinedObject r)
+		{
+			this.onDynamicCombinedObjectCreated?.Invoke(r);
+		};
+		_lodCombiner.onCombinedObjectCreated += delegate(CombinedLODGroup r)
+		{
+			this.onCombinedLODGroupCreated?.Invoke(r);
+		};
+	}
+
+	public void AddSource(ICombineSource source)
+	{
+		if (source is CombineSource source2)
+		{
+			_staticCombiner.AddSource(source2);
+			return;
+		}
+		if (source is DynamicCombineSource source3)
+		{
+			_dynamicCombiner.AddSource(source3);
+			return;
+		}
+		if (source is LODGroupCombineSource source4)
+		{
+			_lodCombiner.AddSource(source4);
+			return;
+		}
+		throw new NotImplementedException("Unknown Combine Source");
+	}
+
+	public void AddSources(IEnumerable<ICombineSource> sources)
+	{
+		foreach (ICombineSource source in sources)
+		{
+			AddSource(source);
+		}
+	}
+
+	public void RemoveSource(ICombineSource source)
+	{
+		if (source is CombineSource source2)
+		{
+			_staticCombiner.RemoveSource(source2);
+			return;
+		}
+		if (source is DynamicCombineSource source3)
+		{
+			_dynamicCombiner.RemoveSource(source3);
+			return;
+		}
+		if (source is LODGroupCombineSource source4)
+		{
+			_lodCombiner.RemoveSource(source4);
+			return;
+		}
+		throw new NotImplementedException("Unknown Combine Source");
+	}
+
+	public void Combine()
+	{
+		if (_staticCombiner.ContainSources)
+		{
+			_staticCombiner.Combine();
+		}
+		if (_dynamicCombiner.ContainSources)
+		{
+			_dynamicCombiner.Combine();
+		}
+		if (_lodCombiner.ContainSources)
+		{
+			_lodCombiner.Combine();
+		}
+	}
+}
diff --git a/Thronefall_1_57/Decompile/NGS.MeshFusionPro/VertexBufferUtil.cs b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/VertexBufferUtil.cs
new file mode 100644
index 0000000..e409ce5
--- /dev/null
+++ b/Thronefall_1_57/Decompile/NGS.MeshFusionPro/VertexBufferUtil.cs
@@ -0,0 +1,124 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+
+namespace NGS.MeshFusionPro;
+
+public static class VertexBufferUtil
+{
+	private static readonly Dictionary<VertexAttribute, VertexAttributeDescriptor> StandardAttributesMap;
+
+	private static readonly VertexAttributeDescriptor[] LightweightAttributesLayout;
+
+	private static List<VertexAttributeDescriptor> _meshAttributes;
+
+	static VertexBufferUtil()
+	{
+		LightweightAttributesLayout = new VertexAttributeDescriptor[5]
+		{
+			new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, 3, 0),
+			new VertexAttributeDescriptor(VertexAttribute.Normal, VertexAttributeFormat.SNorm8, 4),
+			new VertexAttributeDescriptor(VertexAttribute.Tangent, VertexAttributeFormat.SNorm8, 4),
+			new VertexAttributeDescriptor(VertexAttribute.TexCoord0, VertexAttributeFormat.Float16, 2),
+			new VertexAttributeDescriptor(VertexAttribute.TexCoord1, VertexAttributeFormat.Float16, 2)
+		};
+		StandardAttributesMap = new Dictionary<VertexAttribute, VertexAttributeDescriptor>
+		{
+			{
+				VertexAttribute.Position,
+				new VertexAttributeDescriptor(VertexAttribute.Position, VertexAttributeFormat.Float32, 3, 0)
+			},
+			{
+				VertexAttribute.Normal,
+				new VertexAttributeDescriptor(VertexAttribute.Normal)
+			},
+			{
+				VertexAttribute.Tangent,
+				new VertexAttributeDescriptor(VertexAttribute.Tangent, VertexAttributeFormat.Float32, 4)
+			},
+			{
+				VertexAttribute.TexCoord0,
+				new VertexAttributeDescriptor(VertexAttribute.TexCoord0, VertexAttributeFormat.Float32, 2)
+			},
+			{
+				VertexAttribute.TexCoord1,
+				new VertexAttributeDescriptor(VertexAttribute.TexCoord1, VertexAttributeFormat.Float32, 2)
+			},
+			{
+				VertexAttribute.TexCoord2,
+				new VertexAttributeDescriptor(VertexAttribute.TexCoord2, VertexAttributeFormat.Float32, 2)
+			},
+			{
+				VertexAttribute.TexCoord3,
+				new VertexAttributeDescriptor(VertexAttribute.TexCoord3, VertexAttributeFormat.Float32, 2)
+			}
+		};
+		_meshAttributes = new List<VertexAttributeDescriptor>();
+	}
+
+	public static bool IsStandardBuffer(Mesh mesh)
+	{
+		mesh.GetVertexAttributes(_meshAttributes);
+		for (int i = 0; i < _meshAttributes.Count; i++)
+		{
+			VertexAttributeDescriptor vertexAttributeDescriptor = _meshAttributes[i];
+			VertexAttributeDescriptor vertexAttributeDescriptor2 = StandardAttributesMap[vertexAttributeDescriptor.attribute];
+			if (vertexAttributeDescriptor.format != vertexAttributeDescriptor2.format)
+			{
+				return false;
+			}
+			if (vertexAttributeDescriptor.dimension != vertexAttributeDescriptor2.dimension)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static bool IsLightweightBuffer(Mesh mesh)
+	{
+		mesh.GetVertexAttributes(_meshAttributes);
+		if (_meshAttributes.Count != LightweightAttributesLayout.Length)
+		{
+			return false;
+		}
+		for (int i = 0; i < _meshAttributes.Count; i++)
+		{
+			VertexAttributeDescriptor vertexAttributeDescriptor = _meshAttributes[i];
+			VertexAttributeDescriptor vertexAttributeDescriptor2 = LightweightAttributesLayout[i];
+			if (vertexAttributeDescriptor.attribute != vertexAttributeDescriptor2.attribute)
+			{
+				return false;
+			}
+			if (vertexAttributeDescriptor.format != vertexAttributeDescriptor2.format)
+			{
+				return false;
+			}
+			if (vertexAttributeDescriptor.dimension != vertexAttributeDescriptor2.dimension)
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static void ToStandardBuffer(Mesh mesh)
+	{
+		if (!IsStandardBuffer(mesh))
+		{
+			for (int i = 0; i < _meshAttributes.Count; i++)
+			{
+				_meshAttributes[i] = StandardAttributesMap[_meshAttributes[i].attribute];
+			}
+			mesh.SetVertexBufferParams(mesh.vertexCount, _meshAttributes.ToArray());
+		}
+	}
+
+	public static void ToLightweightBuffer(Mesh mesh)
+	{
+		if (!IsLightweightBuffer(mesh))
+		{
+			mesh.SetVertexBufferParams(mesh.vertexCount, LightweightAttributesLayout);
+		}
+	}
+}