using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Jobs;
using UnityEngine;
using UnityEngine.Jobs;
using UnityEngine.Profiling;
using VRM.FastSpringBones.Blittables;
using VRM.FastSpringBones.Components;
using VRM.FastSpringBones.NativeWrappers;
using VRM.FastSpringBones.Registries;
using VRM.FastSpringBones.Schedulers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
}
namespace VRM.FastSpringBones.Schedulers
{
	public sealed class PullTransformJobScheduler : IDisposable
	{
		private struct Job : IJobParallelForTransform
		{
			[NativeDisableUnsafePtrRestriction]
			public unsafe BlittableTransform** TransformPointers;

			public unsafe void Execute(int index, TransformAccess transform)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				TransformPointers[index]->PullFrom(transform);
			}
		}

		private unsafe BlittableTransform** _transformPointers;

		private TransformAccessArray _transformAccessArray;

		private readonly CustomSampler _sampler = CustomSampler.Create("Schedule CopyFromTransformJob", false);

		private readonly TransformRegistry _transformRegistry;

		private bool _dirty = true;

		private IReadOnlyList<NativeTransform> Targets => _transformRegistry.PullTargets;

		public PullTransformJobScheduler(TransformRegistry transformRegistry)
		{
			_transformRegistry = transformRegistry;
			_transformRegistry.SubscribeOnValueChanged(OnTransformChanged);
		}

		private void OnTransformChanged()
		{
			_dirty = true;
		}

		public unsafe JobHandle Schedule(JobHandle dependOn = default(JobHandle))
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//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_0041: Unknown result type (might be due to invalid IL or missing references)
			if (Targets.Count == 0)
			{
				return dependOn;
			}
			if (_dirty)
			{
				ReconstructBuffers();
				_dirty = false;
			}
			Job job = default(Job);
			job.TransformPointers = _transformPointers;
			return IJobParallelForTransformExtensions.Schedule<Job>(job, _transformAccessArray, dependOn);
		}

		private unsafe void ReconstructBuffers()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			ReleaseBuffers();
			IReadOnlyList<NativeTransform> targets = Targets;
			_transformPointers = (BlittableTransform**)UnsafeUtility.Malloc((long)(sizeof(BlittableTransform*) * targets.Count), 16, (Allocator)4);
			_transformAccessArray = new TransformAccessArray(targets.Count, -1);
			for (int i = 0; i < targets.Count; i++)
			{
				_transformPointers[i] = targets[i].GetUnsafePtr();
				((TransformAccessArray)(ref _transformAccessArray)).Add(targets[i].Transform);
			}
		}

		public void Dispose()
		{
			ReleaseBuffers();
			_transformRegistry.UnSubscribeOnValueChanged(OnTransformChanged);
		}

		private unsafe void ReleaseBuffers()
		{
			if (((TransformAccessArray)(ref _transformAccessArray)).isCreated)
			{
				((TransformAccessArray)(ref _transformAccessArray)).Dispose();
			}
			if (_transformPointers != null)
			{
				UnsafeUtility.Free((void*)_transformPointers, (Allocator)4);
				_transformPointers = null;
			}
		}
	}
	public sealed class PushTransformJobScheduler : IDisposable
	{
		private struct Job : IJobParallelForTransform
		{
			[NativeDisableUnsafePtrRestriction]
			public unsafe BlittableTransform** TransformPointers;

			public unsafe void Execute(int index, TransformAccess transform)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				TransformPointers[index]->PushTo(transform);
			}
		}

		private unsafe BlittableTransform** _transformPointers;

		private TransformAccessArray _transformAccessArray;

		private readonly CustomSampler _sampler = CustomSampler.Create("Schedule CopyFromTransformJob", false);

		private readonly TransformRegistry _transformRegistry;

		private bool _dirty = true;

		private IReadOnlyList<NativeTransform> Targets => _transformRegistry.PushTargets;

		public PushTransformJobScheduler(TransformRegistry transformRegistry)
		{
			_transformRegistry = transformRegistry;
			_transformRegistry.SubscribeOnValueChanged(OnTransformChanged);
		}

		private void OnTransformChanged()
		{
			_dirty = true;
		}

		public unsafe JobHandle Schedule(JobHandle dependOn = default(JobHandle))
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//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_0041: Unknown result type (might be due to invalid IL or missing references)
			if (Targets.Count == 0)
			{
				return dependOn;
			}
			if (_dirty)
			{
				ReconstructBuffers();
				_dirty = false;
			}
			Job job = default(Job);
			job.TransformPointers = _transformPointers;
			return IJobParallelForTransformExtensions.Schedule<Job>(job, _transformAccessArray, dependOn);
		}

		private unsafe void ReconstructBuffers()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			ReleaseBuffers();
			IReadOnlyList<NativeTransform> targets = Targets;
			_transformPointers = (BlittableTransform**)UnsafeUtility.Malloc((long)(sizeof(BlittableTransform*) * targets.Count), 16, (Allocator)4);
			_transformAccessArray = new TransformAccessArray(targets.Count, -1);
			for (int i = 0; i < targets.Count; i++)
			{
				_transformPointers[i] = targets[i].GetUnsafePtr();
				((TransformAccessArray)(ref _transformAccessArray)).Add(targets[i].Transform);
			}
		}

		public void Dispose()
		{
			ReleaseBuffers();
			_transformRegistry.UnSubscribeOnValueChanged(OnTransformChanged);
		}

		private unsafe void ReleaseBuffers()
		{
			if (((TransformAccessArray)(ref _transformAccessArray)).isCreated)
			{
				((TransformAccessArray)(ref _transformAccessArray)).Dispose();
			}
			if (_transformPointers != null)
			{
				UnsafeUtility.Free((void*)_transformPointers, (Allocator)4);
				_transformPointers = null;
			}
		}
	}
	public sealed class UpdateSpringBoneJobScheduler : IDisposable
	{
		private struct Job : IJobParallelFor
		{
			[NativeDisableUnsafePtrRestriction]
			public unsafe BlittableRootBone** RootBonePointers;

			public float DeltaTime;

			public unsafe void Execute(int index)
			{
				RootBonePointers[index]->Update(DeltaTime);
			}
		}

		private unsafe BlittableRootBone** _rootBonePointers;

		private readonly RootBoneRegistry _rootBoneRegistry;

		private readonly CustomSampler _sampler = CustomSampler.Create("Schedule CopyFromTransformJob", false);

		private bool _dirty = true;

		private IReadOnlyList<NativePointer<BlittableRootBone>> Targets => _rootBoneRegistry.Items;

		public UpdateSpringBoneJobScheduler(RootBoneRegistry rootBoneRegistry)
		{
			_rootBoneRegistry = rootBoneRegistry;
			_rootBoneRegistry.SubscribeOnValueChanged(OnRootBoneChanged);
		}

		public void Dispose()
		{
			ReleaseBuffer();
			_rootBoneRegistry.UnSubscribeOnValueChanged(OnRootBoneChanged);
		}

		private void OnRootBoneChanged()
		{
			_dirty = true;
		}

		public unsafe JobHandle Schedule(JobHandle dependOn = default(JobHandle))
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (Targets.Count == 0)
			{
				return dependOn;
			}
			if (_dirty)
			{
				ReconstructBuffers();
				_dirty = false;
			}
			Job job = default(Job);
			job.RootBonePointers = _rootBonePointers;
			job.DeltaTime = Time.deltaTime;
			return IJobParallelForExtensions.Schedule<Job>(job, Targets.Count, 0, dependOn);
		}

		private unsafe void ReconstructBuffers()
		{
			ReleaseBuffer();
			_rootBonePointers = (BlittableRootBone**)UnsafeUtility.Malloc((long)(sizeof(BlittableTransform*) * Targets.Count), 16, (Allocator)4);
			for (int i = 0; i < Targets.Count; i++)
			{
				_rootBonePointers[i] = Targets[i].GetUnsafePtr();
			}
		}

		private unsafe void ReleaseBuffer()
		{
			if (_rootBonePointers != null)
			{
				UnsafeUtility.Free((void*)_rootBonePointers, (Allocator)4);
				_rootBonePointers = null;
			}
		}
	}
}
namespace VRM.FastSpringBones.Registries
{
	public sealed class ColliderGroupRegistry : Registry<NativeColliderGroups>
	{
	}
	public class Registry<T>
	{
		private readonly List<T> _items = new List<T>();

