// Warning: Some assembly references could not be resolved automatically. This might lead to incorrect decompilation of some parts,
// for ex. property getter/setter access. To get optimal decompilation results, please manually add the missing references to the list of loaded assemblies.
// EdenAutoMorpherScript, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// Eden.AutoMorpher.WeightTransferUtil
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Eden.AutoMorpher;
using Unity.Collections;
using UnityEditor;
using UnityEngine;

public class WeightTransferUtil
{
	[Serializable]
	public class Settings
	{
		[Header("최근접 표면 매칭")]
		public float maxDistance = 0.1f;

		public float maxNormalAngleDeg = 35f;

		public bool allowFlippedNormal = true;

		[Header("추가 스무딩")]
		public bool enableSmoothing = true;

		public int smoothingIterations = 4;

		[Range(0f, 1f)]
		public float smoothingAlpha = 0.25f;

		[Header("본 수 제한 & 임계값")]
		public bool enforceFourBoneLimit = true;

		public float tinyWeight = 0.0001f;

		public bool weightInClothes;
	}

	private bool NameContainsAny(string lowerName, string[] patterns)
	{
		for (int i = 0; i < patterns.Length; i++)
		{
			if (lowerName.Contains(patterns[i]))
			{
				return true;
			}
		}
		return false;
	}

	private bool IsBreastOrButtBone(Transform t)
	{
		if ((Object)(object)t == (Object)null)
		{
			return false;
		}
		string[] patterns = new string[6] { "breast", "boob", "bust", "oppai", "chichi", "mune" };
		string[] patterns2 = new string[6] { "butt", "buttock", "buttox", "glute", "glutes", "gluteus" };
		string lowerName = ((Object)t).name.ToLowerInvariant();
		if (NameContainsAny(lowerName, patterns))
		{
			return true;
		}
		if (NameContainsAny(lowerName, patterns2))
		{
			return true;
		}
		return false;
	}

	public IEnumerator RetargetAndTransfer(ClothInstance cloth, Animator avatarAnimator, IReadOnlyList<SkinnedMeshRenderer> bodyMeshes, IReadOnlyList<Mesh> bodyBakedMeshes, int referenceBodyIndex = 0, Settings settings = null, Dictionary<Transform, ClothBoneType> boneTypeMap = null, Dictionary<Transform, Transform> bodyToClothesMap = null)
	{
		if (cloth == null || (Object)(object)cloth.smr == (Object)null || (Object)(object)cloth.editableMesh == (Object)null)
		{
			throw new AutoMorpherException("Cloth Instance is Invalid", "[WeightTransferUtil] RetargetAndTransfer\n - cloth is null or cloth.smr is null or cloth.editableMesh is null");
		}
		if (cloth.worldVertices == null || cloth.worldVertices.Length == 0)
		{
			throw new AutoMorpherException("Cloth World Vertices are Missing", "[WeightTransferUtil] RetargetAndTransfer\n - cloth.worldVertices is null or empty");
		}
		if ((Object)(object)cloth.bakedMesh == (Object)null)
		{
			throw new AutoMorpherException("Cloth Baked Mesh is Missing", "[WeightTransferUtil] RetargetAndTransfer\n - cloth.bakedMesh is null");
		}
		if ((Object)(object)avatarAnimator == (Object)null || !avatarAnimator.isHuman)
		{
			throw new AutoMorpherException("Avatar Animator is Invalid", "[WeightTransferUtil] RetargetAndTransfer\n - avatarAnimator is null or not a Humanoid");
		}
		if (bodyMeshes == null || bodyMeshes.Count == 0)
		{
			throw new AutoMorpherException("Body Meshes are Missing", "[WeightTransferUtil] RetargetAndTransfer\n - bodyMeshes is null or empty");
		}
		if (referenceBodyIndex < 0 || referenceBodyIndex >= bodyMeshes.Count)
		{
			referenceBodyIndex = 0;
		}
		SkinnedMeshRenderer bodyRefSmr = bodyMeshes[referenceBodyIndex];
		if ((Object)(object)bodyRefSmr == (Object)null || (Object)(object)bodyRefSmr.sharedMesh == (Object)null)
		{
			throw new AutoMorpherException("Reference Body Mesh is Invalid", "[WeightTransferUtil] RetargetAndTransfer\n - bodyRefSmr is null or bodyRefSmr.sharedMesh is null\n - referenceBodyIndex : " + referenceBodyIndex);
		}
		if (settings == null)
		{
			settings = new Settings();
		}
		Transform[] accessoryBones = null;
		float[,] accessoryWeights = null;
		BoneWeight[] prevBoneWeights = null;
		yield return null;
		Transform[] bones;
		Dictionary<Transform, int> accIndexByTransform;
		float tiny;
		if (boneTypeMap != null && (Object)(object)cloth.smr != (Object)null && (Object)(object)cloth.editableMesh != (Object)null)
		{
			bones = cloth.smr.bones;
			if (bones != null && bones.Length != 0)
			{
				HashSet<Transform> value = null;
				if (cloth.humanoidMatchedBones != null)
				{
					cloth.humanoidMatchedBones.TryGetValue((HumanBodyBones)10, out value);
				}
				HashSet<Transform> hashSet = new HashSet<Transform>();
				foreach (Transform val in bones)
				{
					if (!((Object)(object)val == (Object)null) && boneTypeMap.TryGetValue(val, out var value2) && value2 == ClothBoneType.Accessory)
					{
						hashSet.Add(val);
					}
				}
				if (value != null)
				{
					foreach (Transform item in value)
					{
						if (!((Object)(object)item == (Object)null) && Array.IndexOf(bones, item) >= 0)
						{
							hashSet.Add(item);
						}
					}
				}
				List<Transform> list = new List<Transform>();
				accIndexByTransform = new Dictionary<Transform, int>();
				foreach (Transform val2 in bones)
				{
					if (!((Object)(object)val2 == (Object)null) && hashSet.Contains(val2) && !IsBreastOrButtBone(val2) && !accIndexByTransform.ContainsKey(val2))
					{
						accIndexByTransform[val2] = list.Count;
						list.Add(val2);
					}
				}
				if (list.Count > 0)
				{
					accessoryBones = list.ToArray();
					int vertexCount = cloth.editableMesh.vertexCount;
					accessoryWeights = new float[vertexCount, accessoryBones.Length];
					BoneWeight[] boneWeights = cloth.editableMesh.boneWeights;
					if (boneWeights != null && boneWeights.Length == vertexCount)
					{
						tiny = 1E-06f;
						for (int k = 0; k < vertexCount; k++)
						{
							BoneWeight val3 = boneWeights[k];
							Acc(((BoneWeight)(ref val3)).boneIndex0, ((BoneWeight)(ref val3)).weight0, k);
							Acc(((BoneWeight)(ref val3)).boneIndex1, ((BoneWeight)(ref val3)).weight1, k);
							Acc(((BoneWeight)(ref val3)).boneIndex2, ((BoneWeight)(ref val3)).weight2, k);
							Acc(((BoneWeight)(ref val3)).boneIndex3, ((BoneWeight)(ref val3)).weight3, k);
						}
					}
				}
			}
		}
		int bodyBoneCount = bodyRefSmr.bones.Length;
		yield return null;
		RetargetClothToAvatarSkeleton(cloth, avatarAnimator, bodyRefSmr, accessoryBones);
		TransferFromBodyToCloth(avatarAnimator, cloth, bodyMeshes, bodyBakedMeshes, settings, accessoryBones, accessoryWeights, bodyBoneCount, prevBoneWeights);
		if (settings.weightInClothes)
		{
			MoveBodyWeightsToClothesBones(cloth.smr, cloth.smr.sharedMesh, bodyToClothesMap, accessoryBones);
		}
		void Acc(int boneIndex, float w, int v)
		{
			if (!(w <= tiny) && boneIndex >= 0 && boneIndex < bones.Length)
			{
				Transform val4 = bones[boneIndex];
				if (!((Object)(object)val4 == (Object)null) && accIndexByTransform.TryGetValue(val4, out var value3))
				{
					accessoryWeights[v, value3] += w;
				}
			}
		}
	}

