using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using UnityEngine;

namespace Obi
{
	// Token: 0x02000532 RID: 1330
	public class ObiParticleCache : ScriptableObject
	{
		// Token: 0x17003344 RID: 13124
		// (get) Token: 0x06009798 RID: 38808 RVA: 0x0027064C File Offset: 0x0026E84C
		public unsafe float Duration
		{
			[CallerCount(0)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.NativeMethodInfoPtr_get_Duration_Public_get_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x17003345 RID: 13125
		// (get) Token: 0x06009799 RID: 38809 RVA: 0x0027069C File Offset: 0x0026E89C
		public unsafe int FrameCount
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 643511, XrefRangeEnd = 643512, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.NativeMethodInfoPtr_get_FrameCount_Public_get_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x0600979A RID: 38810 RVA: 0x002706EC File Offset: 0x0026E8EC
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 643512, XrefRangeEnd = 643529, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void OnEnable()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.NativeMethodInfoPtr_OnEnable_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600979B RID: 38811 RVA: 0x00270730 File Offset: 0x0026E930
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 643529, XrefRangeEnd = 643545, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe int SizeInBytes()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.NativeMethodInfoPtr_SizeInBytes_Public_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			return *IL2CPP.il2cpp_object_unbox(intPtr);
		}

		// Token: 0x0600979C RID: 38812 RVA: 0x00270780 File Offset: 0x0026E980
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 643545, XrefRangeEnd = 643555, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Clear()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.NativeMethodInfoPtr_Clear_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600979D RID: 38813 RVA: 0x002707C4 File Offset: 0x0026E9C4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 643555, XrefRangeEnd = 643559, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe int GetBaseFrame(float time)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref time;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.NativeMethodInfoPtr_GetBaseFrame_Private_Int32_Single_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}
		}