		private Action _onValueChanged;

		public IReadOnlyList<T> Items => _items;

		public void Register(T value)
		{
			_items.Add(value);
			_onValueChanged?.Invoke();
		}

		public void Unregister(T value)
		{
			_items.Remove(value);
			_onValueChanged?.Invoke();
		}

		public void SubscribeOnValueChanged(Action action)
		{
			_onValueChanged = (Action)Delegate.Combine(_onValueChanged, action);
		}

		public void UnSubscribeOnValueChanged(Action action)
		{
			_onValueChanged = (Action)Delegate.Remove(_onValueChanged, action);
		}
	}
	public sealed class RootBoneRegistry : Registry<NativePointer<BlittableRootBone>>
	{
	}
	public sealed class TransformRegistry
	{
		private readonly List<NativeTransform> _transforms = new List<NativeTransform>();

		private readonly List<NativeTransform> _pullTargets = new List<NativeTransform>();

		private readonly List<NativeTransform> _pushTargets = new List<NativeTransform>();

		private Action _onValueChanged;

		public IReadOnlyList<NativeTransform> Transforms => _transforms;

		public IReadOnlyList<NativeTransform> PullTargets => _pullTargets;

		public IReadOnlyList<NativeTransform> PushTargets => _pushTargets;

		public void SubscribeOnValueChanged(Action action)
		{
			_onValueChanged = (Action)Delegate.Combine(_onValueChanged, action);
		}

		public void UnSubscribeOnValueChanged(Action action)
		{
			_onValueChanged = (Action)Delegate.Remove(_onValueChanged, action);
		}

		public void Register(NativeTransform nativeTransform, TransformSynchronizationType synchronizationType)
		{
			_transforms.Add(nativeTransform);
			switch (synchronizationType)
			{
			case TransformSynchronizationType.PullOnly:
				_pullTargets.Add(nativeTransform);
				break;
			case TransformSynchronizationType.PushOnly:
				_pushTargets.Add(nativeTransform);
				break;
			default:
				throw new ArgumentOutOfRangeException("synchronizationType", synchronizationType, null);
			}
			_onValueChanged?.Invoke();
		}

		public void Unregister(NativeTransform nativeTransform)
		{
			_transforms.Remove(nativeTransform);
			if (_pullTargets.Contains(nativeTransform))
			{
				_pullTargets.Remove(nativeTransform);
			}
			if (_pushTargets.Contains(nativeTransform))
			{
				_pushTargets.Remove(nativeTransform);
			}
			_onValueChanged?.Invoke();
		}
	}
	public enum TransformSynchronizationType
	{
		PullOnly,
		PushOnly
	}
}
namespace VRM.FastSpringBones.NativeWrappers
{
	public sealed class NativeColliderGroup : IDisposable
	{
		private readonly NativePointer<BlittableColliderGroup> _nativePointer;

		private NativeArray<BlittableCollider> Colliders { get; }

		public unsafe BlittableColliderGroup* GetUnsafePtr()
		{
			return _nativePointer.GetUnsafePtr();
		}

		public unsafe NativeColliderGroup(BlittableCollider[] colliders, NativeTransform nativeTransform)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Colliders = new NativeArray<BlittableCollider>(colliders, (Allocator)4);
			_nativePointer = new NativePointer<BlittableColliderGroup>(new BlittableColliderGroup(Colliders, nativeTransform.GetUnsafePtr()));
		}

		public void Dispose()
		{
			//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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (Colliders.IsCreated)
			{
				Colliders.Dispose();
			}
			_nativePointer.Dispose();
		}
	}
	public sealed class NativeColliderGroups : IDisposable
	{
		private readonly NativePointer<BlittableColliderGroups> _nativePointer = new NativePointer<BlittableColliderGroups>();

		private NativeArray<BlittableColliderGroup> _colliderGroupArray;

		private IReadOnlyList<FastSpringBoneColliderGroup> _colliderGroups;

		private bool _isDisposed;

		public IReadOnlyList<FastSpringBoneColliderGroup> ColliderGroups
		{
			get
			{
				return _colliderGroups;
			}
			set
			{
				_colliderGroups = value;
				UpdateColliderGroups();
			}
		}

		public unsafe BlittableColliderGroups* GetUnsafePtr()
		{
			return _nativePointer.GetUnsafePtr();
		}

		public void DrawGizmos()
		{
			_nativePointer.Value.DrawGizmos();
		}

		private void UpdateColliderGroups()
		{
			if (!_isDisposed)
			{
				if (_colliderGroupArray.IsCreated)
				{
					_colliderGroupArray.Dispose();
				}
				CreateColliderGroupArray(_colliderGroups);
				UpdateData();
			}
		}

		public NativeColliderGroups(IReadOnlyList<FastSpringBoneColliderGroup> colliderGroups)
		{
			_colliderGroups = colliderGroups;
			UpdateColliderGroups();
		}

		public void Dispose()
		{
			if (_colliderGroupArray.IsCreated)
			{
				_colliderGroupArray.Dispose();
				_isDisposed = true;
			}
			_nativePointer.Dispose();
		}

		private unsafe void CreateColliderGroupArray(IReadOnlyList<FastSpringBoneColliderGroup> colliderGroups)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			_colliderGroupArray = new NativeArray<BlittableColliderGroup>(colliderGroups.Count, (Allocator)4, (NativeArrayOptions)1);
			for (int i = 0; i < _colliderGroupArray.Length; i++)
			{
				_colliderGroupArray[i] = *colliderGroups[i].ColliderGroupPtr;
			}
		}

		private unsafe void UpdateData()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			_nativePointer.Value = new BlittableColliderGroups((BlittableColliderGroup*)NativeArrayUnsafeUtility.GetUnsafePtr<BlittableColliderGroup>(_colliderGroupArray), _colliderGroupArray.Length);
		}
	}
	public sealed class NativePointer<T> : IDisposable where T : unmanaged
	{
		private unsafe readonly T* _unsafePtr;

		public unsafe T Value
		{
			get
			{
				return *_unsafePtr;
			}
			set
			{
				*_unsafePtr = value;
			}
		}

		public unsafe T* GetUnsafePtr()
		{
			return _unsafePtr;
		}

		public unsafe NativePointer()
		{
			_unsafePtr = (T*)UnsafeUtility.Malloc((long)sizeof(T), 16, (Allocator)4);
		}

		public unsafe NativePointer(T value)
		{
			_unsafePtr = (T*)UnsafeUtility.Malloc((long)sizeof(T), 16, (Allocator)4);
			Value = value;
		}

		public unsafe void Dispose()
		{
			UnsafeUtility.Free((void*)_unsafePtr, (Allocator)4);
		}
	}
	public sealed class NativePoints : IDisposable
	{
		private readonly NativePointer<BlittablePoints> _nativePointer;

		private NativeArray<BlittablePoint> _buffer;

		public unsafe BlittablePoints* GetUnsafePtr()
		{
			return _nativePointer.GetUnsafePtr();
		}

		public unsafe NativePoints(IList<NativePointer<BlittablePoint>> points)
		{
			//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_0049: Unknown result type (might be due to invalid IL or missing references)
			_buffer = new NativeArray<BlittablePoint>(points.Count, (Allocator)4, (NativeArrayOptions)1);
			for (int i = 0; i < _buffer.Length; i++)
			{
				_buffer[i] = points[i].Value;
			}
			_nativePointer = new NativePointer<BlittablePoints>(new BlittablePoints((BlittablePoint*)NativeArrayUnsafeUtility.GetUnsafePtr<BlittablePoint>(_buffer), _buffer.Length));
		}

		public void Dispose()
		{
			if (_buffer.IsCreated)
			{
				_buffer.Dispose();
			}
			_nativePointer.Dispose();
		}
	}
	public sealed class NativeTransform : IDisposable
	{
		private readonly NativePointer<BlittableTransform> _nativePointer;

		private readonly TransformRegistry _transformRegistry;

		public Transform Transform { get; }

		public BlittableTransform Value => _nativePointer.Value;

		public unsafe BlittableTransform* GetUnsafePtr()
		{
			return _nativePointer.GetUnsafePtr();
		}

		public unsafe NativeTransform(TransformRegistry transformRegistry, TransformSynchronizationType transformSynchronizationType, Transform transform, NativeTransform parent = null)
		{
			_nativePointer = new NativePointer<BlittableTransform>(new BlittableTransform((parent != null) ? parent.GetUnsafePtr() : null, transform));
			Transform = transform;
			_transformRegistry = transformRegistry;
			_transformRegistry.Register(this, transformSynchronizationType);
		}

		public void Dispose()
		{
			_transformRegistry.Unregister(this);
			_nativePointer.Dispose();
		}
	}
}
namespace VRM.FastSpringBones.Components
{
	public sealed class FastSpringBoneColliderGroup : MonoBehaviour
	{
		private NativeTransform _nativeTransform;

