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

namespace Obi
{
	// Token: 0x020004DA RID: 1242
	public class ObiParticleCache : ScriptableObject
	{
		// Token: 0x170030A9 RID: 12457
		// (get) Token: 0x06008F45 RID: 36677 RVA: 0x0024D910 File Offset: 0x0024BB10
		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: 0x170030AA RID: 12458
		// (get) Token: 0x06008F46 RID: 36678 RVA: 0x0024D960 File Offset: 0x0024BB60
		public unsafe int FrameCount
		{
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 611201, XrefRangeEnd = 611202, 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: 0x06008F47 RID: 36679 RVA: 0x0024D9B0 File Offset: 0x0024BBB0
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 611202, XrefRangeEnd = 611219, 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: 0x06008F48 RID: 36680 RVA: 0x0024D9F4 File Offset: 0x0024BBF4
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 611219, XrefRangeEnd = 611235, 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: 0x06008F49 RID: 36681 RVA: 0x0024DA44 File Offset: 0x0024BC44
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 611235, XrefRangeEnd = 611245, 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: 0x06008F4A RID: 36682 RVA: 0x0024DA88 File Offset: 0x0024BC88
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 611245, XrefRangeEnd = 611249, 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: 0x06008F4B RID: 36683 RVA: 0x0024DAEC File Offset: 0x0024BCEC
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 611265, RefRangeEnd = 611266, XrefRangeStart = 611249, XrefRangeEnd = 611265, 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: 0x06008F4C RID: 36684 RVA: 0x0024DB48 File Offset: 0x0024BD48
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 611279, RefRangeEnd = 611280, XrefRangeStart = 611266, XrefRangeEnd = 611279, 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: 0x06008F4D RID: 36685 RVA: 0x0024DBE8 File Offset: 0x0024BDE8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 611280, XrefRangeEnd = 611281, 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: 0x06008F4E RID: 36686 RVA: 0x0024DC34 File Offset: 0x0024BE34
		// 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, 100674391);
			ObiParticleCache.NativeMethodInfoPtr_get_FrameCount_Public_get_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100674392);
			ObiParticleCache.NativeMethodInfoPtr_OnEnable_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100674393);
			ObiParticleCache.NativeMethodInfoPtr_SizeInBytes_Public_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100674394);
			ObiParticleCache.NativeMethodInfoPtr_Clear_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100674395);
			ObiParticleCache.NativeMethodInfoPtr_GetBaseFrame_Private_Int32_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100674396);
			ObiParticleCache.NativeMethodInfoPtr_AddFrame_Public_Void_Frame_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100674397);
			ObiParticleCache.NativeMethodInfoPtr_GetFrame_Public_Void_Single_Boolean_byref_Frame_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100674398);
			ObiParticleCache.NativeMethodInfoPtr__ctor_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache>.NativeClassPtr, 100674399);
		}

		// Token: 0x06008F4F RID: 36687 RVA: 0x00009DEC File Offset: 0x00007FEC
		public ObiParticleCache(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x170030A4 RID: 12452
		// (get) Token: 0x06008F50 RID: 36688 RVA: 0x0024DD7C File Offset: 0x0024BF7C
		// (set) Token: 0x06008F51 RID: 36689 RVA: 0x0024DDA4 File Offset: 0x0024BFA4
		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: 0x170030A5 RID: 12453
		// (get) Token: 0x06008F52 RID: 36690 RVA: 0x0024DDC8 File Offset: 0x0024BFC8
		// (set) Token: 0x06008F53 RID: 36691 RVA: 0x0024DDF0 File Offset: 0x0024BFF0
		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: 0x170030A6 RID: 12454
		// (get) Token: 0x06008F54 RID: 36692 RVA: 0x0024DE14 File Offset: 0x0024C014
		// (set) Token: 0x06008F55 RID: 36693 RVA: 0x0024DE3C File Offset: 0x0024C03C
		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: 0x170030A7 RID: 12455
		// (get) Token: 0x06008F56 RID: 36694 RVA: 0x0024DE60 File Offset: 0x0024C060
		// (set) Token: 0x06008F57 RID: 36695 RVA: 0x0024DE94 File Offset: 0x0024C094
		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: 0x170030A8 RID: 12456
		// (get) Token: 0x06008F58 RID: 36696 RVA: 0x0024DEBC File Offset: 0x0024C0BC
		// (set) Token: 0x06008F59 RID: 36697 RVA: 0x0024DEF0 File Offset: 0x0024C0F0
		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: 0x04005F78 RID: 24440
		private static readonly IntPtr NativeFieldInfoPtr_referenceIntervalSeconds;

		// Token: 0x04005F79 RID: 24441
		private static readonly IntPtr NativeFieldInfoPtr_localSpace;

		// Token: 0x04005F7A RID: 24442
		private static readonly IntPtr NativeFieldInfoPtr_duration;

		// Token: 0x04005F7B RID: 24443
		private static readonly IntPtr NativeFieldInfoPtr_frames;

		// Token: 0x04005F7C RID: 24444
		private static readonly IntPtr NativeFieldInfoPtr_references;

		// Token: 0x04005F7D RID: 24445
		private static readonly IntPtr NativeMethodInfoPtr_get_Duration_Public_get_Single_0;

		// Token: 0x04005F7E RID: 24446
		private static readonly IntPtr NativeMethodInfoPtr_get_FrameCount_Public_get_Int32_0;

		// Token: 0x04005F7F RID: 24447
		private static readonly IntPtr NativeMethodInfoPtr_OnEnable_Public_Void_0;

		// Token: 0x04005F80 RID: 24448
		private static readonly IntPtr NativeMethodInfoPtr_SizeInBytes_Public_Int32_0;

		// Token: 0x04005F81 RID: 24449
		private static readonly IntPtr NativeMethodInfoPtr_Clear_Public_Void_0;

		// Token: 0x04005F82 RID: 24450
		private static readonly IntPtr NativeMethodInfoPtr_GetBaseFrame_Private_Int32_Single_0;

		// Token: 0x04005F83 RID: 24451
		private static readonly IntPtr NativeMethodInfoPtr_AddFrame_Public_Void_Frame_0;

		// Token: 0x04005F84 RID: 24452
		private static readonly IntPtr NativeMethodInfoPtr_GetFrame_Public_Void_Single_Boolean_byref_Frame_0;

		// Token: 0x04005F85 RID: 24453
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

		// Token: 0x020004DB RID: 1243
		public class UncompressedFrame : Il2CppSystem.Object
		{
			// Token: 0x06008F5A RID: 36698 RVA: 0x0024DF18 File Offset: 0x0024C118
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 610985, XrefRangeEnd = 611141, 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: 0x06008F5B RID: 36699 RVA: 0x0024DF64 File Offset: 0x0024C164
			// 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, 100674400);
			}

			// Token: 0x06008F5C RID: 36700 RVA: 0x0000A688 File Offset: 0x00008888
			public UncompressedFrame(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x170030AB RID: 12459
			// (get) Token: 0x06008F5D RID: 36701 RVA: 0x0024DFCC File Offset: 0x0024C1CC
			// (set) Token: 0x06008F5E RID: 36702 RVA: 0x0024E000 File Offset: 0x0024C200
			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: 0x170030AC RID: 12460
			// (get) Token: 0x06008F5F RID: 36703 RVA: 0x0024E028 File Offset: 0x0024C228
			// (set) Token: 0x06008F60 RID: 36704 RVA: 0x0024E05C File Offset: 0x0024C25C
			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: 0x04005F86 RID: 24454
			private static readonly IntPtr NativeFieldInfoPtr_indices;

			// Token: 0x04005F87 RID: 24455
			private static readonly IntPtr NativeFieldInfoPtr_positions;

			// Token: 0x04005F88 RID: 24456
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;
		}

		// Token: 0x020004DC RID: 1244
		[Serializable]
		public class Frame : Il2CppSystem.Object
		{
			// Token: 0x06008F61 RID: 36705 RVA: 0x0024E084 File Offset: 0x0024C284
			[CallerCount(2)]
			[CachedScanResults(RefRangeStart = 611156, RefRangeEnd = 611158, XrefRangeStart = 611141, XrefRangeEnd = 611156, 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: 0x06008F62 RID: 36706 RVA: 0x0024E0D0 File Offset: 0x0024C2D0
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 611158, XrefRangeEnd = 611165, 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: 0x06008F63 RID: 36707 RVA: 0x0024E114 File Offset: 0x0024C314
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 611167, RefRangeEnd = 611168, XrefRangeStart = 611165, XrefRangeEnd = 611167, 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: 0x06008F64 RID: 36708 RVA: 0x0024E164 File Offset: 0x0024C364
			[CallerCount(0)]
			[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 611168, XrefRangeEnd = 611201, 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: 0x06008F65 RID: 36709 RVA: 0x0024E214 File Offset: 0x0024C414
			// 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, 100674401);
				ObiParticleCache.Frame.NativeMethodInfoPtr_Clear_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr, 100674402);
				ObiParticleCache.Frame.NativeMethodInfoPtr_SizeInBytes_Public_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr, 100674403);
				ObiParticleCache.Frame.NativeMethodInfoPtr_Lerp_Public_Static_Void_Frame_Frame_byref_Frame_Single_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<ObiParticleCache.Frame>.NativeClassPtr, 100674404);
			}

			// Token: 0x06008F66 RID: 36710 RVA: 0x0000A688 File Offset: 0x00008888
			public Frame(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x170030AD RID: 12461
			// (get) Token: 0x06008F67 RID: 36711 RVA: 0x0024E2CC File Offset: 0x0024C4CC
			// (set) Token: 0x06008F68 RID: 36712 RVA: 0x0024E2F4 File Offset: 0x0024C4F4
			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: 0x170030AE RID: 12462
			// (get) Token: 0x06008F69 RID: 36713 RVA: 0x0024E318 File Offset: 0x0024C518
			// (set) Token: 0x06008F6A RID: 36714 RVA: 0x0024E34C File Offset: 0x0024C54C
			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: 0x170030AF RID: 12463
			// (get) Token: 0x06008F6B RID: 36715 RVA: 0x0024E374 File Offset: 0x0024C574
			// (set) Token: 0x06008F6C RID: 36716 RVA: 0x0024E3A8 File Offset: 0x0024C5A8
			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: 0x04005F89 RID: 24457
			private static readonly IntPtr NativeFieldInfoPtr_time;

			// Token: 0x04005F8A RID: 24458
			private static readonly IntPtr NativeFieldInfoPtr_positions;

			// Token: 0x04005F8B RID: 24459
			private static readonly IntPtr NativeFieldInfoPtr_indices;

			// Token: 0x04005F8C RID: 24460
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_0;

			// Token: 0x04005F8D RID: 24461
			private static readonly IntPtr NativeMethodInfoPtr_Clear_Public_Void_0;

			// Token: 0x04005F8E RID: 24462
			private static readonly IntPtr NativeMethodInfoPtr_SizeInBytes_Public_Int32_0;

			// Token: 0x04005F8F RID: 24463
			private static readonly IntPtr NativeMethodInfoPtr_Lerp_Public_Static_Void_Frame_Frame_byref_Frame_Single_0;
		}
	}
}
