using System;
using System.Runtime.CompilerServices;
using UnityEngine.Playables;
using UnityEngine.Scripting;

namespace UnityEngine.Animations
{
	// Token: 0x020001F3 RID: 499
	[RequiredByNativeCode]
	public struct AnimationLayerMixerPlayable : IPlayable, IEquatable<AnimationLayerMixerPlayable>
	{
		// Token: 0x060022ED RID: 8941 RVA: 0x00028864 File Offset: 0x00026A64
		internal AnimationLayerMixerPlayable(PlayableHandle handle)
		{
			if (handle.IsValid())
			{
				if (!handle.IsPlayableOfType<AnimationLayerMixerPlayable>())
				{
					throw new InvalidCastException("Can't set handle: the playable is not an AnimationLayerMixerPlayable.");
				}
			}
			this.m_Handle = handle;
		}

		// Token: 0x17000837 RID: 2103
		// (get) Token: 0x060022EE RID: 8942 RVA: 0x00028894 File Offset: 0x00026A94
		public static AnimationLayerMixerPlayable Null
		{
			get
			{
				return AnimationLayerMixerPlayable.m_NullPlayable;
			}
		}

		// Token: 0x060022EF RID: 8943 RVA: 0x000288B0 File Offset: 0x00026AB0
		public static AnimationLayerMixerPlayable Create(PlayableGraph graph, int inputCount = 0)
		{
			PlayableHandle playableHandle = AnimationLayerMixerPlayable.CreateHandle(graph, inputCount);
			return new AnimationLayerMixerPlayable(playableHandle);
		}

		// Token: 0x060022F0 RID: 8944 RVA: 0x000288D4 File Offset: 0x00026AD4
		private static PlayableHandle CreateHandle(PlayableGraph graph, int inputCount = 0)
		{
			PlayableHandle @null = PlayableHandle.Null;
			PlayableHandle playableHandle;
			if (!AnimationLayerMixerPlayable.CreateHandleInternal(graph, ref @null))
			{
				playableHandle = PlayableHandle.Null;
			}
			else
			{
				@null.SetInputCount(inputCount);
				playableHandle = @null;
			}
			return playableHandle;
		}

		// Token: 0x060022F1 RID: 8945 RVA: 0x00028910 File Offset: 0x00026B10
		public PlayableHandle GetHandle()
		{
			return this.m_Handle;
		}

		// Token: 0x060022F2 RID: 8946 RVA: 0x0002892C File Offset: 0x00026B2C
		public static implicit operator Playable(AnimationLayerMixerPlayable playable)
		{
			return new Playable(playable.GetHandle());
		}

		// Token: 0x060022F3 RID: 8947 RVA: 0x00028950 File Offset: 0x00026B50
		public static explicit operator AnimationLayerMixerPlayable(Playable playable)
		{
			return new AnimationLayerMixerPlayable(playable.GetHandle());
		}

		// Token: 0x060022F4 RID: 8948 RVA: 0x00028974 File Offset: 0x00026B74
		public bool Equals(AnimationLayerMixerPlayable other)
		{
			return this.GetHandle() == other.GetHandle();
		}

		// Token: 0x060022F5 RID: 8949 RVA: 0x0002899C File Offset: 0x00026B9C
		private static bool CreateHandleInternal(PlayableGraph graph, ref PlayableHandle handle)
		{
			return AnimationLayerMixerPlayable.INTERNAL_CALL_CreateHandleInternal(ref graph, ref handle);
		}

		// Token: 0x060022F6 RID: 8950
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool INTERNAL_CALL_CreateHandleInternal(ref PlayableGraph graph, ref PlayableHandle handle);