		private NativeColliderGroup _nativeColliderGroup;

		public unsafe BlittableColliderGroup* ColliderGroupPtr => _nativeColliderGroup.GetUnsafePtr();

		public void Initialize(TransformRegistry transformRegistry, BlittableCollider[] colliders)
		{
			_nativeTransform = new NativeTransform(transformRegistry, TransformSynchronizationType.PullOnly, ((Component)this).transform);
			_nativeColliderGroup = new NativeColliderGroup(colliders, _nativeTransform);
		}

		private void OnDestroy()
		{
			_nativeTransform?.Dispose();
			_nativeColliderGroup?.Dispose();
		}
	}
	[DefaultExecutionOrder(11000)]
	public sealed class FastSpringBoneScheduler : MonoBehaviour
	{
		[SerializeField]
		private bool showGizmos;

		private CustomSampler _updateSampler;

		private PullTransformJobScheduler _pullTransformJobScheduler;

		private PushTransformJobScheduler _pushTransformJobScheduler;

		private UpdateSpringBoneJobScheduler _updateSpringBoneJobScheduler;

		private RootBoneRegistry _rootBoneRegistry;

		private ColliderGroupRegistry _colliderGroupRegistry;

		private JobHandle _prevJobHandle;

		public bool ShowGizmos
		{
			get
			{
				return showGizmos;
			}
			set
			{
				showGizmos = value;
			}
		}

		public void Initialize(RootBoneRegistry rootBoneRegistry, TransformRegistry transformRegistry, ColliderGroupRegistry colliderGroupRegistry)
		{
			_rootBoneRegistry = rootBoneRegistry;
			_colliderGroupRegistry = colliderGroupRegistry;
			_updateSampler = CustomSampler.Create("FastSpringBone(Update)", false);
			_pullTransformJobScheduler = new PullTransformJobScheduler(transformRegistry);
			_pushTransformJobScheduler = new PushTransformJobScheduler(transformRegistry);
			_updateSpringBoneJobScheduler = new UpdateSpringBoneJobScheduler(_rootBoneRegistry);
			_rootBoneRegistry.SubscribeOnValueChanged(OnRootBoneChanged);
		}

		private void OnDestroy()
		{
			_rootBoneRegistry.UnSubscribeOnValueChanged(OnRootBoneChanged);
			((JobHandle)(ref _prevJobHandle)).Complete();
			_pullTransformJobScheduler.Dispose();
			_pushTransformJobScheduler.Dispose();
			_updateSpringBoneJobScheduler.Dispose();
		}

		private void OnRootBoneChanged()
		{
			((JobHandle)(ref _prevJobHandle)).Complete();
		}

		private void LateUpdate()
		{
			//IL_000d: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			((JobHandle)(ref _prevJobHandle)).Complete();
			JobHandle dependOn = _pullTransformJobScheduler.Schedule();
			dependOn = _updateSpringBoneJobScheduler.Schedule(dependOn);
			dependOn = _pushTransformJobScheduler.Schedule(dependOn);
			_prevJobHandle = dependOn;
		}
	}
	public sealed class FastSpringRootBone : IDisposable
	{
		private readonly TransformRegistry _transformRegistry;

		private readonly RootBoneRegistry _rootBoneRegistry;

		private readonly ColliderGroupRegistry _colliderGroupRegistry;

		private readonly Transform _transform;

		private float _radius;

		private NativeTransform _center;

		private IReadOnlyDictionary<Transform, int> _transformIndexMap;

		private NativeColliderGroups _nativeColliderGroups;

		private NativePoints _nativePoints;

		private NativePointer<BlittableRootBone> _rootBoneWrapper;

		private readonly IList<NativeTransform> _transformWrappers = new List<NativeTransform>();

		private readonly IList<NativePointer<BlittablePoint>> _points = new List<NativePointer<BlittablePoint>>();

		public IReadOnlyList<FastSpringBoneColliderGroup> ColliderGroups
		{
			get
			{
				return _nativeColliderGroups.ColliderGroups;
			}
			set
			{
				_nativeColliderGroups.ColliderGroups = value;
			}
		}

		public FastSpringRootBone(TransformRegistry transformRegistry, Transform transform, RootBoneRegistry rootBoneRegistry, ColliderGroupRegistry colliderGroupRegistry)
		{
			_transformRegistry = transformRegistry;
			_transform = transform;
			_rootBoneRegistry = rootBoneRegistry;
			_colliderGroupRegistry = colliderGroupRegistry;
		}

		public unsafe void Initialize(float gravityPower, Vector3 gravityDir, float dragForce, float stiffnessForce, IReadOnlyList<FastSpringBoneColliderGroup> colliderGroups, float radius, Transform center)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			_radius = radius;
			if ((Object)(object)center != (Object)null)
			{
				_center = new NativeTransform(_transformRegistry, TransformSynchronizationType.PullOnly, center);
			}
			_nativeColliderGroups = new NativeColliderGroups(colliderGroups);
			NativeTransform parent = null;
			if (Object.op_Implicit((Object)(object)_transform.parent))
			{
				parent = new NativeTransform(_transformRegistry, TransformSynchronizationType.PullOnly, _transform.parent);
			}
			SetupRecursive(_transform, parent);
			_nativePoints = new NativePoints(_points);
			_rootBoneWrapper = new NativePointer<BlittableRootBone>(new BlittableRootBone(gravityPower, gravityDir, dragForce, stiffnessForce, _nativePoints.GetUnsafePtr()));
			_rootBoneRegistry.Register(_rootBoneWrapper);
			_colliderGroupRegistry.Register(_nativeColliderGroups);
		}

		public void Dispose()
		{
			_colliderGroupRegistry.Unregister(_nativeColliderGroups);
			_rootBoneRegistry.Unregister(_rootBoneWrapper);
			foreach (NativeTransform transformWrapper in _transformWrappers)
			{
				transformWrapper.Dispose();
			}
			foreach (NativePointer<BlittablePoint> point in _points)
			{
				point.Dispose();
			}
			_center?.Dispose();
			_nativeColliderGroups?.Dispose();
			_nativePoints.Dispose();
			_rootBoneWrapper.Dispose();
		}