		// Token: 0x0600979E RID: 38814 RVA: 0x00270828 File Offset: 0x0026EA28
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 643575, RefRangeEnd = 643576, XrefRangeStart = 643559, XrefRangeEnd = 643575, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void AddFrame(ObiParticleCache.Frame frame)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(frame);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.NativeMethodInfoPtr_AddFrame_Public_Void_Frame_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x0600979F RID: 38815 RVA: 0x00270884 File Offset: 0x0026EA84
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 643589, RefRangeEnd = 643590, XrefRangeStart = 643576, XrefRangeEnd = 643589, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void GetFrame(float time, bool interpolate, ref ObiParticleCache.Frame result)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref time;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref interpolate;
			ref IntPtr ptr2 = ref ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)];
			IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtr(result);
			ptr2 = &intPtr;
			IntPtr intPtr3;
			IntPtr intPtr2 = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.NativeMethodInfoPtr_GetFrame_Public_Void_Single_Boolean_byref_Frame_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr3);
			Il2CppException.RaiseExceptionIfNecessary(intPtr3);
			IntPtr intPtr4 = intPtr;
			result = ((intPtr4 == 0) ? null : new ObiParticleCache.Frame(intPtr4));
		}

		// Token: 0x060097A0 RID: 38816 RVA: 0x00270924 File Offset: 0x0026EB24
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 643590, XrefRangeEnd = 643591, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe ObiParticleCache()
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr))
		{
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x060097A1 RID: 38817 RVA: 0x00270970 File Offset: 0x0026EB70
		// Note: this type is marked as 'beforefieldinit'.
		static ObiParticleCache()
		{
			Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "Obi", "ObiParticleCache");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr);
			ObiParticleCache.NativeFieldInfoPtr_referenceIntervalSeconds = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, "referenceIntervalSeconds");
			ObiParticleCache.NativeFieldInfoPtr_localSpace = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, "localSpace");
			ObiParticleCache.NativeFieldInfoPtr_duration = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, "duration");
			ObiParticleCache.NativeFieldInfoPtr_frames = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, "frames");
			ObiParticleCache.NativeFieldInfoPtr_references = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, "references");
			ObiParticleCache.NativeMethodInfoPtr_get_Duration_Public_get_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100675104);
			ObiParticleCache.NativeMethodInfoPtr_get_FrameCount_Public_get_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100675105);
			ObiParticleCache.NativeMethodInfoPtr_OnEnable_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100675106);
			ObiParticleCache.NativeMethodInfoPtr_SizeInBytes_Public_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100675107);
			ObiParticleCache.NativeMethodInfoPtr_Clear_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100675108);
			ObiParticleCache.NativeMethodInfoPtr_GetBaseFrame_Private_Int32_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100675109);
			ObiParticleCache.NativeMethodInfoPtr_AddFrame_Public_Void_Frame_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100675110);
			ObiParticleCache.NativeMethodInfoPtr_GetFrame_Public_Void_Single_Boolean_byref_Frame_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100675111);
			ObiParticleCache.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100675112);
		}

		// Token: 0x060097A2 RID: 38818 RVA: 0x00009E64 File Offset: 0x00008064
		public ObiParticleCache(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x1700333F RID: 13119
		// (get) Token: 0x060097A3 RID: 38819 RVA: 0x00270AB8 File Offset: 0x0026ECB8
		// (set) Token: 0x060097A4 RID: 38820 RVA: 0x00270AE0 File Offset: 0x0026ECE0
		public unsafe float referenceIntervalSeconds
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.NativeFieldInfoPtr_referenceIntervalSeconds);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.NativeFieldInfoPtr_referenceIntervalSeconds)) = value;
			}
		}

		// Token: 0x17003340 RID: 13120
		// (get) Token: 0x060097A5 RID: 38821 RVA: 0x00270B04 File Offset: 0x0026ED04
		// (set) Token: 0x060097A6 RID: 38822 RVA: 0x00270B2C File Offset: 0x0026ED2C
		public unsafe bool localSpace
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.NativeFieldInfoPtr_localSpace);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.NativeFieldInfoPtr_localSpace)) = value;
			}
		}

		// Token: 0x17003341 RID: 13121
		// (get) Token: 0x060097A7 RID: 38823 RVA: 0x00270B50 File Offset: 0x0026ED50
		// (set) Token: 0x060097A8 RID: 38824 RVA: 0x00270B78 File Offset: 0x0026ED78
		public unsafe float duration
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.NativeFieldInfoPtr_duration);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.NativeFieldInfoPtr_duration)) = value;
			}
		}

		// Token: 0x17003342 RID: 13122
		// (get) Token: 0x060097A9 RID: 38825 RVA: 0x00270B9C File Offset: 0x0026ED9C
		// (set) Token: 0x060097AA RID: 38826 RVA: 0x00270BD0 File Offset: 0x0026EDD0
		public unsafe List<ObiParticleCache.Frame> frames
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.NativeFieldInfoPtr_frames);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new List<ObiParticleCache.Frame>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.NativeFieldInfoPtr_frames), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17003343 RID: 13123
		// (get) Token: 0x060097AB RID: 38827 RVA: 0x00270BF8 File Offset: 0x0026EDF8
		// (set) Token: 0x060097AC RID: 38828 RVA: 0x00270C2C File Offset: 0x0026EE2C
		public unsafe List<int> references
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.NativeFieldInfoPtr_references);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new List<int>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.NativeFieldInfoPtr_references), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x04006521 RID: 25889
		private static readonly IntPtr NativeFieldInfoPtr_referenceIntervalSeconds;

		// Token: 0x04006522 RID: 25890
		private static readonly IntPtr NativeFieldInfoPtr_localSpace;

		// Token: 0x04006523 RID: 25891
		private static readonly IntPtr NativeFieldInfoPtr_duration;

		// Token: 0x04006524 RID: 25892
		private static readonly IntPtr NativeFieldInfoPtr_frames;

		// Token: 0x04006525 RID: 25893
		private static readonly IntPtr NativeFieldInfoPtr_references;

		// Token: 0x04006526 RID: 25894
		private static readonly IntPtr NativeMethodInfoPtr_get_Duration_Public_get_Single_0;

		// Token: 0x04006527 RID: 25895
		private static readonly IntPtr NativeMethodInfoPtr_get_FrameCount_Public_get_Int32_0;

		// Token: 0x04006528 RID: 25896
		private static readonly IntPtr NativeMethodInfoPtr_OnEnable_Public_Void_0;

		// Token: 0x04006529 RID: 25897
		private static readonly IntPtr NativeMethodInfoPtr_SizeInBytes_Public_Int32_0;

		// Token: 0x0400652A RID: 25898
		private static readonly IntPtr NativeMethodInfoPtr_Clear_Public_Void_0;

		// Token: 0x0400652B RID: 25899
		private static readonly IntPtr NativeMethodInfoPtr_GetBaseFrame_Private_Int32_Single_0;

		// Token: 0x0400652C RID: 25900
		private static readonly IntPtr NativeMethodInfoPtr_AddFrame_Public_Void_Frame_0;

		// Token: 0x0400652D RID: 25901
		private static readonly IntPtr NativeMethodInfoPtr_GetFrame_Public_Void_Single_Boolean_byref_Frame_0;

		// Token: 0x0400652E RID: 25902
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x02000533 RID: 1331
		public class UncompressedFrame : Il2CppSystem.Object
		{
			// Token: 0x060097AD RID: 38829 RVA: 0x00270C54 File Offset: 0x0026EE54
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 643295, XrefRangeEnd = 643451, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe UncompressedFrame()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<ObiParticleCache.UncompressedFrame>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.UncompressedFrame.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060097AE RID: 38830 RVA: 0x00270CA0 File Offset: 0x0026EEA0
			// Note: this type is marked as 'beforefieldinit'.
			static UncompressedFrame()
			{
				Il2CppClassPointerStore<ObiParticleCache.UncompressedFrame>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, "UncompressedFrame");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ObiParticleCache.UncompressedFrame>.NativeClassPtr);
				ObiParticleCache.UncompressedFrame.NativeFieldInfoPtr_indices = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ObiParticleCache.UncompressedFrame>.NativeClassPtr, "indices");
				ObiParticleCache.UncompressedFrame.NativeFieldInfoPtr_positions = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ObiParticleCache.UncompressedFrame>.NativeClassPtr, "positions");
				ObiParticleCache.UncompressedFrame.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache.UncompressedFrame>.NativeClassPtr, 100675113);
			}

			// Token: 0x060097AF RID: 38831 RVA: 0x0000A74C File Offset: 0x0000894C
			public UncompressedFrame(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17003346 RID: 13126
			// (get) Token: 0x060097B0 RID: 38832 RVA: 0x00270D08 File Offset: 0x0026EF08
			// (set) Token: 0x060097B1 RID: 38833 RVA: 0x00270D3C File Offset: 0x0026EF3C
			public unsafe List<int> indices
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.UncompressedFrame.NativeFieldInfoPtr_indices);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new List<int>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.UncompressedFrame.NativeFieldInfoPtr_indices), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x17003347 RID: 13127
			// (get) Token: 0x060097B2 RID: 38834 RVA: 0x00270D64 File Offset: 0x0026EF64
			// (set) Token: 0x060097B3 RID: 38835 RVA: 0x00270D98 File Offset: 0x0026EF98
			public unsafe List<Vector3> positions
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.UncompressedFrame.NativeFieldInfoPtr_positions);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new List<Vector3>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.UncompressedFrame.NativeFieldInfoPtr_positions), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x0400652F RID: 25903
			private static readonly IntPtr NativeFieldInfoPtr_indices;

			// Token: 0x04006530 RID: 25904
			private static readonly IntPtr NativeFieldInfoPtr_positions;

			// Token: 0x04006531 RID: 25905
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x02000534 RID: 1332
		[Serializable]
		public class Frame : Il2CppSystem.Object
		{
			// Token: 0x060097B4 RID: 38836 RVA: 0x00270DC0 File Offset: 0x0026EFC0
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 643466, RefRangeEnd = 643468, XrefRangeStart = 643451, XrefRangeEnd = 643466, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe Frame()
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr))
			{
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.Frame.NativeMethodInfoPtr__ctor_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060097B5 RID: 38837 RVA: 0x00270E0C File Offset: 0x0026F00C
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 643468, XrefRangeEnd = 643475, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe void Clear()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.Frame.NativeMethodInfoPtr_Clear_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060097B6 RID: 38838 RVA: 0x00270E50 File Offset: 0x0026F050
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 643477, RefRangeEnd = 643478, XrefRangeStart = 643475, XrefRangeEnd = 643477, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe int SizeInBytes()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.Frame.NativeMethodInfoPtr_SizeInBytes_Public_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				return *IL2CPP.il2cpp_object_unbox(intPtr);
			}

			// Token: 0x060097B7 RID: 38839 RVA: 0x00270EA0 File Offset: 0x0026F0A0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 643478, XrefRangeEnd = 643511, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe static void Lerp(ObiParticleCache.Frame a, ObiParticleCache.Frame b, ref ObiParticleCache.Frame result, float mu)
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)];
					*ptr = IL2CPP.Il2CppObjectBaseToPtr(a);
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(b);
				ref IntPtr ptr2 = ref ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)];
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtr(result);
				ptr2 = &intPtr;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref mu;
				IntPtr intPtr3;
				IntPtr intPtr2 = IL2CPP.il2cpp_runtime_invoke(ObiParticleCache.Frame.NativeMethodInfoPtr_Lerp_Public_Static_Void_Frame_Frame_byref_Frame_Single_0, 0, (void**)ptr, ref intPtr3);
				Il2CppException.RaiseExceptionIfNecessary(intPtr3);
				IntPtr intPtr4 = intPtr;
				result = ((intPtr4 == 0) ? null : new ObiParticleCache.Frame(intPtr4));
			}

			// Token: 0x060097B8 RID: 38840 RVA: 0x00270F50 File Offset: 0x0026F150
			// Note: this type is marked as 'beforefieldinit'.
			static Frame()
			{
				Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, "Frame");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr);
				ObiParticleCache.Frame.NativeFieldInfoPtr_time = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr, "time");
				ObiParticleCache.Frame.NativeFieldInfoPtr_positions = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr, "positions");
				ObiParticleCache.Frame.NativeFieldInfoPtr_indices = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr, "indices");
				ObiParticleCache.Frame.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr, 100675114);
				ObiParticleCache.Frame.NativeMethodInfoPtr_Clear_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr, 100675115);
				ObiParticleCache.Frame.NativeMethodInfoPtr_SizeInBytes_Public_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr, 100675116);
				ObiParticleCache.Frame.NativeMethodInfoPtr_Lerp_Public_Static_Void_Frame_Frame_byref_Frame_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr, 100675117);
			}

			// Token: 0x060097B9 RID: 38841 RVA: 0x0000A74C File Offset: 0x0000894C
			public Frame(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x17003348 RID: 13128
			// (get) Token: 0x060097BA RID: 38842 RVA: 0x00271008 File Offset: 0x0026F208
			// (set) Token: 0x060097BB RID: 38843 RVA: 0x00271030 File Offset: 0x0026F230
			public unsafe float time
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.Frame.NativeFieldInfoPtr_time);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.Frame.NativeFieldInfoPtr_time)) = value;
				}
			}

			// Token: 0x17003349 RID: 13129
			// (get) Token: 0x060097BC RID: 38844 RVA: 0x00271054 File Offset: 0x0026F254
			// (set) Token: 0x060097BD RID: 38845 RVA: 0x00271088 File Offset: 0x0026F288
			public unsafe List<Vector3> positions
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.Frame.NativeFieldInfoPtr_positions);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new List<Vector3>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.Frame.NativeFieldInfoPtr_positions), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x1700334A RID: 13130
			// (get) Token: 0x060097BE RID: 38846 RVA: 0x002710B0 File Offset: 0x0026F2B0
			// (set) Token: 0x060097BF RID: 38847 RVA: 0x002710E4 File Offset: 0x0026F2E4
			public unsafe List<int> indices
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.Frame.NativeFieldInfoPtr_indices);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new List<int>(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(ObiParticleCache.Frame.NativeFieldInfoPtr_indices), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x04006532 RID: 25906
			private static readonly IntPtr NativeFieldInfoPtr_time;

			// Token: 0x04006533 RID: 25907
			private static readonly IntPtr NativeFieldInfoPtr_positions;

			// Token: 0x04006534 RID: 25908
			private static readonly IntPtr NativeFieldInfoPtr_indices;

			// Token: 0x04006535 RID: 25909
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x04006536 RID: 25910
			private static readonly IntPtr NativeMethodInfoPtr_Clear_Public_Void_0;

			// Token: 0x04006537 RID: 25911
			private static readonly IntPtr NativeMethodInfoPtr_SizeInBytes_Public_Int32_0;

			// Token: 0x04006538 RID: 25912
			private static readonly IntPtr NativeMethodInfoPtr_Lerp_Public_Static_Void_Frame_Frame_byref_Frame_Single_0;
		}
	}
}