		// Token: 0x060022F7 RID: 8951 RVA: 0x000289BC File Offset: 0x00026BBC
		public bool IsLayerAdditive(uint layerIndex)
		{
			if ((ulong)layerIndex >= (ulong)((long)this.m_Handle.GetInputCount()))
			{
				throw new ArgumentOutOfRangeException("layerIndex", string.Format("layerIndex {0} must be in the range of 0 to {1}.", layerIndex, this.m_Handle.GetInputCount() - 1));
			}
			return AnimationLayerMixerPlayable.IsLayerAdditiveInternal(ref this.m_Handle, layerIndex);
		}

		// Token: 0x060022F8 RID: 8952 RVA: 0x00028A20 File Offset: 0x00026C20
		public void SetLayerAdditive(uint layerIndex, bool value)
		{
			if ((ulong)layerIndex >= (ulong)((long)this.m_Handle.GetInputCount()))
			{
				throw new ArgumentOutOfRangeException("layerIndex", string.Format("layerIndex {0} must be in the range of 0 to {1}.", layerIndex, this.m_Handle.GetInputCount() - 1));
			}
			AnimationLayerMixerPlayable.SetLayerAdditiveInternal(ref this.m_Handle, layerIndex, value);
		}

		// Token: 0x060022F9 RID: 8953 RVA: 0x00028A7C File Offset: 0x00026C7C
		public void SetLayerMaskFromAvatarMask(uint layerIndex, AvatarMask mask)
		{
			if ((ulong)layerIndex >= (ulong)((long)this.m_Handle.GetInputCount()))
			{
				throw new ArgumentOutOfRangeException("layerIndex", string.Format("layerIndex {0} must be in the range of 0 to {1}.", layerIndex, this.m_Handle.GetInputCount() - 1));
			}
			if (mask == null)
			{
				throw new ArgumentNullException("mask");
			}
			AnimationLayerMixerPlayable.SetLayerMaskFromAvatarMaskInternal(ref this.m_Handle, layerIndex, mask);
		}

		// Token: 0x060022FA RID: 8954 RVA: 0x00028AF0 File Offset: 0x00026CF0
		private static bool IsLayerAdditiveInternal(ref PlayableHandle handle, uint layerIndex)
		{
			return AnimationLayerMixerPlayable.INTERNAL_CALL_IsLayerAdditiveInternal(ref handle, layerIndex);
		}

		// Token: 0x060022FB RID: 8955
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern bool INTERNAL_CALL_IsLayerAdditiveInternal(ref PlayableHandle handle, uint layerIndex);

		// Token: 0x060022FC RID: 8956 RVA: 0x00028B0C File Offset: 0x00026D0C
		private static void SetLayerAdditiveInternal(ref PlayableHandle handle, uint layerIndex, bool value)
		{
			AnimationLayerMixerPlayable.INTERNAL_CALL_SetLayerAdditiveInternal(ref handle, layerIndex, value);
		}

		// Token: 0x060022FD RID: 8957
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetLayerAdditiveInternal(ref PlayableHandle handle, uint layerIndex, bool value);

		// Token: 0x060022FE RID: 8958 RVA: 0x00028B18 File Offset: 0x00026D18
		private static void SetLayerMaskFromAvatarMaskInternal(ref PlayableHandle handle, uint layerIndex, AvatarMask mask)
		{
			AnimationLayerMixerPlayable.INTERNAL_CALL_SetLayerMaskFromAvatarMaskInternal(ref handle, layerIndex, mask);
		}

		// Token: 0x060022FF RID: 8959
		[GeneratedByOldBindingsGenerator]
		[MethodImpl(MethodImplOptions.InternalCall)]
		private static extern void INTERNAL_CALL_SetLayerMaskFromAvatarMaskInternal(ref PlayableHandle handle, uint layerIndex, AvatarMask mask);

		// Token: 0x04000541 RID: 1345
		private PlayableHandle m_Handle;

		// Token: 0x04000542 RID: 1346
		private static readonly AnimationLayerMixerPlayable m_NullPlayable = new AnimationLayerMixerPlayable(PlayableHandle.Null);
	}
}