		private unsafe void SetupRecursive(Transform trs, NativeTransform parent = null)
		{
			NativeTransform nativeTransform = new NativeTransform(_transformRegistry, TransformSynchronizationType.PushOnly, trs, parent);
			_transformWrappers.Add(nativeTransform);
			NativePointer<BlittablePoint> item = new NativePointer<BlittablePoint>(new BlittablePoint(trs, _radius, (_center != null) ? _center.GetUnsafePtr() : null, _nativeColliderGroups.GetUnsafePtr(), nativeTransform.GetUnsafePtr()));
			_points.Add(item);
			for (int i = 0; i < trs.childCount; i++)
			{
				SetupRecursive(trs.GetChild(i), nativeTransform);
			}
		}
	}
}
namespace VRM.FastSpringBones.Blittables
{
	public readonly struct BlittableCollider
	{
		public Vector3 Offset { get; }

		public float Radius { get; }

		public BlittableCollider(Vector3 offset, float radius)
		{
			//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)
			Offset = offset;
			Radius = radius;
		}
	}
	public readonly struct BlittableColliderGroup
	{
		public BlittableColliders Colliders { get; }

		public unsafe BlittableTransform* Transform { get; }

		public unsafe BlittableColliderGroup(NativeArray<BlittableCollider> colliders, BlittableTransform* transform)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Colliders = new BlittableColliders((BlittableCollider*)NativeArrayUnsafeUtility.GetUnsafePtr<BlittableCollider>(colliders), colliders.Length);
			Transform = transform;
		}
	}
	public readonly struct BlittableColliderGroups
	{
		private unsafe readonly BlittableColliderGroup* _data;

		public int Length { get; }

		public unsafe BlittableColliderGroup this[int i] => _data[i];

		public unsafe void DrawGizmos()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < Length; i++)
			{
				BlittableColliderGroup blittableColliderGroup = this[i];
				BlittableColliders colliders = blittableColliderGroup.Colliders;
				for (int j = 0; j < colliders.Count; j++)
				{
					Gizmos.DrawWireSphere(blittableColliderGroup.Transform->WorldPosition, colliders[j].Radius);
				}
			}
		}

		public unsafe BlittableColliderGroups(BlittableColliderGroup* data, int length)
		{
			_data = data;
			Length = length;
		}
	}
	public struct BlittableColliders
	{
		private unsafe readonly BlittableCollider* _colliders;

		public int Count { get; }

		public unsafe BlittableCollider this[int i] => _colliders[i];

		public unsafe BlittableColliders(BlittableCollider* colliders, int count)
		{
			_colliders = colliders;
			Count = count;
		}
	}
	public struct BlittablePoint
	{
		private readonly float _length;

		private readonly Quaternion _localRotation;

		private readonly Vector3 _boneAxis;

		private readonly float _radius;

		private Vector3 _prevPosition;

		private unsafe readonly BlittableColliderGroups* _blittableColliderGroups;

		private unsafe readonly BlittableTransform* _center;

		private unsafe readonly BlittableTransform* _transform;

		public Vector3 CurrentPosition { get; private set; }

		public unsafe BlittablePoint(Transform transform, float radius, BlittableTransform* center, BlittableColliderGroups* blittableColliderGroups, BlittableTransform* blittableTransform)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_0009: 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_0019: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0046: 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)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_00a9: 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_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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)
			Matrix4x4 val3;
			Vector3 val4;
			if (transform.childCount == 0)
			{
				Vector3 val = transform.position - transform.parent.position;
				Vector3 val2 = transform.position + ((Vector3)(ref val)).normalized * 0.07f;
				val3 = transform.worldToLocalMatrix;
				val4 = ((Matrix4x4)(ref val3)).MultiplyPoint(val2);
			}
			else
			{
				Transform child = transform.GetChild(0);
				Vector3 lossyScale = child.lossyScale;
				val4 = child.localPosition;
				val4.x *= lossyScale.x;
				val4.y *= lossyScale.y;
				val4.z *= lossyScale.z;
			}
			Vector3 val5 = transform.TransformPoint(val4);
			Vector3 val6;
			if (center == null)
			{
				val6 = val5;
			}
			else
			{
				val3 = center->LocalToWorld;
				val3 = ((Matrix4x4)(ref val3)).inverse;
				val6 = ((Matrix4x4)(ref val3)).MultiplyPoint3x4(val5);
			}
			Vector3 prevPosition = val6;
			CurrentPosition = val6;
			_prevPosition = prevPosition;
			_localRotation = transform.localRotation;
			_boneAxis = ((Vector3)(ref val4)).normalized;
			_length = ((Vector3)(ref val4)).magnitude;
			_radius = radius;
			_blittableColliderGroups = blittableColliderGroups;
			_transform = blittableTransform;
			_center = center;
		}

		public unsafe void Update(float stiffnessForce, float dragForce, Vector3 external)
		{
			//IL_002b: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_005d: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_0094: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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_00a7: 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_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)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: 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_00ff: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: 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)
			_transform->UpdateLocalToWorldMatrix();
			Vector3 val;
			Vector3 val2;
			if (_center == null)
			{
				val = CurrentPosition;
				val2 = _prevPosition;
			}
			else
			{
				Matrix4x4 localToWorld = _center->LocalToWorld;
				val = ((Matrix4x4)(ref localToWorld)).MultiplyPoint3x4(CurrentPosition);
				val2 = ((Matrix4x4)(ref localToWorld)).MultiplyPoint3x4(_prevPosition);
			}
			Vector3 val3 = val + (val - val2) * (1f - dragForce) + _transform->ParentWorldRotation * _localRotation * _boneAxis * stiffnessForce + external;
			Vector3 worldPosition = _transform->WorldPosition;
			Vector3 val4 = val3 - worldPosition;
			val3 = worldPosition + ((Vector3)(ref val4)).normalized * _length;
			val3 = Collision(val3, worldPosition);
			if (_center == null)
			{
				_prevPosition = val;
				CurrentPosition = val3;
			}
			else
			{
				Matrix4x4 localToWorld2 = _center->LocalToWorld;
				Matrix4x4 inverse = ((Matrix4x4)(ref localToWorld2)).inverse;
				_prevPosition = ((Matrix4x4)(ref inverse)).MultiplyPoint3x4(val);
				CurrentPosition = ((Matrix4x4)(ref inverse)).MultiplyPoint3x4(val3);
			}
			_transform->SetWorldRotation(ApplyRotation(val3));
		}

		private unsafe Vector3 Collision(Vector3 nextPosition, Vector3 position)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_006a: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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_0094: 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_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00a4: 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_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_00bd: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _blittableColliderGroups->Length; i++)
			{
				BlittableColliderGroup blittableColliderGroup = (*_blittableColliderGroups)[i];
				for (int j = 0; j < blittableColliderGroup.Colliders.Count; j++)
				{
					BlittableCollider blittableCollider = blittableColliderGroup.Colliders[j];
					Vector3 val = blittableColliderGroup.Transform->TransformPoint(blittableCollider.Offset);
					float num = _radius + blittableCollider.Radius;
					Vector3 val2 = nextPosition - val;
					if (((Vector3)(ref val2)).sqrMagnitude <= num * num)
					{
						val2 = nextPosition - val;
						Vector3 normalized = ((Vector3)(ref val2)).normalized;
						Vector3 val3 = val + normalized * (_radius + blittableCollider.Radius);
						val2 = val3 - position;
						nextPosition = position + ((Vector3)(ref val2)).normalized * _length;
					}
				}
			}
			return nextPosition;
		}

		private static Quaternion FromToRotation(Vector3 from, Vector3 to)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Acos(Mathf.Clamp(Vector3.Dot(((Vector3)(ref from)).normalized, ((Vector3)(ref to)).normalized), -1f, 1f)) * 57.29578f;
			Vector3 val = Vector3.Cross(from, to);
			return Quaternion.AngleAxis(num, ((Vector3)(ref val)).normalized);
		}

		private unsafe Quaternion ApplyRotation(Vector3 nextTail)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = _transform->ParentWorldRotation * _localRotation;
			return FromToRotation(val * _boneAxis, nextTail - _transform->WorldPosition) * val;
		}
	}
	public struct BlittablePoints
	{
		private unsafe readonly BlittablePoint* _points;

		public int Count { get; }

		public unsafe BlittablePoint this[int i]
		{
			get
			{
				return _points[i];
			}
			set
			{
				Unsafe.Write(_points + i, value);
			}
		}

		public unsafe BlittablePoints(BlittablePoint* points, int count)
		{
			_points = points;
			Count = count;
		}
	}
	public readonly struct BlittableRootBone
	{
		private readonly float _gravityPower;

		private readonly Vector3 _gravityDir;

		private readonly float _dragForce;

		private readonly float _stiffnessForce;

		private unsafe readonly BlittablePoints* _blittablePoints;

		public unsafe void DrawGizmos()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < _blittablePoints->Count; i++)
			{
				Gizmos.DrawWireSphere((*_blittablePoints)[i].CurrentPosition, 0.05f);
			}
			for (int j = 0; j < _blittablePoints->Count - 1; j++)
			{
				BlittablePoint blittablePoint = (*_blittablePoints)[j];
				BlittablePoint blittablePoint2 = (*_blittablePoints)[j + 1];
				Gizmos.DrawLine(blittablePoint.CurrentPosition, blittablePoint2.CurrentPosition);
			}
		}

		public unsafe BlittableRootBone(float gravityPower, Vector3 gravityDir, float dragForce, float stiffnessForce, BlittablePoints* blittablePoints)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			_gravityPower = gravityPower;
			_gravityDir = gravityDir;
			_dragForce = dragForce;
			_stiffnessForce = stiffnessForce;
			_blittablePoints = blittablePoints;
		}

		public unsafe void Update(float deltaTime)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			float stiffnessForce = _stiffnessForce * deltaTime;
			Vector3 external = _gravityDir * (_gravityPower * deltaTime);
			for (int i = 0; i < _blittablePoints->Count; i++)
			{
				BlittablePoint value = (*_blittablePoints)[i];
				value.Update(stiffnessForce, _dragForce, external);
				(*_blittablePoints)[i] = value;
			}
		}
	}
	public struct BlittableTransform
	{
		private unsafe readonly BlittableTransform* _parent;

		private Quaternion _worldRotation;

		private Vector3 _localPosition;

		private Vector3 _localScale;

		private Quaternion _localRotation;

		private Matrix4x4 _localToWorld;

		public Vector3 WorldPosition { get; private set; }

		public Matrix4x4 LocalToWorld => _localToWorld;

		private Matrix4x4 LocalTransform => Matrix4x4.TRS(_localPosition, _localRotation, _localScale);

		public unsafe Quaternion ParentWorldRotation
		{
			get
			{
				//IL_0016: 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)
				if (_parent == null)
				{
					return Quaternion.identity;
				}
				return _parent->_worldRotation;
			}
		}

		public void SetWorldRotation(Quaternion rotation)
		{
			//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_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			Quaternion parentWorldRotation = ParentWorldRotation;
			_localRotation = Quaternion.Inverse(parentWorldRotation) * rotation;
			UpdateLocalToWorldMatrix();
		}

		public unsafe BlittableTransform(BlittableTransform* parent, Transform transform)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0026: 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)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			_parent = parent;
			WorldPosition = transform.position;
			_worldRotation = transform.rotation;
			_localPosition = transform.localPosition;
			_localRotation = transform.localRotation;
			_localScale = transform.localScale;
			_localToWorld = transform.localToWorldMatrix;
		}

		public void PullFrom(TransformAccess transform)
		{
			//IL_0003: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			WorldPosition = ((TransformAccess)(ref transform)).position;
			_worldRotation = ((TransformAccess)(ref transform)).rotation;
			_localPosition = ((TransformAccess)(ref transform)).localPosition;
			_localRotation = ((TransformAccess)(ref transform)).localRotation;
			_localScale = ((TransformAccess)(ref transform)).localScale;
			_localToWorld = ((TransformAccess)(ref transform)).localToWorldMatrix;
		}

		public void PushTo(TransformAccess transform)
		{
			//IL_0003: 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)
			((TransformAccess)(ref transform)).localPosition = _localPosition;
			((TransformAccess)(ref transform)).localRotation = _localRotation;
		}

		public Vector3 TransformPoint(Vector3 offset)
		{
			//IL_0006: 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)
			return ((Matrix4x4)(ref _localToWorld)).MultiplyPoint3x4(offset);
		}

		public unsafe void UpdateLocalToWorldMatrix()
		{
			//IL_0024: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			_localToWorld = ((_parent == null) ? LocalTransform : (_parent->_localToWorld * LocalTransform));
			WorldPosition = ((Matrix4x4)(ref _localToWorld)).MultiplyPoint3x4(Vector3.zero);
			_worldRotation = ((Matrix4x4)(ref _localToWorld)).rotation;
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using UniVRM10.FastSpringBones.Blittables;
using Unity.Collections;
using Unity.Jobs;
using UnityEngine;
using UnityEngine.Jobs;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace UniVRM10.FastSpringBones.System
{
	public class FastSpringBoneBuffer : IDisposable
	{
		public NativeArray<BlittableSpring> Springs { get; }

		public NativeArray<BlittableJoint> Joints { get; }

		public NativeArray<BlittableCollider> Colliders { get; }

		public NativeArray<BlittableLogic> Logics { get; }

		public NativeArray<BlittableTransform> BlittableTransforms { get; }

		public Transform[] Transforms { get; }

		public bool IsDisposed { get; private set; }

		public FastSpringBoneBuffer(IReadOnlyList<FastSpringBoneSpring> springs)
		{
			//IL_0426: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: 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_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			HashSet<Transform> hashSet = new HashSet<Transform>();
			foreach (FastSpringBoneSpring spring in springs)
			{
				FastSpringBoneJoint[] joints = spring.joints;
				for (int i = 0; i < joints.Length; i++)
				{
					FastSpringBoneJoint fastSpringBoneJoint = joints[i];
					hashSet.Add(fastSpringBoneJoint.Transform);
					if ((Object)(object)fastSpringBoneJoint.Transform.parent != (Object)null)
					{
						hashSet.Add(fastSpringBoneJoint.Transform.parent);
					}
				}
				FastSpringBoneCollider[] colliders = spring.colliders;
				for (int i = 0; i < colliders.Length; i++)
				{
					FastSpringBoneCollider fastSpringBoneCollider = colliders[i];
					hashSet.Add(fastSpringBoneCollider.Transform);
				}
				if ((Object)(object)spring.center != (Object)null)
				{
					hashSet.Add(spring.center);
				}
			}
			Transform[] array = hashSet.ToArray();
			Dictionary<Transform, int> transformIndexDictionary = array.Select((Transform trs, int index) => (trs, index)).ToDictionary<(Transform, int), Transform, int>(((Transform trs, int index) tuple) => tuple.trs, ((Transform trs, int index) tuple) => tuple.index);
			List<BlittableCollider> list = new List<BlittableCollider>();
			List<BlittableJoint> list2 = new List<BlittableJoint>();
			List<BlittableSpring> list3 = new List<BlittableSpring>();
			List<BlittableLogic> list4 = new List<BlittableLogic>();
			Vector3 val = default(Vector3);
			foreach (FastSpringBoneSpring spring2 in springs)
			{
				BlittableSpring item = new BlittableSpring
				{
					colliderSpan = new BlittableSpan
					{
						startIndex = list.Count,
						count = spring2.colliders.Length
					},
					logicSpan = new BlittableSpan
					{
						startIndex = list2.Count,
						count = spring2.joints.Length - 1
					},
					centerTransformIndex = (Object.op_Implicit((Object)(object)spring2.center) ? transformIndexDictionary[spring2.center] : (-1))
				};
				list3.Add(item);
				list.AddRange(spring2.colliders.Select(delegate(FastSpringBoneCollider collider)
				{
					BlittableCollider collider2 = collider.Collider;
					collider2.transformIndex = transformIndexDictionary[collider.Transform];
					return collider2;
				}));
				list2.AddRange(from joint in spring2.joints.Take(spring2.joints.Length - 1)
					select joint.Joint);
				for (int j = 0; j < spring2.joints.Length - 1; j++)
				{
					FastSpringBoneJoint fastSpringBoneJoint2 = spring2.joints[j];
					FastSpringBoneJoint fastSpringBoneJoint3 = spring2.joints[j + 1];
					Vector3 localPosition = fastSpringBoneJoint3.Transform.localPosition;
					Vector3 lossyScale = fastSpringBoneJoint3.Transform.lossyScale;
					((Vector3)(ref val))..ctor(localPosition.x * lossyScale.x, localPosition.y * lossyScale.y, localPosition.z * lossyScale.z);
					Vector3 val2 = fastSpringBoneJoint2.Transform.TransformPoint(val);
					Vector3 val3 = (((Object)(object)spring2.center != (Object)null) ? spring2.center.InverseTransformPoint(val2) : val2);
					Transform parent = fastSpringBoneJoint2.Transform.parent;
					list4.Add(new BlittableLogic
					{
						headTransformIndex = transformIndexDictionary[fastSpringBoneJoint2.Transform],
						parentTransformIndex = (((Object)(object)parent != (Object)null) ? transformIndexDictionary[parent] : (-1)),
						currentTail = val3,
						prevTail = val3,
						localRotation = fastSpringBoneJoint2.Transform.localRotation,
						boneAxis = ((Vector3)(ref val)).normalized,
						length = ((Vector3)(ref val)).magnitude
					});
				}
			}
			Springs = new NativeArray<BlittableSpring>(list3.ToArray(), (Allocator)4);
			Joints = new NativeArray<BlittableJoint>(list2.ToArray(), (Allocator)4);
			Colliders = new NativeArray<BlittableCollider>(list.ToArray(), (Allocator)4);
			Logics = new NativeArray<BlittableLogic>(list4.ToArray(), (Allocator)4);
			BlittableTransforms = new NativeArray<BlittableTransform>(array.Length, (Allocator)4, (NativeArrayOptions)1);
			Transforms = array.ToArray();
		}

		public void Dispose()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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)
			//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)
			//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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			if (!IsDisposed)
			{
				IsDisposed = true;
				Springs.Dispose();
				Joints.Dispose();
				BlittableTransforms.Dispose();
				Colliders.Dispose();
				Logics.Dispose();
			}
		}
	}
	[Serializable]
	public struct FastSpringBoneCollider
	{
		public Transform Transform;

		public BlittableCollider Collider;
	}
	[Serializable]
	public struct FastSpringBoneJoint
	{
		public Transform Transform;

		public BlittableJoint Joint;
	}
	[Serializable]
	public struct FastSpringBoneSpring
	{
		public Transform center;

		public FastSpringBoneJoint[] joints;

		public FastSpringBoneCollider[] colliders;
	}
	public struct PullTransformJob : IJobParallelForTransform
	{
		[WriteOnly]
		public NativeArray<BlittableTransform> Transforms;

		public void Execute(int index, TransformAccess transform)
		{
			//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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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)
			Transforms[index] = new BlittableTransform
			{
				position = ((TransformAccess)(ref transform)).position,
				rotation = ((TransformAccess)(ref transform)).rotation,
				localPosition = ((TransformAccess)(ref transform)).localPosition,
				localRotation = ((TransformAccess)(ref transform)).localRotation,
				localScale = ((TransformAccess)(ref transform)).localScale,
				localToWorldMatrix = ((TransformAccess)(ref transform)).localToWorldMatrix,
				worldToLocalMatrix = ((TransformAccess)(ref transform)).worldToLocalMatrix
			};
		}
	}
	public sealed class FastSpringBoneBufferCombiner : IDisposable
	{
		private struct LoadTransformsJob : IJobParallelFor
		{
			[ReadOnly]
			public NativeArray<BlittableTransform> SrcTransforms;

			[WriteOnly]
			public NativeSlice<BlittableTransform> DestTransforms;

			public void Execute(int index)
			{
				DestTransforms[index] = SrcTransforms[index];
			}
		}

		private struct LoadSpringsJob : IJobParallelFor
		{
			[ReadOnly]
			public NativeArray<BlittableSpring> SrcSprings;

			[WriteOnly]
			public NativeSlice<BlittableSpring> DestSprings;

			public int CollidersOffset;

			public int LogicsOffset;

			public int TransformOffset;

			public void Execute(int index)
			{
				BlittableSpring blittableSpring = SrcSprings[index];
				blittableSpring.colliderSpan.startIndex += CollidersOffset;
				blittableSpring.logicSpan.startIndex += LogicsOffset;
				blittableSpring.transformIndexOffset = TransformOffset;
				DestSprings[index] = blittableSpring;
			}
		}

		private struct LoadCollidersJob : IJobParallelFor
		{
			[ReadOnly]
			public NativeArray<BlittableCollider> SrcColliders;

			[WriteOnly]
			public NativeSlice<BlittableCollider> DestColliders;

			public void Execute(int index)
			{
				DestColliders[index] = SrcColliders[index];
			}
		}

		private struct OffsetLogicsJob : IJobParallelFor
		{
			[ReadOnly]
			public NativeSlice<BlittableLogic> SrcLogics;

			[ReadOnly]
			public NativeSlice<BlittableJoint> SrcJoints;

			[WriteOnly]
			public NativeSlice<BlittableLogic> DestLogics;

			[WriteOnly]
			public NativeSlice<BlittableJoint> DestJoints;

			public void Execute(int index)
			{
				DestLogics[index] = SrcLogics[index];
				DestJoints[index] = SrcJoints[index];
			}
		}

		private NativeArray<BlittableSpring> _springs;

		private NativeArray<BlittableTransform> _transforms;

		private NativeArray<BlittableCollider> _colliders;

		private NativeArray<BlittableJoint> _joints;

		private NativeArray<BlittableLogic> _logics;

		private TransformAccessArray _transformAccessArray;

		private readonly LinkedList<FastSpringBoneBuffer> _buffers = new LinkedList<FastSpringBoneBuffer>();

		private FastSpringBoneBuffer[] _batchedBuffers;

		private int[] _batchedBufferLogicSizes;

		private bool _isDirty;

		public NativeArray<BlittableSpring> Springs => _springs;

		public NativeArray<BlittableJoint> Joints => _joints;

		public NativeArray<BlittableTransform> Transforms => _transforms;

		public TransformAccessArray TransformAccessArray => _transformAccessArray;

		public NativeArray<BlittableCollider> Colliders => _colliders;

		public NativeArray<BlittableLogic> Logics => _logics;

		public void Register(FastSpringBoneBuffer buffer)
		{
			_buffers.AddLast(buffer);
			_isDirty = true;
		}

		public void Unregister(FastSpringBoneBuffer buffer)
		{
			_buffers.Remove(buffer);
			_isDirty = true;
		}

		public JobHandle ReconstructIfDirty(JobHandle handle)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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)
			if (_isDirty)
			{
				JobHandle result = ReconstructBuffers(handle);
				_isDirty = false;
				return result;
			}
			return handle;
		}

		private void SaveToSourceBuffer()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (_batchedBuffers == null)
			{
				return;
			}
			int num = 0;
			for (int i = 0; i < _batchedBuffers.Length; i++)
			{
				int num2 = _batchedBufferLogicSizes[i];
				if (!_batchedBuffers[i].IsDisposed && num2 > 0)
				{
					NativeArray<BlittableLogic>.Copy(_logics, num, _batchedBuffers[i].Logics, 0, num2);
				}
				num += num2;
			}
		}

		private JobHandle ReconstructBuffers(JobHandle handle)
		{
			//IL_0075: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: 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_00e9: 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_00f7: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_0166: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: 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_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: 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)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: 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_0201: 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)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: 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_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: 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_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			SaveToSourceBuffer();
			DisposeAllBuffers();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			_batchedBuffers = _buffers.ToArray();
			_batchedBufferLogicSizes = _buffers.Select((FastSpringBoneBuffer buffer) => buffer.Logics.Length).ToArray();
			foreach (FastSpringBoneBuffer buffer in _buffers)
			{
				num += buffer.Springs.Length;
				num2 += buffer.Colliders.Length;
				num3 += buffer.Logics.Length;
				num4 += buffer.BlittableTransforms.Length;
			}
			_springs = new NativeArray<BlittableSpring>(num, (Allocator)4, (NativeArrayOptions)1);
			_joints = new NativeArray<BlittableJoint>(num3, (Allocator)4, (NativeArrayOptions)1);
			_logics = new NativeArray<BlittableLogic>(num3, (Allocator)4, (NativeArrayOptions)1);
			_colliders = new NativeArray<BlittableCollider>(num2, (Allocator)4, (NativeArrayOptions)1);
			_transforms = new NativeArray<BlittableTransform>(num4, (Allocator)4, (NativeArrayOptions)1);
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			foreach (FastSpringBoneBuffer buffer2 in _buffers)
			{
				LoadTransformsJob loadTransformsJob = default(LoadTransformsJob);
				loadTransformsJob.SrcTransforms = buffer2.BlittableTransforms;
				loadTransformsJob.DestTransforms = new NativeSlice<BlittableTransform>(_transforms, num8, buffer2.BlittableTransforms.Length);
				handle = IJobParallelForExtensions.Schedule<LoadTransformsJob>(loadTransformsJob, buffer2.BlittableTransforms.Length, 1, handle);
				LoadSpringsJob loadSpringsJob = default(LoadSpringsJob);
				loadSpringsJob.SrcSprings = buffer2.Springs;
				loadSpringsJob.DestSprings = new NativeSlice<BlittableSpring>(_springs, num5, buffer2.Springs.Length);
				loadSpringsJob.CollidersOffset = num6;
				loadSpringsJob.LogicsOffset = num7;
				loadSpringsJob.TransformOffset = num8;
				handle = IJobParallelForExtensions.Schedule<LoadSpringsJob>(loadSpringsJob, buffer2.Springs.Length, 1, handle);
				LoadCollidersJob loadCollidersJob = default(LoadCollidersJob);
				loadCollidersJob.SrcColliders = buffer2.Colliders;
				loadCollidersJob.DestColliders = new NativeSlice<BlittableCollider>(_colliders, num6, buffer2.Colliders.Length);
				handle = IJobParallelForExtensions.Schedule<LoadCollidersJob>(loadCollidersJob, buffer2.Colliders.Length, 1, handle);
				OffsetLogicsJob offsetLogicsJob = default(OffsetLogicsJob);
				offsetLogicsJob.SrcLogics = NativeSlice<BlittableLogic>.op_Implicit(buffer2.Logics);
				offsetLogicsJob.SrcJoints = NativeSlice<BlittableJoint>.op_Implicit(buffer2.Joints);
				offsetLogicsJob.DestLogics = new NativeSlice<BlittableLogic>(_logics, num7, buffer2.Logics.Length);
				offsetLogicsJob.DestJoints = new NativeSlice<BlittableJoint>(_joints, num7, buffer2.Logics.Length);
				handle = IJobParallelForExtensions.Schedule<OffsetLogicsJob>(offsetLogicsJob, buffer2.Logics.Length, 1, handle);
				num5 += buffer2.Springs.Length;
				num6 += buffer2.Colliders.Length;
				num7 += buffer2.Logics.Length;
				num8 += buffer2.BlittableTransforms.Length;
			}
			JobHandle.ScheduleBatchedJobs();
			Transform[] array = (Transform[])(object)new Transform[num4];
			int num9 = 0;
			foreach (FastSpringBoneBuffer buffer3 in _buffers)
			{
				Array.Copy(buffer3.Transforms, 0, array, num9, buffer3.Transforms.Length);
				num9 += buffer3.BlittableTransforms.Length;
			}
			_transformAccessArray = new TransformAccessArray(array, -1);
			return handle;
		}

		private void DisposeAllBuffers()
		{
			if (_springs.IsCreated)
			{
				_springs.Dispose();
			}
			if (_joints.IsCreated)
			{
				_joints.Dispose();
			}
			if (_transforms.IsCreated)
			{
				_transforms.Dispose();
			}
			if (((TransformAccessArray)(ref _transformAccessArray)).isCreated)
			{
				((TransformAccessArray)(ref _transformAccessArray)).Dispose();
			}
			if (_colliders.IsCreated)
			{
				_colliders.Dispose();
			}
			if (_logics.IsCreated)
			{
				_logics.Dispose();
			}
		}

		public void Dispose()
		{
			DisposeAllBuffers();
		}
	}
	public sealed class FastSpringBoneScheduler : IDisposable
	{
		private readonly FastSpringBoneBufferCombiner _bufferCombiner;

		public FastSpringBoneScheduler(FastSpringBoneBufferCombiner bufferCombiner)
		{
			_bufferCombiner = bufferCombiner;
		}

		public JobHandle Schedule()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_00b7: 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_00c5: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_00f4: 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)
			JobHandle val = _bufferCombiner.ReconstructIfDirty(default(JobHandle));
			PullTransformJob pullTransformJob = default(PullTransformJob);
			pullTransformJob.Transforms = _bufferCombiner.Transforms;
			val = IJobParallelForTransformExtensions.Schedule<PullTransformJob>(pullTransformJob, _bufferCombiner.TransformAccessArray, val);
			UpdateFastSpringBoneJob updateFastSpringBoneJob = default(UpdateFastSpringBoneJob);
			updateFastSpringBoneJob.Colliders = _bufferCombiner.Colliders;
			updateFastSpringBoneJob.Joints = _bufferCombiner.Joints;
			updateFastSpringBoneJob.Logics = _bufferCombiner.Logics;
			updateFastSpringBoneJob.Springs = _bufferCombiner.Springs;
			updateFastSpringBoneJob.Transforms = _bufferCombiner.Transforms;
			updateFastSpringBoneJob.DeltaTime = Time.deltaTime;
			val = IJobParallelForExtensions.Schedule<UpdateFastSpringBoneJob>(updateFastSpringBoneJob, _bufferCombiner.Springs.Length, 1, val);
			PushTransformJob pushTransformJob = default(PushTransformJob);
			pushTransformJob.Transforms = _bufferCombiner.Transforms;
			return IJobParallelForTransformExtensions.Schedule<PushTransformJob>(pushTransformJob, _bufferCombiner.TransformAccessArray, val);
		}

		public void Dispose()
		{
			_bufferCombiner.Dispose();
		}
	}
	[DefaultExecutionOrder(11000)]
	public sealed class FastSpringBoneService : MonoBehaviour
	{
		private FastSpringBoneScheduler _fastSpringBoneScheduler;

		private static FastSpringBoneService _instance;

		public FastSpringBoneBufferCombiner BufferCombiner { get; private set; }

		public static FastSpringBoneService Instance
		{
			get
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				if (Object.op_Implicit((Object)(object)_instance))
				{
					return _instance;
				}
				_instance = Object.FindObjectOfType<FastSpringBoneService>();
				if (Object.op_Implicit((Object)(object)_instance))
				{
					return _instance;
				}
				GameObject val = new GameObject("FastSpringBone Service");
				Object.DontDestroyOnLoad((Object)val);
				_instance = val.AddComponent<FastSpringBoneService>();
				return _instance;
			}
		}

		public static void Free()
		{
			Object.Destroy((Object)(object)((Component)_instance).gameObject);
			_instance = null;
		}

		private void OnEnable()
		{
			BufferCombiner = new FastSpringBoneBufferCombiner();
			_fastSpringBoneScheduler = new FastSpringBoneScheduler(BufferCombiner);
		}

		private void OnDisable()
		{
			BufferCombiner.Dispose();
			_fastSpringBoneScheduler.Dispose();
		}

		private void LateUpdate()
		{
			//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)
			JobHandle val = _fastSpringBoneScheduler.Schedule();
			((JobHandle)(ref val)).Complete();
		}
	}
	public struct PushTransformJob : IJobParallelForTransform
	{
		[ReadOnly]
		public NativeArray<BlittableTransform> Transforms;

		public void Execute(int index, TransformAccess transform)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			((TransformAccess)(ref transform)).rotation = Transforms[index].rotation;
		}
	}
	public struct UpdateFastSpringBoneJob : IJobParallelFor
	{
		[ReadOnly]
		public NativeArray<BlittableSpring> Springs;

		[ReadOnly]
		public NativeArray<BlittableJoint> Joints;

		[ReadOnly]
		public NativeArray<BlittableCollider> Colliders;

		[NativeDisableParallelForRestriction]
		public NativeArray<BlittableLogic> Logics;

		[NativeDisableParallelForRestriction]
		public NativeArray<BlittableTransform> Transforms;

		public float DeltaTime;

		public void Execute(int index)
		{
			//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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: 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_0119: 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_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: 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_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: 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_0204: 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)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: 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_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: 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_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03da: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			BlittableSpring blittableSpring = Springs[index];
			int transformIndexOffset = blittableSpring.transformIndexOffset;
			BlittableSpan colliderSpan = blittableSpring.colliderSpan;
			BlittableSpan logicSpan = blittableSpring.logicSpan;
			for (int i = logicSpan.startIndex; i < logicSpan.startIndex + logicSpan.count; i++)
			{
				BlittableLogic blittableLogic = Logics[i];
				BlittableJoint joint = Joints[i];
				BlittableTransform blittableTransform = Transforms[blittableLogic.headTransformIndex + transformIndexOffset];
				BlittableTransform? blittableTransform2 = ((blittableLogic.parentTransformIndex >= 0) ? new BlittableTransform?(Transforms[blittableLogic.parentTransformIndex + transformIndexOffset]) : null);
				BlittableTransform? blittableTransform3 = ((blittableSpring.centerTransformIndex >= 0) ? new BlittableTransform?(Transforms[blittableSpring.centerTransformIndex + transformIndexOffset]) : null);
				BlittableTransform value;
				if (blittableTransform2.HasValue)
				{
					value = blittableTransform2.Value;
					blittableTransform.position = ((Matrix4x4)(ref value.localToWorldMatrix)).MultiplyPoint3x4(blittableTransform.localPosition);
					blittableTransform.rotation = blittableTransform2.Value.rotation * blittableTransform.localRotation;
				}
				Vector3 val;
				if (!blittableTransform3.HasValue)
				{
					val = blittableLogic.currentTail;
				}
				else
				{
					value = blittableTransform3.Value;
					val = ((Matrix4x4)(ref value.localToWorldMatrix)).MultiplyPoint3x4(blittableLogic.currentTail);
				}
				Vector3 val2 = val;
				Vector3 val3;
				if (!blittableTransform3.HasValue)
				{
					val3 = blittableLogic.prevTail;
				}
				else
				{
					value = blittableTransform3.Value;
					val3 = ((Matrix4x4)(ref value.localToWorldMatrix)).MultiplyPoint3x4(blittableLogic.prevTail);
				}
				Vector3 val4 = val3;
				Quaternion val5 = blittableTransform2?.rotation ?? Quaternion.identity;
				Vector3 val6 = joint.gravityDir * joint.gravityPower * DeltaTime;
				Vector3 val7 = val2 + (val2 - val4) * (1f - joint.dragForce) + val5 * blittableLogic.localRotation * blittableLogic.boneAxis * joint.stiffnessForce * DeltaTime + val6;
				Vector3 position = blittableTransform.position;
				Vector3 val8 = val7 - blittableTransform.position;
				val7 = position + ((Vector3)(ref val8)).normalized * blittableLogic.length;
				for (int j = colliderSpan.startIndex; j < colliderSpan.startIndex + colliderSpan.count; j++)
				{
					BlittableCollider collider = Colliders[j];
					BlittableTransform blittableTransform4 = Transforms[collider.transformIndex + transformIndexOffset];
					Vector3 lossyScale = ((Matrix4x4)(ref blittableTransform4.localToWorldMatrix)).lossyScale;
					float maxColliderScale = Mathf.Max(Mathf.Max(Mathf.Abs(lossyScale.x), Mathf.Abs(lossyScale.y)), Mathf.Abs(lossyScale.z));
					Vector3 worldPosition = ((Matrix4x4)(ref blittableTransform4.localToWorldMatrix)).MultiplyPoint3x4(collider.offset);
					Vector3 worldTail = ((Matrix4x4)(ref blittableTransform4.localToWorldMatrix)).MultiplyPoint3x4(collider.tail);
					switch (collider.colliderType)
					{
					case BlittableColliderType.Sphere:
						ResolveSphereCollision(joint, collider, worldPosition, blittableTransform, maxColliderScale, blittableLogic, ref val7);
						break;
					case BlittableColliderType.Capsule:
						ResolveCapsuleCollision(worldTail, worldPosition, blittableTransform, joint, collider, maxColliderScale, blittableLogic, ref val7);
						break;
					}
				}
				Vector3 prevTail;
				if (!blittableTransform3.HasValue)
				{
					prevTail = val2;
				}
				else
				{
					value = blittableTransform3.Value;
					prevTail = ((Matrix4x4)(ref value.worldToLocalMatrix)).MultiplyPoint3x4(val2);
				}
				blittableLogic.prevTail = prevTail;
				Vector3 currentTail;
				if (!blittableTransform3.HasValue)
				{
					currentTail = val7;
				}
				else
				{
					value = blittableTransform3.Value;
					currentTail = ((Matrix4x4)(ref value.worldToLocalMatrix)).MultiplyPoint3x4(val7);
				}
				blittableLogic.currentTail = currentTail;
				Quaternion val9 = val5 * blittableLogic.localRotation;
				blittableTransform.rotation = Quaternion.FromToRotation(val9 * blittableLogic.boneAxis, val7 - blittableTransform.position) * val9;
				if (blittableTransform2.HasValue)
				{
					Matrix4x4 localToWorldMatrix = blittableTransform2.Value.localToWorldMatrix;
					blittableTransform.localRotation = Normalize(Quaternion.Inverse(blittableTransform2.Value.rotation) * blittableTransform.rotation);
					blittableTransform.localToWorldMatrix = localToWorldMatrix * Matrix4x4.TRS(blittableTransform.localPosition, blittableTransform.localRotation, blittableTransform.localScale);
					blittableTransform.worldToLocalMatrix = ((Matrix4x4)(ref blittableTransform.localToWorldMatrix)).inverse;
				}
				else
				{
					blittableTransform.localToWorldMatrix = Matrix4x4.TRS(blittableTransform.position, blittableTransform.rotation, blittableTransform.localScale);
					blittableTransform.worldToLocalMatrix = ((Matrix4x4)(ref blittableTransform.localToWorldMatrix)).inverse;
					blittableTransform.localRotation = blittableTransform.rotation;
				}
				Transforms[blittableLogic.headTransformIndex + transformIndexOffset] = blittableTransform;
				Logics[i] = blittableLogic;
			}
		}

		private static Quaternion Normalize(Quaternion q)
		{
			//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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			float num = (float)Math.Sqrt(Quaternion.Dot(q, q));
			if (!(num < float.Epsilon))
			{
				return new Quaternion(q.x / num, q.y / num, q.z / num, q.w / num);
			}
			return Quaternion.identity;
		}

		private static void ResolveCapsuleCollision(Vector3 worldTail, Vector3 worldPosition, BlittableTransform headTransform, BlittableJoint joint, BlittableCollider collider, float maxColliderScale, BlittableLogic logic, ref Vector3 nextTail)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = worldTail - worldPosition;
			Vector3 val2 = headTransform.position - worldPosition;
			float num = Vector3.Dot(val, val2);
			if (num <= 0f)
			{
				ResolveSphereCollision(joint, collider, worldPosition, headTransform, maxColliderScale, logic, ref nextTail);
			}
			float num2 = num / ((Vector3)(ref val)).magnitude;
			if (num2 >= 1f)
			{
				ResolveSphereCollision(joint, collider, worldTail, headTransform, maxColliderScale, logic, ref nextTail);
			}
			Vector3 worldPosition2 = worldPosition + val * num2;
			ResolveSphereCollision(joint, collider, worldPosition2, headTransform, maxColliderScale, logic, ref nextTail);
		}

		private static void ResolveSphereCollision(BlittableJoint joint, BlittableCollider collider, Vector3 worldPosition, BlittableTransform headTransform, float maxColliderScale, BlittableLogic logic, ref Vector3 nextTail)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0038: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			float num = joint.radius + collider.radius * maxColliderScale;
			if (Vector3.SqrMagnitude(nextTail - worldPosition) <= num * num)
			{
				Vector3 val = nextTail - worldPosition;
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				Vector3 val2 = worldPosition + normalized * num;
				Vector3 position = headTransform.position;
				val = val2 - headTransform.position;
				nextTail = position + ((Vector3)(ref val)).normalized * logic.length;
			}
		}
	}
}
namespace UniVRM10.FastSpringBones.Blittables
{
	[Serializable]
	public struct BlittableCollider
	{
		public BlittableColliderType colliderType;