	private void RetargetClothToAvatarSkeleton(ClothInstance cloth, Animator avatarAnimator, SkinnedMeshRenderer bodyRefSmr, Transform[] accessoryBones = null)
	{
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: Invalid comparison between Unknown and I4
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_045a: Unknown result type (might be due to invalid IL or missing references)
		//IL_045f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0443: Unknown result type (might be due to invalid IL or missing references)
		//IL_0448: Unknown result type (might be due to invalid IL or missing references)
		//IL_044a: Unknown result type (might be due to invalid IL or missing references)
		//IL_044f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_047c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0481: Unknown result type (might be due to invalid IL or missing references)
		//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0238: Unknown result type (might be due to invalid IL or missing references)
		//IL_023d: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_030e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0313: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0303: Unknown result type (might be due to invalid IL or missing references)
		//IL_04af: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
		SkinnedMeshRenderer smr = cloth.smr;
		Mesh sharedMesh = cloth.smr.sharedMesh;
		if ((Object)(object)sharedMesh == (Object)null)
		{
			throw new AutoMorpherException("Cloth Mesh is Missing", "[WeightTransferUtil] RetargetClothToAvatarSkeleton\n - clothMesh is null");
		}
		Transform[] bones = smr.bones;
		Transform[] bones2 = bodyRefSmr.bones;
		if (bones == null || bones.Length == 0 || bones2 == null || bones2.Length == 0)
		{
			throw new AutoMorpherException("Cloth or Target Bones are Missing", "[WeightTransferUtil] RetargetClothToAvatarSkeleton\n - clothBones is null/empty or targetBones is null/empty\n - clothBones.Length : " + ((bones == null) ? (-1) : bones.Length) + "\n - targetBones.Length : " + ((bones2 == null) ? (-1) : bones2.Length));
		}
		Matrix4x4 localToWorldMatrix = ((Component)smr).transform.localToWorldMatrix;
		if (accessoryBones == null || accessoryBones.Length == 0)
		{
			Dictionary<Transform, HumanBodyBones> dictionary = new Dictionary<Transform, HumanBodyBones>();
			foreach (KeyValuePair<HumanBodyBones, HashSet<Transform>> humanoidMatchedBone in cloth.humanoidMatchedBones)
			{
				HumanBodyBones key = humanoidMatchedBone.Key;
				HashSet<Transform> value = humanoidMatchedBone.Value;
				if (value == null)
				{
					continue;
				}
				foreach (Transform item in value)
				{
					if (!((Object)(object)item == (Object)null) && !dictionary.ContainsKey(item))
					{
						dictionary.Add(item, key);
					}
				}
			}
			Dictionary<HumanBodyBones, int> dictionary2 = new Dictionary<HumanBodyBones, int>();
			Dictionary<Transform, int> dictionary3 = new Dictionary<Transform, int>();
			for (int i = 0; i < bones2.Length; i++)
			{
				Transform val = bones2[i];
				if ((Object)(object)val != (Object)null && !dictionary3.ContainsKey(val))
				{
					dictionary3.Add(val, i);
				}
			}
			foreach (HumanBodyBones value4 in Enum.GetValues(typeof(HumanBodyBones)))
			{
				if ((int)value4 != 55)
				{
					Transform boneTransform = avatarAnimator.GetBoneTransform(value4);
					if (!((Object)(object)boneTransform == (Object)null) && dictionary3.TryGetValue(boneTransform, out var value2))
					{
						dictionary2[value4] = value2;
					}
				}
			}
			BoneWeight[] boneWeights = sharedMesh.boneWeights;
			if (boneWeights == null || boneWeights.Length == 0)
			{
				Debug.LogWarning((object)"[WeightTransferUtil] clothMesh.boneWeights 가 비어 있음. 리타겟할 weight 가 없음.");
				return;
			}
			int vertexCount = sharedMesh.vertexCount;
			int num = bones2.Length;
			float[,] array = new float[vertexCount, num];
			for (int j = 0; j < vertexCount; j++)
			{
				BoneWeight val3 = boneWeights[j];
				AccumulateRetargetWeight(array, j, ((BoneWeight)(ref val3)).boneIndex0, ((BoneWeight)(ref val3)).weight0, bones, dictionary, dictionary2);
				AccumulateRetargetWeight(array, j, ((BoneWeight)(ref val3)).boneIndex1, ((BoneWeight)(ref val3)).weight1, bones, dictionary, dictionary2);
				AccumulateRetargetWeight(array, j, ((BoneWeight)(ref val3)).boneIndex2, ((BoneWeight)(ref val3)).weight2, bones, dictionary, dictionary2);
				AccumulateRetargetWeight(array, j, ((BoneWeight)(ref val3)).boneIndex3, ((BoneWeight)(ref val3)).weight3, bones, dictionary, dictionary2);
			}
			BoneWeight[] boneWeights2 = CollapseWeightsToBoneWeights(array, 4, 0.0001f);
			Matrix4x4[] array2 = (Matrix4x4[])(object)new Matrix4x4[bones2.Length];
			for (int k = 0; k < bones2.Length; k++)
			{
				Transform val4 = bones2[k];
				if ((Object)(object)val4 != (Object)null)
				{
					array2[k] = val4.worldToLocalMatrix * localToWorldMatrix;
				}
				else
				{
					array2[k] = Matrix4x4.identity;
				}
			}
			sharedMesh.boneWeights = boneWeights2;
			sharedMesh.bindposes = array2;
			smr.rootBone = bodyRefSmr.rootBone;
			smr.bones = bones2;
			EditorUtility.SetDirty((Object)(object)sharedMesh);
			EditorUtility.SetDirty((Object)(object)smr);
			return;
		}
		Transform[] bones3 = bodyRefSmr.bones;
		if (bones3 == null || bones3.Length == 0)
		{
			throw new AutoMorpherException("Target Body Bones are Missing", "[WeightTransferUtil] RetargetClothToAvatarSkeleton\n - bodyRefSmr.bones is null or empty");
		}
		Transform[] bones4 = smr.bones;
		Matrix4x4[] bindposes = sharedMesh.bindposes;
		Dictionary<Transform, int> dictionary4 = new Dictionary<Transform, int>();
		if (bones4 != null)
		{
			for (int l = 0; l < bones4.Length; l++)
			{
				Transform val5 = bones4[l];
				if (!((Object)(object)val5 == (Object)null) && !dictionary4.ContainsKey(val5))
				{
					dictionary4.Add(val5, l);
				}
			}
		}
		int num2 = bones3.Length;
		int num3 = accessoryBones.Length;
		Transform[] array3 = (Transform[])(object)new Transform[num2 + num3];
		for (int m = 0; m < num2; m++)
		{
			array3[m] = bones3[m];
		}
		for (int n = 0; n < num3; n++)
		{
			array3[num2 + n] = accessoryBones[n];
		}
		Matrix4x4[] array4 = (Matrix4x4[])(object)new Matrix4x4[array3.Length];
		for (int num4 = 0; num4 < num2; num4++)
		{
			Transform val6 = bones3[num4];
			if ((Object)(object)val6 != (Object)null)
			{
				array4[num4] = val6.worldToLocalMatrix * localToWorldMatrix;
			}
			else
			{
				array4[num4] = Matrix4x4.identity;
			}
		}
		for (int num5 = 0; num5 < num3; num5++)
		{
			Transform val7 = accessoryBones[num5];
			Matrix4x4 val8 = Matrix4x4.identity;
			if ((Object)(object)val7 != (Object)null && dictionary4.TryGetValue(val7, out var value3))
			{
				val8 = ((bindposes == null || value3 < 0 || value3 >= bindposes.Length) ? (val7.worldToLocalMatrix * localToWorldMatrix) : bindposes[value3]);
			}
			array4[num2 + num5] = val8;
		}
		sharedMesh.bindposes = array4;
		sharedMesh.boneWeights = (BoneWeight[])(object)new BoneWeight[sharedMesh.vertexCount];
		smr.rootBone = bodyRefSmr.rootBone;
		smr.bones = array3;
		EditorUtility.SetDirty((Object)(object)sharedMesh);
		EditorUtility.SetDirty((Object)(object)smr);
	}

