using System;
using Il2CppInterop.Common.Attributes;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using UnityEngine;

namespace XftWeapon
{
	// Token: 0x0200038F RID: 911
	public class VertexPool : Il2CppSystem.Object
	{
		// Token: 0x170027A2 RID: 10146
		// (get) Token: 0x06007375 RID: 29557 RVA: 0x001D6B38 File Offset: 0x001D4D38
		public unsafe Mesh MyMesh
		{
			[CallerCount(8)]
			[CachedScanResults(RefRangeStart = 587323, RefRangeEnd = 587331, XrefRangeStart = 587314, XrefRangeEnd = 587323, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			get
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.NativeMethodInfoPtr_get_MyMesh_Public_get_Mesh_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
				IntPtr intPtr3 = intPtr;
				return (intPtr3 != 0) ? new Mesh(intPtr3) : null;
			}
		}

		// Token: 0x06007376 RID: 29558 RVA: 0x001D6B90 File Offset: 0x001D4D90
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 587331, XrefRangeEnd = 587334, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void RecalculateBounds()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.NativeMethodInfoPtr_RecalculateBounds_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007377 RID: 29559 RVA: 0x001D6BD4 File Offset: 0x001D4DD4
		[CallerCount(5)]
		[CachedScanResults(RefRangeStart = 587340, RefRangeEnd = 587345, XrefRangeStart = 587334, XrefRangeEnd = 587340, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void SetMeshObjectActive(bool flag)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			checked
			{
				IntPtr* ptr = stackalloc IntPtr[unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref flag;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.NativeMethodInfoPtr_SetMeshObjectActive_Public_Void_Boolean_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}
		}

		// Token: 0x06007378 RID: 29560 RVA: 0x001D6C28 File Offset: 0x001D4E28
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 587400, RefRangeEnd = 587401, XrefRangeStart = 587345, XrefRangeEnd = 587400, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void CreateMeshObj(XWeaponTrail owner, Material material)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(owner);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(material);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.NativeMethodInfoPtr_CreateMeshObj_Private_Void_XWeaponTrail_Material_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x06007379 RID: 29561 RVA: 0x001D6C9C File Offset: 0x001D4E9C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 587409, RefRangeEnd = 587410, XrefRangeStart = 587401, XrefRangeEnd = 587409, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void Destroy()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.NativeMethodInfoPtr_Destroy_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600737A RID: 29562 RVA: 0x001D6CE0 File Offset: 0x001D4EE0
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 587436, RefRangeEnd = 587438, XrefRangeStart = 587410, XrefRangeEnd = 587436, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe VertexPool(Material material, XWeaponTrail owner)
			: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VertexPool>.NativeClassPtr))
		{
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = IL2CPP.Il2CppObjectBaseToPtr(material);
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(owner);
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.NativeMethodInfoPtr__ctor_Public_Void_Material_XWeaponTrail_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600737B RID: 29563 RVA: 0x001D6D5C File Offset: 0x001D4F5C
		[CallerCount(2)]
		[CachedScanResults(RefRangeStart = 587443, RefRangeEnd = 587445, XrefRangeStart = 587438, XrefRangeEnd = 587443, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe VertexPool.VertexSegment GetVertices(int vcount, int icount)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref vcount;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref icount;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.NativeMethodInfoPtr_GetVertices_Public_VertexSegment_Int32_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			IntPtr intPtr3 = intPtr;
			return (intPtr3 != 0) ? new VertexPool.VertexSegment(intPtr3) : null;
		}

		// Token: 0x0600737C RID: 29564 RVA: 0x001D6DD8 File Offset: 0x001D4FD8
		[CallerCount(0)]
		[CachedScanResults(RefRangeStart = 0, RefRangeEnd = 0, XrefRangeStart = 587445, XrefRangeEnd = 587461, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void InitArrays()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.NativeMethodInfoPtr_InitArrays_Protected_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600737D RID: 29565 RVA: 0x001D6E1C File Offset: 0x001D501C
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 587481, RefRangeEnd = 587482, XrefRangeStart = 587461, XrefRangeEnd = 587481, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void EnlargeArrays(int count, int icount)
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr;
			checked
			{
				ptr = stackalloc IntPtr[unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)];
				*ptr = ref count;
			}
			ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref icount;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.NativeMethodInfoPtr_EnlargeArrays_Public_Void_Int32_Int32_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600737E RID: 29566 RVA: 0x001D6E84 File Offset: 0x001D5084
		[CallerCount(1)]
		[CachedScanResults(RefRangeStart = 587503, RefRangeEnd = 587504, XrefRangeStart = 587482, XrefRangeEnd = 587503, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
		public unsafe void LateUpdate()
		{
			IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
			IntPtr* ptr = null;
			IntPtr intPtr2;
			IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.NativeMethodInfoPtr_LateUpdate_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
			Il2CppException.RaiseExceptionIfNecessary(intPtr2);
		}

		// Token: 0x0600737F RID: 29567 RVA: 0x001D6EC8 File Offset: 0x001D50C8
		// Note: this type is marked as 'beforefieldinit'.
		static VertexPool()
		{
			Il2CppClassPointerStore<VertexPool>.NativeClassPtr = IL2CPP.GetIl2CppClass("Assembly-CSharp.dll", "XftWeapon", "VertexPool");
			IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VertexPool>.NativeClassPtr);
			VertexPool.NativeFieldInfoPtr_Vertices = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "Vertices");
			VertexPool.NativeFieldInfoPtr_Indices = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "Indices");
			VertexPool.NativeFieldInfoPtr_UVs = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "UVs");
			VertexPool.NativeFieldInfoPtr_Colors = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "Colors");
			VertexPool.NativeFieldInfoPtr_IndiceChanged = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "IndiceChanged");
			VertexPool.NativeFieldInfoPtr_ColorChanged = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "ColorChanged");
			VertexPool.NativeFieldInfoPtr_UVChanged = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "UVChanged");
			VertexPool.NativeFieldInfoPtr_VertChanged = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "VertChanged");
			VertexPool.NativeFieldInfoPtr_UV2Changed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "UV2Changed");
			VertexPool.NativeFieldInfoPtr_VertexTotal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "VertexTotal");
			VertexPool.NativeFieldInfoPtr_VertexUsed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "VertexUsed");
			VertexPool.NativeFieldInfoPtr_IndexTotal = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "IndexTotal");
			VertexPool.NativeFieldInfoPtr_IndexUsed = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "IndexUsed");
			VertexPool.NativeFieldInfoPtr_FirstUpdate = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "FirstUpdate");
			VertexPool.NativeFieldInfoPtr_VertCountChanged = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "VertCountChanged");
			VertexPool.NativeFieldInfoPtr_BlockSize = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "BlockSize");
			VertexPool.NativeFieldInfoPtr_BoundsScheduleTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "BoundsScheduleTime");
			VertexPool.NativeFieldInfoPtr_ElapsedTime = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "ElapsedTime");
			VertexPool.NativeFieldInfoPtr__owner = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "_owner");
			VertexPool.NativeFieldInfoPtr__meshFilter = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "_meshFilter");
			VertexPool.NativeFieldInfoPtr__mesh2d = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "_mesh2d");
			VertexPool.NativeFieldInfoPtr__material = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "_material");
			VertexPool.NativeMethodInfoPtr_get_MyMesh_Public_get_Mesh_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, 100671989);
			VertexPool.NativeMethodInfoPtr_RecalculateBounds_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, 100671990);
			VertexPool.NativeMethodInfoPtr_SetMeshObjectActive_Public_Void_Boolean_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, 100671991);
			VertexPool.NativeMethodInfoPtr_CreateMeshObj_Private_Void_XWeaponTrail_Material_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, 100671992);
			VertexPool.NativeMethodInfoPtr_Destroy_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, 100671993);
			VertexPool.NativeMethodInfoPtr__ctor_Public_Void_Material_XWeaponTrail_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, 100671994);
			VertexPool.NativeMethodInfoPtr_GetVertices_Public_VertexSegment_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, 100671995);
			VertexPool.NativeMethodInfoPtr_InitArrays_Protected_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, 100671996);
			VertexPool.NativeMethodInfoPtr_EnlargeArrays_Public_Void_Int32_Int32_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, 100671997);
			VertexPool.NativeMethodInfoPtr_LateUpdate_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, 100671998);
		}

		// Token: 0x06007380 RID: 29568 RVA: 0x0000A688 File Offset: 0x00008888
		public VertexPool(IntPtr pointer)
			: base(pointer)
		{
		}

		// Token: 0x1700278C RID: 10124
		// (get) Token: 0x06007381 RID: 29569 RVA: 0x001D7178 File Offset: 0x001D5378
		// (set) Token: 0x06007382 RID: 29570 RVA: 0x001D71AC File Offset: 0x001D53AC
		public unsafe Il2CppStructArray<Vector3> Vertices
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_Vertices);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<Vector3>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_Vertices), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x1700278D RID: 10125
		// (get) Token: 0x06007383 RID: 29571 RVA: 0x001D71D4 File Offset: 0x001D53D4
		// (set) Token: 0x06007384 RID: 29572 RVA: 0x001D7208 File Offset: 0x001D5408
		public unsafe Il2CppStructArray<int> Indices
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_Indices);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<int>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_Indices), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x1700278E RID: 10126
		// (get) Token: 0x06007385 RID: 29573 RVA: 0x001D7230 File Offset: 0x001D5430
		// (set) Token: 0x06007386 RID: 29574 RVA: 0x001D7264 File Offset: 0x001D5464
		public unsafe Il2CppStructArray<Vector2> UVs
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_UVs);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<Vector2>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_UVs), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x1700278F RID: 10127
		// (get) Token: 0x06007387 RID: 29575 RVA: 0x001D728C File Offset: 0x001D548C
		// (set) Token: 0x06007388 RID: 29576 RVA: 0x001D72C0 File Offset: 0x001D54C0
		public unsafe Il2CppStructArray<Color> Colors
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_Colors);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Il2CppStructArray<Color>(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_Colors), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x17002790 RID: 10128
		// (get) Token: 0x06007389 RID: 29577 RVA: 0x001D72E8 File Offset: 0x001D54E8
		// (set) Token: 0x0600738A RID: 29578 RVA: 0x001D7310 File Offset: 0x001D5510
		public unsafe bool IndiceChanged
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_IndiceChanged);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_IndiceChanged)) = value;
			}
		}

		// Token: 0x17002791 RID: 10129
		// (get) Token: 0x0600738B RID: 29579 RVA: 0x001D7334 File Offset: 0x001D5534
		// (set) Token: 0x0600738C RID: 29580 RVA: 0x001D735C File Offset: 0x001D555C
		public unsafe bool ColorChanged
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_ColorChanged);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_ColorChanged)) = value;
			}
		}

		// Token: 0x17002792 RID: 10130
		// (get) Token: 0x0600738D RID: 29581 RVA: 0x001D7380 File Offset: 0x001D5580
		// (set) Token: 0x0600738E RID: 29582 RVA: 0x001D73A8 File Offset: 0x001D55A8
		public unsafe bool UVChanged
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_UVChanged);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_UVChanged)) = value;
			}
		}

		// Token: 0x17002793 RID: 10131
		// (get) Token: 0x0600738F RID: 29583 RVA: 0x001D73CC File Offset: 0x001D55CC
		// (set) Token: 0x06007390 RID: 29584 RVA: 0x001D73F4 File Offset: 0x001D55F4
		public unsafe bool VertChanged
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_VertChanged);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_VertChanged)) = value;
			}
		}

		// Token: 0x17002794 RID: 10132
		// (get) Token: 0x06007391 RID: 29585 RVA: 0x001D7418 File Offset: 0x001D5618
		// (set) Token: 0x06007392 RID: 29586 RVA: 0x001D7440 File Offset: 0x001D5640
		public unsafe bool UV2Changed
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_UV2Changed);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_UV2Changed)) = value;
			}
		}

		// Token: 0x17002795 RID: 10133
		// (get) Token: 0x06007393 RID: 29587 RVA: 0x001D7464 File Offset: 0x001D5664
		// (set) Token: 0x06007394 RID: 29588 RVA: 0x001D748C File Offset: 0x001D568C
		public unsafe int VertexTotal
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_VertexTotal);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_VertexTotal)) = value;
			}
		}

		// Token: 0x17002796 RID: 10134
		// (get) Token: 0x06007395 RID: 29589 RVA: 0x001D74B0 File Offset: 0x001D56B0
		// (set) Token: 0x06007396 RID: 29590 RVA: 0x001D74D8 File Offset: 0x001D56D8
		public unsafe int VertexUsed
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_VertexUsed);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_VertexUsed)) = value;
			}
		}

		// Token: 0x17002797 RID: 10135
		// (get) Token: 0x06007397 RID: 29591 RVA: 0x001D74FC File Offset: 0x001D56FC
		// (set) Token: 0x06007398 RID: 29592 RVA: 0x001D7524 File Offset: 0x001D5724
		public unsafe int IndexTotal
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_IndexTotal);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_IndexTotal)) = value;
			}
		}

		// Token: 0x17002798 RID: 10136
		// (get) Token: 0x06007399 RID: 29593 RVA: 0x001D7548 File Offset: 0x001D5748
		// (set) Token: 0x0600739A RID: 29594 RVA: 0x001D7570 File Offset: 0x001D5770
		public unsafe int IndexUsed
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_IndexUsed);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_IndexUsed)) = value;
			}
		}

		// Token: 0x17002799 RID: 10137
		// (get) Token: 0x0600739B RID: 29595 RVA: 0x001D7594 File Offset: 0x001D5794
		// (set) Token: 0x0600739C RID: 29596 RVA: 0x001D75BC File Offset: 0x001D57BC
		public unsafe bool FirstUpdate
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_FirstUpdate);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_FirstUpdate)) = value;
			}
		}

		// Token: 0x1700279A RID: 10138
		// (get) Token: 0x0600739D RID: 29597 RVA: 0x001D75E0 File Offset: 0x001D57E0
		// (set) Token: 0x0600739E RID: 29598 RVA: 0x001D7608 File Offset: 0x001D5808
		public unsafe bool VertCountChanged
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_VertCountChanged);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_VertCountChanged)) = value;
			}
		}

		// Token: 0x1700279B RID: 10139
		// (get) Token: 0x0600739F RID: 29599 RVA: 0x001D762C File Offset: 0x001D582C
		// (set) Token: 0x060073A0 RID: 29600 RVA: 0x001D764A File Offset: 0x001D584A
		public unsafe static int BlockSize
		{
			get
			{
				int num;
				IL2CPP.il2cpp_field_static_get_value(VertexPool.NativeFieldInfoPtr_BlockSize, (void*)(&num));
				return num;
			}
			set
			{
				IL2CPP.il2cpp_field_static_set_value(VertexPool.NativeFieldInfoPtr_BlockSize, (void*)(&value));
			}
		}

		// Token: 0x1700279C RID: 10140
		// (get) Token: 0x060073A1 RID: 29601 RVA: 0x001D765C File Offset: 0x001D585C
		// (set) Token: 0x060073A2 RID: 29602 RVA: 0x001D7684 File Offset: 0x001D5884
		public unsafe float BoundsScheduleTime
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_BoundsScheduleTime);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_BoundsScheduleTime)) = value;
			}
		}

		// Token: 0x1700279D RID: 10141
		// (get) Token: 0x060073A3 RID: 29603 RVA: 0x001D76A8 File Offset: 0x001D58A8
		// (set) Token: 0x060073A4 RID: 29604 RVA: 0x001D76D0 File Offset: 0x001D58D0
		public unsafe float ElapsedTime
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_ElapsedTime);
				return *intPtr;
			}
			set
			{
				*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr_ElapsedTime)) = value;
			}
		}

		// Token: 0x1700279E RID: 10142
		// (get) Token: 0x060073A5 RID: 29605 RVA: 0x001D76F4 File Offset: 0x001D58F4
		// (set) Token: 0x060073A6 RID: 29606 RVA: 0x001D7728 File Offset: 0x001D5928
		public unsafe XWeaponTrail _owner
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr__owner);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new XWeaponTrail(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr__owner), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x1700279F RID: 10143
		// (get) Token: 0x060073A7 RID: 29607 RVA: 0x001D7750 File Offset: 0x001D5950
		// (set) Token: 0x060073A8 RID: 29608 RVA: 0x001D7784 File Offset: 0x001D5984
		public unsafe MeshFilter _meshFilter
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr__meshFilter);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new MeshFilter(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr__meshFilter), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x170027A0 RID: 10144
		// (get) Token: 0x060073A9 RID: 29609 RVA: 0x001D77AC File Offset: 0x001D59AC
		// (set) Token: 0x060073AA RID: 29610 RVA: 0x001D77E0 File Offset: 0x001D59E0
		public unsafe Mesh _mesh2d
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr__mesh2d);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Mesh(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr__mesh2d), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x170027A1 RID: 10145
		// (get) Token: 0x060073AB RID: 29611 RVA: 0x001D7808 File Offset: 0x001D5A08
		// (set) Token: 0x060073AC RID: 29612 RVA: 0x001D783C File Offset: 0x001D5A3C
		public unsafe Material _material
		{
			get
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr__material);
				IntPtr intPtr2 = *intPtr;
				return (intPtr2 != 0) ? new Material(intPtr2) : null;
			}
			set
			{
				IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.NativeFieldInfoPtr__material), IL2CPP.Il2CppObjectBaseToPtr(value));
			}
		}

		// Token: 0x04004D7F RID: 19839
		private static readonly IntPtr NativeFieldInfoPtr_Vertices;

		// Token: 0x04004D80 RID: 19840
		private static readonly IntPtr NativeFieldInfoPtr_Indices;

		// Token: 0x04004D81 RID: 19841
		private static readonly IntPtr NativeFieldInfoPtr_UVs;

		// Token: 0x04004D82 RID: 19842
		private static readonly IntPtr NativeFieldInfoPtr_Colors;

		// Token: 0x04004D83 RID: 19843
		private static readonly IntPtr NativeFieldInfoPtr_IndiceChanged;

		// Token: 0x04004D84 RID: 19844
		private static readonly IntPtr NativeFieldInfoPtr_ColorChanged;

		// Token: 0x04004D85 RID: 19845
		private static readonly IntPtr NativeFieldInfoPtr_UVChanged;

		// Token: 0x04004D86 RID: 19846
		private static readonly IntPtr NativeFieldInfoPtr_VertChanged;

		// Token: 0x04004D87 RID: 19847
		private static readonly IntPtr NativeFieldInfoPtr_UV2Changed;

		// Token: 0x04004D88 RID: 19848
		private static readonly IntPtr NativeFieldInfoPtr_VertexTotal;

		// Token: 0x04004D89 RID: 19849
		private static readonly IntPtr NativeFieldInfoPtr_VertexUsed;

		// Token: 0x04004D8A RID: 19850
		private static readonly IntPtr NativeFieldInfoPtr_IndexTotal;

		// Token: 0x04004D8B RID: 19851
		private static readonly IntPtr NativeFieldInfoPtr_IndexUsed;

		// Token: 0x04004D8C RID: 19852
		private static readonly IntPtr NativeFieldInfoPtr_FirstUpdate;

		// Token: 0x04004D8D RID: 19853
		private static readonly IntPtr NativeFieldInfoPtr_VertCountChanged;

		// Token: 0x04004D8E RID: 19854
		private static readonly IntPtr NativeFieldInfoPtr_BlockSize;

		// Token: 0x04004D8F RID: 19855
		private static readonly IntPtr NativeFieldInfoPtr_BoundsScheduleTime;

		// Token: 0x04004D90 RID: 19856
		private static readonly IntPtr NativeFieldInfoPtr_ElapsedTime;

		// Token: 0x04004D91 RID: 19857
		private static readonly IntPtr NativeFieldInfoPtr__owner;

		// Token: 0x04004D92 RID: 19858
		private static readonly IntPtr NativeFieldInfoPtr__meshFilter;

		// Token: 0x04004D93 RID: 19859
		private static readonly IntPtr NativeFieldInfoPtr__mesh2d;

		// Token: 0x04004D94 RID: 19860
		private static readonly IntPtr NativeFieldInfoPtr__material;

		// Token: 0x04004D95 RID: 19861
		private static readonly IntPtr NativeMethodInfoPtr_get_MyMesh_Public_get_Mesh_0;

		// Token: 0x04004D96 RID: 19862
		private static readonly IntPtr NativeMethodInfoPtr_RecalculateBounds_Public_Void_0;

		// Token: 0x04004D97 RID: 19863
		private static readonly IntPtr NativeMethodInfoPtr_SetMeshObjectActive_Public_Void_Boolean_0;

		// Token: 0x04004D98 RID: 19864
		private static readonly IntPtr NativeMethodInfoPtr_CreateMeshObj_Private_Void_XWeaponTrail_Material_0;

		// Token: 0x04004D99 RID: 19865
		private static readonly IntPtr NativeMethodInfoPtr_Destroy_Public_Void_0;

		// Token: 0x04004D9A RID: 19866
		private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Material_XWeaponTrail_0;

		// Token: 0x04004D9B RID: 19867
		private static readonly IntPtr NativeMethodInfoPtr_GetVertices_Public_VertexSegment_Int32_Int32_0;

		// Token: 0x04004D9C RID: 19868
		private static readonly IntPtr NativeMethodInfoPtr_InitArrays_Protected_Void_0;

		// Token: 0x04004D9D RID: 19869
		private static readonly IntPtr NativeMethodInfoPtr_EnlargeArrays_Public_Void_Int32_Int32_0;

		// Token: 0x04004D9E RID: 19870
		private static readonly IntPtr NativeMethodInfoPtr_LateUpdate_Public_Void_0;

		// Token: 0x02000390 RID: 912
		public class VertexSegment : Il2CppSystem.Object
		{
			// Token: 0x060073AD RID: 29613 RVA: 0x001D7864 File Offset: 0x001D5A64
			[CallerCount(1)]
			[CachedScanResults(RefRangeStart = 587313, RefRangeEnd = 587314, XrefRangeStart = 587307, XrefRangeEnd = 587313, MetadataInitTokenRva = 0L, MetadataInitFlagRva = 0L)]
			public unsafe VertexSegment(int start, int count, int istart, int icount, VertexPool pool)
				: this(IL2CPP.il2cpp_object_new(Il2CppClassPointerStore<VertexPool.VertexSegment>.NativeClassPtr))
			{
				IntPtr* ptr;
				checked
				{
					ptr = stackalloc IntPtr[unchecked((UIntPtr)5) * (UIntPtr)sizeof(IntPtr)];
					*ptr = ref start;
				}
				ptr[checked(unchecked((UIntPtr)1) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref count;
				ptr[checked(unchecked((UIntPtr)2) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref istart;
				ptr[checked(unchecked((UIntPtr)3) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = ref icount;
				ptr[checked(unchecked((UIntPtr)4) * (UIntPtr)sizeof(IntPtr)) / (UIntPtr)sizeof(IntPtr)] = IL2CPP.Il2CppObjectBaseToPtr(pool);
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.VertexSegment.NativeMethodInfoPtr__ctor_Public_Void_Int32_Int32_Int32_Int32_VertexPool_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060073AE RID: 29614 RVA: 0x001D7914 File Offset: 0x001D5B14
			[CallerCount(0)]
			public unsafe void ClearIndices()
			{
				IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
				IntPtr* ptr = null;
				IntPtr intPtr2;
				IntPtr intPtr = IL2CPP.il2cpp_runtime_invoke(VertexPool.VertexSegment.NativeMethodInfoPtr_ClearIndices_Public_Void_0, IL2CPP.Il2CppObjectBaseToPtrNotNull(this), (void**)ptr, ref intPtr2);
				Il2CppException.RaiseExceptionIfNecessary(intPtr2);
			}

			// Token: 0x060073AF RID: 29615 RVA: 0x001D7958 File Offset: 0x001D5B58
			// Note: this type is marked as 'beforefieldinit'.
			static VertexSegment()
			{
				Il2CppClassPointerStore<VertexPool.VertexSegment>.NativeClassPtr = IL2CPP.GetIl2CppNestedType(Il2CppClassPointerStore<VertexPool>.NativeClassPtr, "VertexSegment");
				IL2CPP.il2cpp_runtime_class_init(Il2CppClassPointerStore<VertexPool.VertexSegment>.NativeClassPtr);
				VertexPool.VertexSegment.NativeFieldInfoPtr_VertStart = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool.VertexSegment>.NativeClassPtr, "VertStart");
				VertexPool.VertexSegment.NativeFieldInfoPtr_IndexStart = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool.VertexSegment>.NativeClassPtr, "IndexStart");
				VertexPool.VertexSegment.NativeFieldInfoPtr_VertCount = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool.VertexSegment>.NativeClassPtr, "VertCount");
				VertexPool.VertexSegment.NativeFieldInfoPtr_IndexCount = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool.VertexSegment>.NativeClassPtr, "IndexCount");
				VertexPool.VertexSegment.NativeFieldInfoPtr_Pool = IL2CPP.GetIl2CppField(Il2CppClassPointerStore<VertexPool.VertexSegment>.NativeClassPtr, "Pool");
				VertexPool.VertexSegment.NativeMethodInfoPtr__ctor_Public_Void_Int32_Int32_Int32_Int32_VertexPool_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool.VertexSegment>.NativeClassPtr, 100671999);
				VertexPool.VertexSegment.NativeMethodInfoPtr_ClearIndices_Public_Void_0 = IL2CPP.GetIl2CppMethodByToken(Il2CppClassPointerStore<VertexPool.VertexSegment>.NativeClassPtr, 100672000);
			}

			// Token: 0x060073B0 RID: 29616 RVA: 0x0000A688 File Offset: 0x00008888
			public VertexSegment(IntPtr pointer)
				: base(pointer)
			{
			}

			// Token: 0x170027A3 RID: 10147
			// (get) Token: 0x060073B1 RID: 29617 RVA: 0x001D7A10 File Offset: 0x001D5C10
			// (set) Token: 0x060073B2 RID: 29618 RVA: 0x001D7A38 File Offset: 0x001D5C38
			public unsafe int VertStart
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.VertexSegment.NativeFieldInfoPtr_VertStart);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.VertexSegment.NativeFieldInfoPtr_VertStart)) = value;
				}
			}

			// Token: 0x170027A4 RID: 10148
			// (get) Token: 0x060073B3 RID: 29619 RVA: 0x001D7A5C File Offset: 0x001D5C5C
			// (set) Token: 0x060073B4 RID: 29620 RVA: 0x001D7A84 File Offset: 0x001D5C84
			public unsafe int IndexStart
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.VertexSegment.NativeFieldInfoPtr_IndexStart);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.VertexSegment.NativeFieldInfoPtr_IndexStart)) = value;
				}
			}

			// Token: 0x170027A5 RID: 10149
			// (get) Token: 0x060073B5 RID: 29621 RVA: 0x001D7AA8 File Offset: 0x001D5CA8
			// (set) Token: 0x060073B6 RID: 29622 RVA: 0x001D7AD0 File Offset: 0x001D5CD0
			public unsafe int VertCount
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.VertexSegment.NativeFieldInfoPtr_VertCount);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.VertexSegment.NativeFieldInfoPtr_VertCount)) = value;
				}
			}

			// Token: 0x170027A6 RID: 10150
			// (get) Token: 0x060073B7 RID: 29623 RVA: 0x001D7AF4 File Offset: 0x001D5CF4
			// (set) Token: 0x060073B8 RID: 29624 RVA: 0x001D7B1C File Offset: 0x001D5D1C
			public unsafe int IndexCount
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.VertexSegment.NativeFieldInfoPtr_IndexCount);
					return *intPtr;
				}
				set
				{
					*(IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.VertexSegment.NativeFieldInfoPtr_IndexCount)) = value;
				}
			}

			// Token: 0x170027A7 RID: 10151
			// (get) Token: 0x060073B9 RID: 29625 RVA: 0x001D7B40 File Offset: 0x001D5D40
			// (set) Token: 0x060073BA RID: 29626 RVA: 0x001D7B74 File Offset: 0x001D5D74
			public unsafe VertexPool Pool
			{
				get
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this) + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.VertexSegment.NativeFieldInfoPtr_Pool);
					IntPtr intPtr2 = *intPtr;
					return (intPtr2 != 0) ? new VertexPool(intPtr2) : null;
				}
				set
				{
					IntPtr intPtr = IL2CPP.Il2CppObjectBaseToPtrNotNull(this);
					IL2CPP.il2cpp_gc_wbarrier_set_field(intPtr, intPtr + (IntPtr)IL2CPP.il2cpp_field_get_offset(VertexPool.VertexSegment.NativeFieldInfoPtr_Pool), IL2CPP.Il2CppObjectBaseToPtr(value));
				}
			}

			// Token: 0x04004D9F RID: 19871
			private static readonly IntPtr NativeFieldInfoPtr_VertStart;

			// Token: 0x04004DA0 RID: 19872
			private static readonly IntPtr NativeFieldInfoPtr_IndexStart;

			// Token: 0x04004DA1 RID: 19873
			private static readonly IntPtr NativeFieldInfoPtr_VertCount;

			// Token: 0x04004DA2 RID: 19874
			private static readonly IntPtr NativeFieldInfoPtr_IndexCount;

			// Token: 0x04004DA3 RID: 19875
			private static readonly IntPtr NativeFieldInfoPtr_Pool;

			// Token: 0x04004DA4 RID: 19876
			private static readonly IntPtr NativeMethodInfoPtr__ctor_Public_Void_Int32_Int32_Int32_Int32_VertexPool_0;

			// Token: 0x04004DA5 RID: 19877
			private static readonly IntPtr NativeMethodInfoPtr_ClearIndices_Public_Void_0;
		}
	}
}