		public Vector3 offset;

		public float radius;

		public Vector3 tail;

		public int transformIndex;
	}
	public enum BlittableColliderType
	{
		Sphere,
		Capsule
	}
	[Serializable]
	public struct BlittableJoint
	{
		public float stiffnessForce;

		public float gravityPower;

		public Vector3 gravityDir;

		public float dragForce;

		public float radius;
	}
	[Serializable]
	public struct BlittableLogic
	{
		public int parentTransformIndex;

		public int headTransformIndex;

		public float length;

		public Vector3 currentTail;

		public Vector3 prevTail;

		public Quaternion localRotation;

		public Vector3 boneAxis;
	}
	[Serializable]
	public struct BlittableSpan
	{
		public int startIndex;

		public int count;
	}
	[Serializable]
	public struct BlittableSpring
	{
		public BlittableSpan colliderSpan;

		public BlittableSpan logicSpan;

		public int centerTransformIndex;

		public int transformIndexOffset;
	}
	[Serializable]
	public struct BlittableTransform
	{
		public Vector3 position;

		public Quaternion rotation;

		public Vector3 localPosition;

		public Quaternion localRotation;

		public Vector3 localScale;

		public Matrix4x4 localToWorldMatrix;

		public Matrix4x4 worldToLocalMatrix;
	}
}