	private void AccumulateRetargetWeight(float[,] W, int vertIndex, int clothBoneIndex, float weight, Transform[] clothBones, Dictionary<Transform, HumanBodyBones> clothBoneToHuman, Dictionary<HumanBodyBones, int> humanToTargetBoneIndex)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		if (!(weight <= 0f) && clothBoneIndex >= 0 && clothBoneIndex < clothBones.Length)
		{
			Transform val = clothBones[clothBoneIndex];
			if (!((Object)(object)val == (Object)null) && clothBoneToHuman.TryGetValue(val, out var value) && humanToTargetBoneIndex.TryGetValue(value, out var value2))
			{
				W[vertIndex, value2] += weight;
			}
		}
	}

	private void TransferFromBodyToCloth(Animator avatarAnimator, ClothInstance cloth, IReadOnlyList<SkinnedMeshRenderer> bodyMeshes, IReadOnlyList<Mesh> bodyBakedMeshes, Settings settings, Transform[] accessoryBones, float[,] accessoryWeights, int bodyBoneCount, BoneWeight[] prevBoneWeights = null)
	{
		//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_020a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_023f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0244: Unknown result type (might be due to invalid IL or missing references)
		//IL_0246: Unknown result type (might be due to invalid IL or missing references)
		//IL_024b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0250: Unknown result type (might be due to invalid IL or missing references)
		//IL_0264: Unknown result type (might be due to invalid IL or missing references)
		//IL_0269: Unknown result type (might be due to invalid IL or missing references)
		//IL_026e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0279: Unknown result type (might be due to invalid IL or missing references)
		//IL_027e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0283: Unknown result type (might be due to invalid IL or missing references)
		//IL_0287: Unknown result type (might be due to invalid IL or missing references)
		//IL_028c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_0297: Unknown result type (might be due to invalid IL or missing references)
		//IL_0302: Unknown result type (might be due to invalid IL or missing references)
		//IL_0307: Unknown result type (might be due to invalid IL or missing references)
		Vector3[] worldVertices = cloth.worldVertices;
		if (worldVertices == null || worldVertices.Length == 0)
		{
			throw new AutoMorpherException("Cloth World Vertices are Missing", "[WeightTransferUtil] TransferFromBodyToCloth\n - cloth.worldVertices is null or empty");
		}
		int[] triangles = cloth.editableMesh.triangles;
		Vector3[] clothWorldNormals = GetClothWorldNormals(cloth);
		if (clothWorldNormals == null || clothWorldNormals.Length != worldVertices.Length)
		{
			throw new AutoMorpherException("Cloth World Normals Calculation Failed", "[WeightTransferUtil] TransferFromBodyToCloth\n - targetNormalsWorld is null or length mismatch\n - targetVertsWorld.Length : " + ((worldVertices == null) ? (-1) : worldVertices.Length) + "\n - targetNormalsWorld.Length : " + ((clothWorldNormals == null) ? (-1) : clothWorldNormals.Length));
		}
		Transform[] bones = cloth.smr.bones;
		int num = bones.Length;
		Dictionary<Transform, int> dictionary = new Dictionary<Transform, int>();
		for (int i = 0; i < bones.Length; i++)
		{
			Transform val = bones[i];
			if ((Object)(object)val != (Object)null && !dictionary.ContainsKey(val))
			{
				dictionary.Add(val, i);
			}
		}
		int num2 = 0;
		int num3 = 0;
		foreach (SkinnedMeshRenderer bodyMesh in bodyMeshes)
		{
			if (!((Object)(object)bodyMesh == (Object)null) && !((Object)(object)bodyMesh.sharedMesh == (Object)null))
			{
				num2 += bodyMesh.sharedMesh.vertexCount;
				num3 += bodyMesh.sharedMesh.triangles.Length;
			}
		}
		if (num2 == 0 || num3 == 0)
		{
			throw new AutoMorpherException("Valid Body Mesh is Missing", "[WeightTransferUtil] TransferFromBodyToCloth\n - bodyMeshes has no valid mesh (totalVerts == 0 or totalTris == 0)");
		}
		Vector3[] array = (Vector3[])(object)new Vector3[num2];
		Vector3[] array2 = (Vector3[])(object)new Vector3[num2];
		int[] array3 = new int[num3];
		float[,] W = new float[num2, num];
		int num4 = 0;
		int num5 = 0;
		Vector3 val3 = default(Vector3);
		for (int j = 0; j < bodyMeshes.Count; j++)
		{
			SkinnedMeshRenderer val2 = bodyMeshes[j];
			if ((Object)(object)val2 == (Object)null || (Object)(object)val2.sharedMesh == (Object)null)
			{
				continue;
			}
			Mesh sharedMesh = val2.sharedMesh;
			Mesh obj = bodyBakedMeshes[j];
			Vector3[] vertices = obj.vertices;
			Vector3[] normals = obj.normals;
			int[] triangles2 = obj.triangles;
			int vertexCount = obj.vertexCount;
			Vector3 lossyScale = ((Component)val2).transform.lossyScale;
			((Vector3)(ref val3))._002Ector(1f / Mathf.Max(lossyScale.x, 1E-08f), 1f / Mathf.Max(lossyScale.y, 1E-08f), 1f / Mathf.Max(lossyScale.z, 1E-08f));
			Matrix4x4 val4 = ((Component)val2).transform.localToWorldMatrix * Matrix4x4.Scale(val3);
			for (int k = 0; k < vertexCount; k++)
			{
				array[num4 + k] = ((Matrix4x4)(ref val4)).MultiplyPoint3x4(vertices[k]);
				Vector3 val5 = ((Matrix4x4)(ref val4)).MultiplyVector(normals[k]);
				Vector3 normalized = ((Vector3)(ref val5)).normalized;
				array2[num4 + k] = normalized;
			}
			for (int l = 0; l < triangles2.Length; l++)
			{
				array3[num5 + l] = triangles2[l] + num4;
			}
			BoneWeight[] boneWeights = sharedMesh.boneWeights;
			Transform[] bones2 = val2.bones;
			if (boneWeights != null && boneWeights.Length == vertexCount && bones2 != null)
			{
				for (int m = 0; m < vertexCount; m++)
				{
					BoneWeight val6 = boneWeights[m];
					AccumulateBodyWeight(ref W, num4 + m, ((BoneWeight)(ref val6)).boneIndex0, ((BoneWeight)(ref val6)).weight0, bones2, dictionary);
					AccumulateBodyWeight(ref W, num4 + m, ((BoneWeight)(ref val6)).boneIndex1, ((BoneWeight)(ref val6)).weight1, bones2, dictionary);
					AccumulateBodyWeight(ref W, num4 + m, ((BoneWeight)(ref val6)).boneIndex2, ((BoneWeight)(ref val6)).weight2, bones2, dictionary);
					AccumulateBodyWeight(ref W, num4 + m, ((BoneWeight)(ref val6)).boneIndex3, ((BoneWeight)(ref val6)).weight3, bones2, dictionary);
				}
			}
			num4 += vertexCount;
			num5 += triangles2.Length;
		}
		List<int>[] array4 = cloth.vertexAdjacency;
		if (array4 == null || array4.Length != worldVertices.Length)
		{
			array4 = BuildAdjacencyFromTriangles(worldVertices.Length, triangles);
		}
		float[,] weights = FindMatchesClosestSurface(array, array3, array2, worldVertices, clothWorldNormals, W, settings.maxDistance * settings.maxDistance, settings.maxNormalAngleDeg, settings.allowFlippedNormal, out var matchedMask);
		weights = InpaintApprox(worldVertices, triangles, weights, matchedMask, array4, 20, 0.7f);
		if (settings.enableSmoothing && settings.smoothingIterations > 0 && settings.smoothingAlpha > 0f)
		{
			weights = SmoothWeightsApprox(worldVertices, weights, matchedMask, array4, settings.smoothingIterations, settings.smoothingAlpha, settings.maxDistance);
		}
		ApplyLegVertexConstraints(avatarAnimator, cloth, weights, bodyBoneCount, settings.tinyWeight);
		int vertexCount2 = cloth.editableMesh.vertexCount;
		num = cloth.smr.bones.Length;
		if (accessoryBones != null && accessoryBones.Length != 0 && accessoryWeights != null && bodyBoneCount > 0)
		{
			HashSet<Transform> value = null;
			if (cloth.humanoidMatchedBones != null)
			{
				cloth.humanoidMatchedBones.TryGetValue((HumanBodyBones)10, out value);
			}
			Transform val7 = null;
			if ((Object)(object)avatarAnimator != (Object)null)
			{
				val7 = avatarAnimator.GetBoneTransform((HumanBodyBones)10);
			}
			if (value != null && (Object)(object)val7 != (Object)null)
			{
				int num6 = Array.IndexOf(cloth.smr.bones, val7);
				if (num6 >= 0 && num6 < bodyBoneCount)
				{
					foreach (Transform item in value)
					{
						if ((Object)(object)item == (Object)null)
						{
							continue;
						}
						int num7 = Array.IndexOf(accessoryBones, item);
						if (num7 < 0)
						{
							continue;
						}
						for (int n = 0; n < vertexCount2; n++)
						{
							float num8 = accessoryWeights[n, num7];
							if (!(num8 <= settings.tinyWeight))
							{
								weights[n, num6] += num8;
								accessoryWeights[n, num7] = 0f;
							}
						}
					}
				}
			}
		}
		BoneWeight[] array5;
		if (accessoryBones != null && accessoryBones.Length != 0 && accessoryWeights != null && bodyBoneCount > 0 && bodyBoneCount + accessoryBones.Length == num)
		{
			array5 = MergeBodyAndAccessoryWeights(weights, accessoryWeights, bodyBoneCount, settings.tinyWeight, settings.enforceFourBoneLimit);
		}
		else
		{
			if (settings.enforceFourBoneLimit)
			{
				EnforceMaxBonesPerVertex(weights, 4, settings.tinyWeight);
			}
			else
			{
				ZeroSmallWeights(weights, settings.tinyWeight);
			}
			NormalizeWeightsPerVertex(weights, settings.tinyWeight);
			array5 = CollapseWeightsToBoneWeights(weights, 4, settings.tinyWeight);
		}
		Mesh sharedMesh2 = cloth.smr.sharedMesh;
		if (sharedMesh2.vertexCount != array5.Length)
		{
			throw new AutoMorpherException("Vertex Count and Weight Length Mismatch", "[WeightTransferUtil] TransferFromBodyToCloth\n - mesh.vertexCount : " + sharedMesh2.vertexCount + "\n - finalWeights.Length : " + array5.Length);
		}
		EnsureNonZeroAndNormalizeFinalWeights(cloth, array5, array4, settings.tinyWeight);
		ApplyEquivalentVertexWeights(cloth, array5);
		NormalizeAllBoneWeightsInPlace(array5, settings.tinyWeight);
		sharedMesh2.boneWeights = array5;
		cloth.smr.sharedMesh = sharedMesh2;
		if (!TryApplyBoneWeightsWithValidation(sharedMesh2, array5, 1E-10f, out var zeroWeightVertexCount))
		{
			Debug.LogWarning((object)$"[WeightValidation] Zero-weight vertices detected: {zeroWeightVertexCount}");
		}
	}

	public void MoveBodyWeightsToClothesBones(SkinnedMeshRenderer clothesSmr, Mesh clothesMesh, Dictionary<Transform, Transform> bodyToClothesMap, Transform[] accessoryBones)
	{
		//IL_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)clothesSmr == (Object)null)
		{
			throw new AutoMorpherException("Clothes SMR is Missing", "[WeightTransferUtil] MoveBodyWeightsToClothesBones\n - clothesSmr is null");
		}
		if ((Object)(object)clothesMesh == (Object)null)
		{
			throw new AutoMorpherException("Clothes Mesh is Missing", "[WeightTransferUtil] MoveBodyWeightsToClothesBones\n - clothesMesh is null");
		}
		if (bodyToClothesMap == null)
		{
			throw new AutoMorpherException("Body To Clothes Map is Missing", "[WeightTransferUtil] MoveBodyWeightsToClothesBones\n - bodyToClothesMap is null");
		}
		Transform clothesFallbackRoot = (((Object)(object)clothesSmr.rootBone != (Object)null) ? clothesSmr.rootBone : ((Component)clothesSmr).transform);
		HashSet<Transform> hashSet = null;
		if (accessoryBones != null && accessoryBones.Length != 0)
		{
			hashSet = new HashSet<Transform>(accessoryBones);
		}
		Transform[] bones = clothesSmr.bones;
		if (bones == null || bones.Length == 0)
		{
			throw new AutoMorpherException("Clothes Bones are Missing", "[WeightTransferUtil] MoveBodyWeightsToClothesBones\n - clothesSmr.bones is null or empty");
		}
		Transform[] array = (Transform[])(object)new Transform[bones.Length];
		for (int i = 0; i < bones.Length; i++)
		{
			Transform val = bones[i];
			if ((Object)(object)val == (Object)null)
			{
				array[i] = clothesFallbackRoot;
				continue;
			}
			if (hashSet != null && hashSet.Contains(val))
			{
				array[i] = val;
				continue;
			}
			Transform val2 = EnsureClothesBoneExists(val);
			array[i] = (((Object)(object)val2 != (Object)null) ? val2 : clothesFallbackRoot);
		}
		clothesSmr.bones = array;
		if ((Object)(object)clothesSmr.rootBone != (Object)null && (hashSet == null || !hashSet.Contains(clothesSmr.rootBone)))
		{
			Transform val3 = EnsureClothesBoneExists(clothesSmr.rootBone);
			if ((Object)(object)val3 != (Object)null)
			{
				clothesSmr.rootBone = val3;
			}
		}
		Transform val4 = (((Object)(object)clothesSmr.rootBone != (Object)null) ? clothesSmr.rootBone : ((Component)clothesSmr).transform);
		Matrix4x4[] array2 = (Matrix4x4[])(object)new Matrix4x4[array.Length];
		for (int j = 0; j < array.Length; j++)
		{
			Transform val5 = array[j];
			if ((Object)(object)val5 == (Object)null)
			{
				throw new AutoMorpherException("Remapped Bone is Null", "[WeightTransferUtil] MoveBodyWeightsToClothesBones\n - remappedBones contains null bone after fallback");
			}
			array2[j] = val5.worldToLocalMatrix * val4.localToWorldMatrix;
		}
		clothesMesh.bindposes = array2;
		Transform EnsureClothesBoneExists(Transform bodyBone)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)bodyBone == (Object)null)
			{
				return null;
			}
			if (bodyToClothesMap.TryGetValue(bodyBone, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			Transform val6 = null;
			if ((Object)(object)bodyBone.parent != (Object)null)
			{
				val6 = EnsureClothesBoneExists(bodyBone.parent);
			}
			if ((Object)(object)val6 == (Object)null)
			{
				val6 = clothesFallbackRoot;
			}
			Transform transform = new GameObject(((Object)bodyBone).name).transform;
			transform.SetParent(val6, false);
			transform.localPosition = bodyBone.localPosition;
			transform.localRotation = bodyBone.localRotation;
			transform.localScale = bodyBone.localScale;
			bodyToClothesMap[bodyBone] = transform;
			return transform;
		}
	}

	private bool TryApplyBoneWeightsWithValidation(Mesh mesh, BoneWeight[] weights, float tiny, out int zeroWeightVertexCount)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		bool result = true;
		zeroWeightVertexCount = 0;
		int num = weights.Length;
		NativeArray<byte> val = default(NativeArray<byte>);
		val._002Ector(num, (Allocator)2, (NativeArrayOptions)1);
		List<BoneWeight1> list = new List<BoneWeight1>(num * 4);
		NativeArray<BoneWeight1> val2 = default(NativeArray<BoneWeight1>);
		try
		{
			for (int i = 0; i < num; i++)
			{
				BoneWeight val3 = weights[i];
				int count = 0;
				AddIfValid(list, ((BoneWeight)(ref val3)).boneIndex0, ((BoneWeight)(ref val3)).weight0, tiny, ref count);
				AddIfValid(list, ((BoneWeight)(ref val3)).boneIndex1, ((BoneWeight)(ref val3)).weight1, tiny, ref count);
				AddIfValid(list, ((BoneWeight)(ref val3)).boneIndex2, ((BoneWeight)(ref val3)).weight2, tiny, ref count);
				AddIfValid(list, ((BoneWeight)(ref val3)).boneIndex3, ((BoneWeight)(ref val3)).weight3, tiny, ref count);
				if (count == 0)
				{
					zeroWeightVertexCount++;
				}
				val[i] = (byte)count;
			}
			if (zeroWeightVertexCount > 0)
			{
				return false;
			}
			val2 = new NativeArray<BoneWeight1>(list.Count, (Allocator)2, (NativeArrayOptions)1);
			for (int j = 0; j < list.Count; j++)
			{
				val2[j] = list[j];
			}
			mesh.SetBoneWeights(val, val2);
		}
		catch (Exception ex)
		{
			Debug.LogWarning((object)("[SetBoneWeights] Failed: " + ex.Message));
			result = false;
		}
		finally
		{
			if (val2.IsCreated)
			{
				val2.Dispose();
			}
			if (val.IsCreated)
			{
				val.Dispose();
			}
		}
		return result;
	}

	private void AddIfValid(List<BoneWeight1> list, int boneIndex, float weight, float tiny, ref int count)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		if (boneIndex >= 0 && !(weight <= tiny))
		{
			BoneWeight1 item = default(BoneWeight1);
			((BoneWeight1)(ref item)).boneIndex = boneIndex;
			((BoneWeight1)(ref item)).weight = weight;
			list.Add(item);
			count++;
		}
	}

	private void ApplyEquivalentVertexWeights(ClothInstance cloth, BoneWeight[] finalWeights)
	{
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
		if (cloth == null || cloth.equivalentVertices == null || cloth.equivalentVertices.Count == 0 || finalWeights == null || finalWeights.Length == 0)
		{
			return;
		}
		List<List<int>> equivalentVertices = cloth.equivalentVertices;
		int num = finalWeights.Length;
		bool[] array = new bool[num];
		foreach (List<int> item in equivalentVertices)
		{
			if (item == null || item.Count == 0)
			{
				continue;
			}
			List<int> list = null;
			bool flag = false;
			for (int i = 0; i < item.Count; i++)
			{
				int num2 = item[i];
				if (num2 >= 0 && num2 < num)
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(num2);
					if (!array[num2])
					{
						flag = true;
					}
				}
			}
			if (list == null || !flag)
			{
				continue;
			}
			Dictionary<int, float> weightMap = new Dictionary<int, float>();
			foreach (int item2 in list)
			{
				BoneWeight val = finalWeights[item2];
				Accumulate(((BoneWeight)(ref val)).boneIndex0, ((BoneWeight)(ref val)).weight0);
				Accumulate(((BoneWeight)(ref val)).boneIndex1, ((BoneWeight)(ref val)).weight1);
				Accumulate(((BoneWeight)(ref val)).boneIndex2, ((BoneWeight)(ref val)).weight2);
				Accumulate(((BoneWeight)(ref val)).boneIndex3, ((BoneWeight)(ref val)).weight3);
			}
			if (weightMap.Count == 0)
			{
				continue;
			}
			List<KeyValuePair<int, float>> list2 = weightMap.OrderByDescending((KeyValuePair<int, float> kv) => kv.Value).Take(4).ToList();
			float num3 = 0f;
			for (int num4 = 0; num4 < Math.Min(4, list2.Count); num4++)
			{
				num3 += list2[num4].Value;
			}
			if (num3 <= 1E-08f)
			{
				continue;
			}
			BoneWeight val2 = default(BoneWeight);
			for (int num5 = 0; num5 < Math.Min(4, list2.Count); num5++)
			{
				int key = list2[num5].Key;
				float num6 = list2[num5].Value / num3;
				switch (num5)
				{
				case 0:
					((BoneWeight)(ref val2)).boneIndex0 = key;
					((BoneWeight)(ref val2)).weight0 = num6;
					break;
				case 1:
					((BoneWeight)(ref val2)).boneIndex1 = key;
					((BoneWeight)(ref val2)).weight1 = num6;
					break;
				case 2:
					((BoneWeight)(ref val2)).boneIndex2 = key;
					((BoneWeight)(ref val2)).weight2 = num6;
					break;
				case 3:
					((BoneWeight)(ref val2)).boneIndex3 = key;
					((BoneWeight)(ref val2)).weight3 = num6;
					break;
				}
			}
			foreach (int item3 in list)
			{
				finalWeights[item3] = val2;
				array[item3] = true;
			}
			void Accumulate(int boneIndex, float w)
			{
				if (!(w <= 0f) && boneIndex >= 0)
				{
					if (weightMap.TryGetValue(boneIndex, out var value))
					{
						weightMap[boneIndex] = value + w;
					}
					else
					{
						weightMap[boneIndex] = w;
					}
				}
			}
		}
	}

	private void ApplyLegVertexConstraints(Animator avatarAnimator, ClothInstance cloth, float[,] weights, int bodyBoneCount, float tinyWeight)
	{
		if (cloth == null || (Object)(object)cloth.smr == (Object)null)
		{
			return;
		}
		bool[] isLeftLegVertex = cloth.isLeftLegVertex;
		bool[] isRightLegVertex = cloth.isRightLegVertex;
		if (isLeftLegVertex == null && isRightLegVertex == null)
		{
			return;
		}
		Transform[] bones = cloth.smr.bones;
		if (bones == null)
		{
			return;
		}
		int length = weights.GetLength(0);
		int length2 = weights.GetLength(1);
		Transform boneTransform = avatarAnimator.GetBoneTransform((HumanBodyBones)1);
		Transform boneTransform2 = avatarAnimator.GetBoneTransform((HumanBodyBones)2);
		bool[] array = new bool[length2];
		bool[] array2 = new bool[length2];
		int num = Mathf.Min(bodyBoneCount, bones.Length);
		for (int i = 0; i < num; i++)
		{
			Transform val = bones[i];
			if (!((Object)(object)val == (Object)null))
			{
				if (val.IsChildOf(boneTransform))
				{
					array[i] = true;
				}
				else if (val.IsChildOf(boneTransform2))
				{
					array2[i] = true;
				}
			}
		}
		for (int j = 0; j < length; j++)
		{
			bool flag = isLeftLegVertex != null && j < isLeftLegVertex.Length && isLeftLegVertex[j];
			bool flag2 = isRightLegVertex != null && j < isRightLegVertex.Length && isRightLegVertex[j];
			if (!flag && !flag2)
			{
				continue;
			}
			for (int k = 0; k < length2; k++)
			{
				if (weights[j, k] <= tinyWeight)
				{
					continue;
				}
				if (flag)
				{
					if (array2[k])
					{
						weights[j, k] = 0f;
					}
				}
				else if (flag2 && array[k])
				{
					weights[j, k] = 0f;
				}
			}
		}
	}

	private Vector3[] GetClothWorldNormals(ClothInstance cloth)
	{
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		if (cloth.worldVertices == null)
		{
			return null;
		}
		int num = cloth.worldVertices.Length;
		if ((Object)(object)cloth.bakedMesh == (Object)null || cloth.bakedMesh.vertexCount != num)
		{
			throw new AutoMorpherException("Cloth Baked Mesh is Invalid", "[WeightTransferUtil] GetClothWorldNormals\n - bakedMesh is null or vertexCount mismatch\n - bakedMesh.vertexCount : " + (((Object)(object)cloth.bakedMesh == (Object)null) ? (-1) : cloth.bakedMesh.vertexCount) + "\n - worldVertices.Length : " + num);
		}
		Vector3[] array = (Vector3[])(object)new Vector3[num];
		Mesh bakedMesh = cloth.bakedMesh;
		Vector3[] normals = bakedMesh.normals;
		if (normals == null || normals.Length != num)
		{
			bakedMesh.RecalculateNormals();
			normals = bakedMesh.normals;
		}
		for (int i = 0; i < num; i++)
		{
			Vector3 val = ((Matrix4x4)(ref cloth.worldNoScale)).MultiplyVector(normals[i]);
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			array[i] = normalized;
		}
		return array;
	}

	private void AccumulateBodyWeight(ref float[,] W, int vIndex, int localBoneIndex, float weight, Transform[] bodyBones, Dictionary<Transform, int> targetBoneIndexByTransform)
	{
		if (!(weight <= 0f) && bodyBones != null && localBoneIndex >= 0 && localBoneIndex < bodyBones.Length)
		{
			Transform val = bodyBones[localBoneIndex];
			if (!((Object)(object)val == (Object)null) && targetBoneIndexByTransform.TryGetValue(val, out var value))
			{
				W[vIndex, value] += weight;
			}
		}
	}

	private List<int>[] BuildAdjacencyFromTriangles(int vertexCount, int[] triangles)
	{
		List<int>[] array = new List<int>[vertexCount];
		for (int i = 0; i < vertexCount; i++)
		{
			array[i] = new List<int>();
		}
		int num = triangles.Length / 3;
		for (int j = 0; j < num; j++)
		{
			int num2 = triangles[j * 3];
			int num3 = triangles[j * 3 + 1];
			int num4 = triangles[j * 3 + 2];
			AddEdge(array, num2, num3);
			AddEdge(array, num3, num4);
			AddEdge(array, num4, num2);
		}
		return array;
	}

	private void AddEdge(List<int>[] adj, int a, int b)
	{
		if (!adj[a].Contains(b))
		{
			adj[a].Add(b);
		}
		if (!adj[b].Contains(a))
		{
			adj[b].Add(a);
		}
	}

	private float[,] FindMatchesClosestSurface(Vector3[] sourceVerts, int[] sourceTris, Vector3[] sourceNormals, Vector3[] targetVerts, Vector3[] targetNormals, float[,] sourceWeights, float distanceThresholdSqr, float angleThresholdDeg, bool flipVertexNormal, out bool[] matchedMask)
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0141: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_0148: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Unknown result type (might be due to invalid IL or missing references)
		//IL_015d: Unknown result type (might be due to invalid IL or missing references)
		//IL_016b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0172: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0202: Unknown result type (might be due to invalid IL or missing references)
		int num = targetVerts.Length;
		int length = sourceWeights.GetLength(1);
		float[,] array = new float[num, length];
		matchedMask = new bool[num];
		int num2 = sourceTris.Length / 3;
		float num3 = angleThresholdDeg * (MathF.PI / 180f);
		for (int i = 0; i < num; i++)
		{
			Vector3 val = targetVerts[i];
			float num4 = float.PositiveInfinity;
			int num5 = -1;
			Vector3 val2 = Vector3.zero;
			Vector3 val4;
			for (int j = 0; j < num2; j++)
			{
				int num6 = sourceTris[j * 3];
				int num7 = sourceTris[j * 3 + 1];
				int num8 = sourceTris[j * 3 + 2];
				Vector3 a = sourceVerts[num6];
				Vector3 b = sourceVerts[num7];
				Vector3 c = sourceVerts[num8];
				Vector3 bary;
				Vector3 val3 = ClosestPointOnTriangle(val, a, b, c, out bary);
				val4 = val - val3;
				float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
				if (sqrMagnitude < num4)
				{
					num4 = sqrMagnitude;
					num5 = j;
					val2 = bary;
				}
			}
			if (num5 < 0)
			{
				matchedMask[i] = false;
				continue;
			}
			bool num9 = num4 <= distanceThresholdSqr;
			int num10 = sourceTris[num5 * 3];
			int num11 = sourceTris[num5 * 3 + 1];
			int num12 = sourceTris[num5 * 3 + 2];
			Vector3 val5 = sourceNormals[num10];
			Vector3 val6 = sourceNormals[num11];
			Vector3 val7 = sourceNormals[num12];
			val4 = val5 * val2.x + val6 * val2.y + val7 * val2.z;
			Vector3 normalized = ((Vector3)(ref val4)).normalized;
			Vector3 normalized2 = ((Vector3)(ref targetNormals[i])).normalized;
			float num13 = Mathf.Acos(Mathf.Clamp(Vector3.Dot(normalized, normalized2), -1f, 1f));
			bool flag = num13 <= num3;
			if (flipVertexNormal && MathF.PI - num13 <= num3)
			{
				flag = true;
			}
			bool flag2 = num9 && flag;
			matchedMask[i] = flag2;
			for (int k = 0; k < length; k++)
			{
				float num14 = sourceWeights[num10, k];
				float num15 = sourceWeights[num11, k];
				float num16 = sourceWeights[num12, k];
				array[i, k] = num14 * val2.x + num15 * val2.y + num16 * val2.z;
			}
		}
		return array;
	}

	private Vector3 ClosestPointOnTriangle(Vector3 p, Vector3 a, Vector3 b, Vector3 c, out Vector3 bary)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0141: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0244: Unknown result type (might be due to invalid IL or missing references)
		//IL_0249: Unknown result type (might be due to invalid IL or missing references)
		//IL_024e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0251: Unknown result type (might be due to invalid IL or missing references)
		//IL_0256: Unknown result type (might be due to invalid IL or missing references)
		//IL_0259: Unknown result type (might be due to invalid IL or missing references)
		//IL_025e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0263: Unknown result type (might be due to invalid IL or missing references)
		//IL_0267: Unknown result type (might be due to invalid IL or missing references)
		//IL_026c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0186: Unknown result type (might be due to invalid IL or missing references)
		//IL_018b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0190: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0206: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = b - a;
		Vector3 val2 = c - a;
		Vector3 val3 = p - a;
		float num = Vector3.Dot(val, val3);
		float num2 = Vector3.Dot(val2, val3);
		if (num <= 0f && num2 <= 0f)
		{
			bary = new Vector3(1f, 0f, 0f);
			return a;
		}
		Vector3 val4 = p - b;
		float num3 = Vector3.Dot(val, val4);
		float num4 = Vector3.Dot(val2, val4);
		if (num3 >= 0f && num4 <= num3)
		{
			bary = new Vector3(0f, 1f, 0f);
			return b;
		}
		float num5 = num * num4 - num3 * num2;
		if (num5 <= 0f && num >= 0f && num3 <= 0f)
		{
			float num6 = num / (num - num3);
			bary = new Vector3(1f - num6, num6, 0f);
			return a + val * num6;
		}
		Vector3 val5 = p - c;
		float num7 = Vector3.Dot(val, val5);
		float num8 = Vector3.Dot(val2, val5);
		if (num8 >= 0f && num7 <= num8)
		{
			bary = new Vector3(0f, 0f, 1f);
			return c;
		}
		float num9 = num7 * num2 - num * num8;
		if (num9 <= 0f && num2 >= 0f && num8 <= 0f)
		{
			float num10 = num2 / (num2 - num8);
			bary = new Vector3(1f - num10, 0f, num10);
			return a + val2 * num10;
		}
		float num11 = num3 * num8 - num7 * num4;
		if (num11 <= 0f && num4 - num3 >= 0f && num7 - num8 >= 0f)
		{
			float num12 = (num4 - num3) / (num4 - num3 + (num7 - num8));
			bary = new Vector3(0f, 1f - num12, num12);
			return b + (c - b) * num12;
		}
		float num13 = 1f / (num11 + num9 + num5);
		float num14 = num9 * num13;
		float num15 = num5 * num13;
		float num16 = 1f - num14 - num15;
		bary = new Vector3(num16, num14, num15);
		return a * num16 + b * num14 + c * num15;
	}

	private void ZeroSmallWeights(float[,] weights, float tiny)
	{
		int length = weights.GetLength(0);
		int length2 = weights.GetLength(1);
		for (int i = 0; i < length; i++)
		{
			for (int j = 0; j < length2; j++)
			{
				if (weights[i, j] <= tiny)
				{
					weights[i, j] = 0f;
				}
			}
		}
	}

	private void EnforceMaxBonesPerVertex(float[,] weights, int maxBonesPerVertex, float tinyWeight)
	{
		int length = weights.GetLength(0);
		int length2 = weights.GetLength(1);
		for (int i = 0; i < length; i++)
		{
			List<(int, float)> list = new List<(int, float)>();
			for (int j = 0; j < length2; j++)
			{
				float num = weights[i, j];
				if (num > tinyWeight)
				{
					list.Add((j, num));
				}
			}
			list.Sort(((int bone, float w) a, (int bone, float w) b) => b.w.CompareTo(a.w));
			HashSet<int> hashSet = new HashSet<int>();
			int num2 = Mathf.Min(maxBonesPerVertex, list.Count);
			for (int num3 = 0; num3 < num2; num3++)
			{
				hashSet.Add(list[num3].Item1);
			}
			for (int num4 = 0; num4 < length2; num4++)
			{
				if (!hashSet.Contains(num4) || weights[i, num4] <= tinyWeight)
				{
					weights[i, num4] = 0f;
				}
			}
		}
	}

	private void NormalizeWeightsPerVertex(float[,] weights, float tiny)
	{
		int length = weights.GetLength(0);
		int length2 = weights.GetLength(1);
		for (int i = 0; i < length; i++)
		{
			float num = 0f;
			for (int j = 0; j < length2; j++)
			{
				num += weights[i, j];
			}
			if (!(num < tiny))
			{
				float num2 = 1f / num;
				for (int k = 0; k < length2; k++)
				{
					weights[i, k] *= num2;
				}
			}
		}
	}

	private BoneWeight[] CollapseWeightsToBoneWeights(float[,] weights, int maxBonesPerVert, float tiny)
	{
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0191: Unknown result type (might be due to invalid IL or missing references)
		//IL_0193: Unknown result type (might be due to invalid IL or missing references)
		int length = weights.GetLength(0);
		int length2 = weights.GetLength(1);
		BoneWeight[] array = (BoneWeight[])(object)new BoneWeight[length];
		for (int i = 0; i < length; i++)
		{
			List<(int, float)> list = new List<(int, float)>();
			for (int j = 0; j < length2; j++)
			{
				float num = weights[i, j];
				if (num > tiny)
				{
					list.Add((j, num));
				}
			}
			if (list.Count == 0)
			{
				array[i] = default(BoneWeight);
				continue;
			}
			list.Sort(((int idx, float w) a, (int idx, float w) b) => b.w.CompareTo(a.w));
			int num2 = Mathf.Min(maxBonesPerVert, list.Count);
			float num3 = 0f;
			for (int num4 = 0; num4 < num2; num4++)
			{
				num3 += list[num4].Item2;
			}
			if (num3 < tiny)
			{
				num3 = 1f;
			}
			float num5 = 1f / num3;
			BoneWeight val = default(BoneWeight);
			for (int num6 = 0; num6 < num2; num6++)
			{
				int item = list[num6].Item1;
				float num7 = list[num6].Item2 * num5;
				switch (num6)
				{
				case 0:
					((BoneWeight)(ref val)).boneIndex0 = item;
					((BoneWeight)(ref val)).weight0 = num7;
					break;
				case 1:
					((BoneWeight)(ref val)).boneIndex1 = item;
					((BoneWeight)(ref val)).weight1 = num7;
					break;
				case 2:
					((BoneWeight)(ref val)).boneIndex2 = item;
					((BoneWeight)(ref val)).weight2 = num7;
					break;
				case 3:
					((BoneWeight)(ref val)).boneIndex3 = item;
					((BoneWeight)(ref val)).weight3 = num7;
					break;
				}
			}
			array[i] = val;
		}
		return array;
	}

	private float[,] InpaintApprox(Vector3[] verts, int[] triangles, float[,] weights, bool[] matched, List<int>[] adjacency, int iterations, float alpha)
	{
		int num = verts.Length;
		int length = weights.GetLength(1);
		float[,] array = (float[,])weights.Clone();
		float[,] array2 = new float[num, length];
		for (int i = 0; i < iterations; i++)
		{
			for (int j = 0; j < num; j++)
			{
				if (matched[j])
				{
					for (int k = 0; k < length; k++)
					{
						array2[j, k] = array[j, k];
					}
					continue;
				}
				List<int> list = adjacency[j];
				if (list == null || list.Count == 0)
				{
					for (int l = 0; l < length; l++)
					{
						array2[j, l] = array[j, l];
					}
					continue;
				}
				for (int m = 0; m < length; m++)
				{
					float num2 = 0f;
					for (int n = 0; n < list.Count; n++)
					{
						int num3 = list[n];
						num2 += array[num3, m];
					}
					float num4 = num2 / (float)list.Count;
					array2[j, m] = Mathf.Lerp(array[j, m], num4, alpha);
				}
			}
			float[,] array3 = array2;
			float[,] array4 = array;
			array = array3;
			array2 = array4;
		}
		return array;
	}

	private float[,] SmoothWeightsApprox(Vector3[] verts, float[,] weights, bool[] matched, List<int>[] adjacency, int numSmoothIterSteps, float smoothAlpha, float distanceThreshold)
	{
		int num = verts.Length;
		int length = weights.GetLength(1);
		bool[] array = new bool[num];
		for (int i = 0; i < num; i++)
		{
			if (!matched[i])
			{
				FloodFillWithinDistance(verts, adjacency, i, distanceThreshold, array);
			}
		}
		float[,] array2 = (float[,])weights.Clone();
		float[,] array3 = new float[num, length];
		for (int j = 0; j < numSmoothIterSteps; j++)
		{
			for (int k = 0; k < num; k++)
			{
				if (!array[k])
				{
					for (int l = 0; l < length; l++)
					{
						array3[k, l] = array2[k, l];
					}
					continue;
				}
				List<int> list = adjacency[k];
				if (list == null || list.Count == 0)
				{
					for (int m = 0; m < length; m++)
					{
						array3[k, m] = array2[k, m];
					}
					continue;
				}
				for (int n = 0; n < length; n++)
				{
					float num2 = 0f;
					for (int num3 = 0; num3 < list.Count; num3++)
					{
						int num4 = list[num3];
						num2 += array2[num4, n];
					}
					float num5 = num2 / (float)list.Count;
					array3[k, n] = Mathf.Lerp(array2[k, n], num5, smoothAlpha);
				}
			}
			float[,] array4 = array3;
			float[,] array5 = array2;
			array2 = array4;
			array3 = array5;
		}
		return array2;
	}

	private void FloodFillWithinDistance(Vector3[] verts, List<int>[] adjacency, int startIndex, float maxDistance, bool[] visited)
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		Queue<int> queue = new Queue<int>();
		queue.Enqueue(startIndex);
		visited[startIndex] = true;
		while (queue.Count > 0)
		{
			int num = queue.Dequeue();
			foreach (int item in adjacency[num])
			{
				if (!visited[item])
				{
					Vector3 val = verts[startIndex] - verts[item];
					if (((Vector3)(ref val)).magnitude < maxDistance)
					{
						visited[item] = true;
						queue.Enqueue(item);
					}
				}
			}
		}
	}

	private BoneWeight[] MergeBodyAndAccessoryWeights(float[,] bodyWeights, float[,] accessoryWeights, int bodyBoneCount, float tiny, bool enforceFour)
	{
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_029a: Unknown result type (might be due to invalid IL or missing references)
		//IL_034e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0350: Unknown result type (might be due to invalid IL or missing references)
		int length = bodyWeights.GetLength(0);
		bodyWeights.GetLength(1);
		int length2 = accessoryWeights.GetLength(1);
		BoneWeight[] array = (BoneWeight[])(object)new BoneWeight[length];
		for (int i = 0; i < length; i++)
		{
			List<(int, float)> list = new List<(int, float)>();
			float num = 0f;
			for (int j = 0; j < length2; j++)
			{
				float num2 = accessoryWeights[i, j];
				if (num2 > tiny)
				{
					int item = bodyBoneCount + j;
					list.Add((item, num2));
					num += num2;
				}
			}
			List<(int, float)> list2 = new List<(int, float)>();
			float num3 = 0f;
			for (int k = 0; k < bodyBoneCount; k++)
			{
				float num4 = bodyWeights[i, k];
				if (num4 > tiny)
				{
					list2.Add((k, num4));
					num3 += num4;
				}
			}
			if (num3 > tiny && num < 1f - tiny)
			{
				float num5 = Mathf.Max(0f, 1f - num);
				float num6 = num5 / num3;
				for (int l = 0; l < list2.Count; l++)
				{
					list2[l] = (list2[l].Item1, list2[l].Item2 * num6);
				}
				num3 = num5;
			}
			else
			{
				for (int m = 0; m < list2.Count; m++)
				{
					list2[m] = (list2[m].Item1, 0f);
				}
				num3 = 0f;
			}
			List<(int, float)> list3 = new List<(int, float)>();
			list3.AddRange(list);
			list3.AddRange(list2);
			list3.RemoveAll(((int bone, float w) t) => t.w <= tiny);
			if (list3.Count == 0)
			{
				array[i] = default(BoneWeight);
				continue;
			}
			if (enforceFour && list3.Count > 4)
			{
				list3.Sort(delegate((int bone, float w) a, (int bone, float w) b)
				{
					bool flag = a.bone >= bodyBoneCount;
					bool flag2 = b.bone >= bodyBoneCount;
					return (flag != flag2) ? ((!flag) ? 1 : (-1)) : b.w.CompareTo(a.w);
				});
				list3 = list3.GetRange(0, 4);
			}
			float num7 = 0f;
			foreach (var item3 in list3)
			{
				num7 += item3.Item2;
			}
			if (num7 < tiny)
			{
				num7 = 1f;
			}
			float num8 = 1f / num7;
			BoneWeight val = default(BoneWeight);
			for (int num9 = 0; num9 < list3.Count && num9 < 4; num9++)
			{
				int item2 = list3[num9].Item1;
				float num10 = list3[num9].Item2 * num8;
				switch (num9)
				{
				case 0:
					((BoneWeight)(ref val)).boneIndex0 = item2;
					((BoneWeight)(ref val)).weight0 = num10;
					break;
				case 1:
					((BoneWeight)(ref val)).boneIndex1 = item2;
					((BoneWeight)(ref val)).weight1 = num10;
					break;
				case 2:
					((BoneWeight)(ref val)).boneIndex2 = item2;
					((BoneWeight)(ref val)).weight2 = num10;
					break;
				case 3:
					((BoneWeight)(ref val)).boneIndex3 = item2;
					((BoneWeight)(ref val)).weight3 = num10;
					break;
				}
			}
			array[i] = val;
		}
		return array;
	}

	private void EnsureNonZeroAndNormalizeFinalWeights(ClothInstance cloth, BoneWeight[] weights, List<int>[] adjacency, float tiny)
	{
		if (cloth != null && weights != null && weights.Length != 0)
		{
			PreNormalizeBoneWeightsInPlace(weights, tiny);
			FillZeroWeightsFromNeighbors(weights, adjacency, tiny);
			NormalizeAllBoneWeightsInPlace(weights, tiny);
		}
	}

	private void PreNormalizeBoneWeightsInPlace(BoneWeight[] weights, float tiny)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < weights.Length; i++)
		{
			BoneWeight val = weights[i];
			float num = Sum(in weights[i]);
			if (!(num < tiny))
			{
				float num2 = 1f / num;
				((BoneWeight)(ref val)).weight0 = ((BoneWeight)(ref val)).weight0 * num2;
				((BoneWeight)(ref val)).weight1 = ((BoneWeight)(ref val)).weight1 * num2;
				((BoneWeight)(ref val)).weight2 = ((BoneWeight)(ref val)).weight2 * num2;
				((BoneWeight)(ref val)).weight3 = ((BoneWeight)(ref val)).weight3 * num2;
				weights[i] = val;
			}
		}
	}

	private void FillZeroWeightsFromNeighbors(BoneWeight[] weights, List<int>[] adjacency, float tiny)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		int num = weights.Length;
		for (int i = 0; i < num; i++)
		{
			if (!(Sum(in weights[i]) >= tiny))
			{
				BoneWeight bw = AverageFromNeighbors(i, weights, adjacency, tiny, 1);
				if (Sum(in bw) >= tiny)
				{
					weights[i] = bw;
				}
			}
		}
		for (int j = 0; j < num; j++)
		{
			if (!(Sum(in weights[j]) >= tiny))
			{
				int num2 = FindNearestNonZeroVertexBfs(j, weights, adjacency, tiny, 8);
				if (num2 >= 0)
				{
					weights[j] = weights[num2];
					continue;
				}
				BoneWeight val = default(BoneWeight);
				((BoneWeight)(ref val)).boneIndex0 = 0;
				((BoneWeight)(ref val)).weight0 = 1f;
				weights[j] = val;
			}
		}
	}

	private BoneWeight AverageFromNeighbors(int v, BoneWeight[] weights, List<int>[] adjacency, float tiny, int maxRing)
	{
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		Dictionary<int, float> map = new Dictionary<int, float>();
		Queue<int> queue = new Queue<int>();
		Dictionary<int, int> dictionary = new Dictionary<int, int>();
		HashSet<int> hashSet = new HashSet<int>();
		queue.Enqueue(v);
		dictionary[v] = 0;
		hashSet.Add(v);
		while (queue.Count > 0)
		{
			int num = queue.Dequeue();
			int num2 = dictionary[num];
			if (num2 >= maxRing)
			{
				continue;
			}
			List<int> list = adjacency[num];
			if (list == null)
			{
				continue;
			}
			foreach (int item in list)
			{
				if (item >= 0 && item < weights.Length && hashSet.Add(item))
				{
					dictionary[item] = num2 + 1;
					queue.Enqueue(item);
					BoneWeight bw = weights[item];
					if (!(Sum(in bw) < tiny))
					{
						Acc(map, ((BoneWeight)(ref bw)).boneIndex0, ((BoneWeight)(ref bw)).weight0, tiny);
						Acc(map, ((BoneWeight)(ref bw)).boneIndex1, ((BoneWeight)(ref bw)).weight1, tiny);
						Acc(map, ((BoneWeight)(ref bw)).boneIndex2, ((BoneWeight)(ref bw)).weight2, tiny);
						Acc(map, ((BoneWeight)(ref bw)).boneIndex3, ((BoneWeight)(ref bw)).weight3, tiny);
					}
				}
			}
		}
		return BuildTop4Normalized(map, tiny);
	}

	private int FindNearestNonZeroVertexBfs(int start, BoneWeight[] weights, List<int>[] adjacency, float tiny, int maxDepth)
	{
		Queue<int> queue = new Queue<int>();
		Dictionary<int, int> dictionary = new Dictionary<int, int>();
		HashSet<int> hashSet = new HashSet<int>();
		queue.Enqueue(start);
		dictionary[start] = 0;
		hashSet.Add(start);
		while (queue.Count > 0)
		{
			int num = queue.Dequeue();
			int num2 = dictionary[num];
			if (num2 > 0 && Sum(in weights[num]) >= tiny)
			{
				return num;
			}
			if (num2 >= maxDepth)
			{
				continue;
			}
			List<int> list = adjacency[num];
			if (list == null)
			{
				continue;
			}
			foreach (int item in list)
			{
				if (item >= 0 && item < weights.Length && hashSet.Add(item))
				{
					dictionary[item] = num2 + 1;
					queue.Enqueue(item);
				}
			}
		}
		return -1;
	}

	private void NormalizeAllBoneWeightsInPlace(BoneWeight[] weights, float tiny)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < weights.Length; i++)
		{
			float num = Sum(in weights[i]);
			if (!(num < tiny))
			{
				float num2 = 1f / num;
				BoneWeight val = weights[i];
				((BoneWeight)(ref val)).weight0 = ((BoneWeight)(ref val)).weight0 * num2;
				((BoneWeight)(ref val)).weight1 = ((BoneWeight)(ref val)).weight1 * num2;
				((BoneWeight)(ref val)).weight2 = ((BoneWeight)(ref val)).weight2 * num2;
				((BoneWeight)(ref val)).weight3 = ((BoneWeight)(ref val)).weight3 * num2;
				weights[i] = val;
			}
		}
	}

	private float Sum(in BoneWeight bw)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		BoneWeight val = bw;
		float weight = ((BoneWeight)(ref val)).weight0;
		val = bw;
		float num = weight + ((BoneWeight)(ref val)).weight1;
		val = bw;
		float num2 = num + ((BoneWeight)(ref val)).weight2;
		val = bw;
		return num2 + ((BoneWeight)(ref val)).weight3;
	}

	private void Acc(Dictionary<int, float> map, int boneIndex, float w, float tiny)
	{
		if (boneIndex >= 0 && !(w <= tiny))
		{
			if (map.TryGetValue(boneIndex, out var value))
			{
				map[boneIndex] = value + w;
			}
			else
			{
				map[boneIndex] = w;
			}
		}
	}

	private BoneWeight BuildTop4Normalized(Dictionary<int, float> map, float tiny)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Unknown result type (might be due to invalid IL or missing references)
		if (map == null || map.Count == 0)
		{
			return default(BoneWeight);
		}
		List<KeyValuePair<int, float>> list = map.OrderByDescending((KeyValuePair<int, float> kv) => kv.Value).Take(4).ToList();
		float num = 0f;
		for (int num2 = 0; num2 < list.Count; num2++)
		{
			num += list[num2].Value;
		}
		if (num < tiny)
		{
			return default(BoneWeight);
		}
		float num3 = 1f / num;
		BoneWeight result = default(BoneWeight);
		for (int num4 = 0; num4 < list.Count; num4++)
		{
			int key = list[num4].Key;
			float num5 = list[num4].Value * num3;
			switch (num4)
			{
			case 0:
				((BoneWeight)(ref result)).boneIndex0 = key;
				((BoneWeight)(ref result)).weight0 = num5;
				break;
			case 1:
				((BoneWeight)(ref result)).boneIndex1 = key;
				((BoneWeight)(ref result)).weight1 = num5;
				break;
			case 2:
				((BoneWeight)(ref result)).boneIndex2 = key;
				((BoneWeight)(ref result)).weight2 = num5;
				break;
			case 3:
				((BoneWeight)(ref result)).boneIndex3 = key;
				((BoneWeight)(ref result)).weight3 = num5;
				break;
			}
		}
		return result;
	}
}