using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using AOT;
using Drawing;
using Drawing.Text;
using Microsoft.CodeAnalysis;
using Unity.Burst;
using Unity.Burst.CompilerServices;
using Unity.Burst.Intrinsics;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Jobs;
using Unity.Jobs.LowLevel.Unsafe;
using Unity.Mathematics;
using Unity.Profiling;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: StaticTypeReinit(typeof(CommandBuilder.JobWireMesh.WireMesh_000000FE$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(CommandBuilder.JobWireMesh.Execute_000000FF$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(DrawingData.BuilderData.AnyBuffersWrittenTo_000002F4$BurstDirectCall))]
[assembly: StaticTypeReinit(typeof(DrawingData.BuilderData.ResetAllBuffers_000002F5$BurstDirectCall))]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
}
[CompilerGenerated]
[EditorBrowsable(EditorBrowsableState.Never)]
[GeneratedCode("Unity.MonoScriptGenerator.MonoScriptInfoGenerator", null)]
internal class UnitySourceGeneratedAssemblyMonoScriptTypes_v1
{
	private struct MonoScriptData
	{
		public byte[] FilePathsData;

		public byte[] TypesData;

		public int TotalTypes;

		public int TotalFiles;

		public bool IsEditorOnly;
	}

	[MethodImpl(MethodImplOptions.AggressiveInlining)]
	private static MonoScriptData Get()
	{
		return new MonoScriptData
		{
			FilePathsData = new byte[728]
			{
				0, 0, 0, 22, 0, 0, 0, 40, 92, 65,
				115, 115, 101, 116, 115, 92, 69, 120, 116, 101,
				114, 110, 97, 108, 92, 65, 76, 73, 78, 69,
				92, 67, 111, 109, 109, 97, 110, 100, 66, 117,
				105, 108, 100, 101, 114, 46, 99, 115, 0, 0,
				0, 1, 0, 0, 0, 42, 92, 65, 115, 115,
				101, 116, 115, 92, 69, 120, 116, 101, 114, 110,
				97, 108, 92, 65, 76, 73, 78, 69, 92, 67,
				111, 109, 109, 97, 110, 100, 66, 117, 105, 108,
				100, 101, 114, 50, 68, 46, 99, 115, 0, 0,
				0, 1, 0, 0, 0, 52, 92, 65, 115, 115,
				101, 116, 115, 92, 69, 120, 116, 101, 114, 110,
				97, 108, 92, 65, 76, 73, 78, 69, 92, 67,
				111, 109, 109, 97, 110, 100, 66, 117, 105, 108,
				100, 101, 114, 50, 68, 69, 120, 116, 101, 110,
				115, 105, 111, 110, 115, 46, 99, 115, 0, 0,
				0, 1, 0, 0, 0, 50, 92, 65, 115, 115,
				101, 116, 115, 92, 69, 120, 116, 101, 114, 110,
				97, 108, 92, 65, 76, 73, 78, 69, 92, 67,
				111, 109, 109, 97, 110, 100, 66, 117, 105, 108,
				100, 101, 114, 69, 120, 116, 101, 110, 115, 105,
				111, 110, 115, 46, 99, 115, 0, 0, 0, 1,
				0, 0, 0, 30, 92, 65, 115, 115, 101, 116,
				115, 92, 69, 120, 116, 101, 114, 110, 97, 108,
				92, 65, 76, 73, 78, 69, 92, 68, 114, 97,
				119, 46, 99, 115, 0, 0, 0, 19, 0, 0,
				0, 37, 92, 65, 115, 115, 101, 116, 115, 92,
				69, 120, 116, 101, 114, 110, 97, 108, 92, 65,
				76, 73, 78, 69, 92, 68, 114, 97, 119, 105,
				110, 103, 68, 97, 116, 97, 46, 99, 115, 0,
				0, 0, 4, 0, 0, 0, 40, 92, 65, 115,
				115, 101, 116, 115, 92, 69, 120, 116, 101, 114,
				110, 97, 108, 92, 65, 76, 73, 78, 69, 92,
				68, 114, 97, 119, 105, 110, 103, 77, 97, 110,
				97, 103, 101, 114, 46, 99, 115, 0, 0, 0,
				2, 0, 0, 0, 41, 92, 65, 115, 115, 101,
				116, 115, 92, 69, 120, 116, 101, 114, 110, 97,
				108, 92, 65, 76, 73, 78, 69, 92, 68, 114,
				97, 119, 105, 110, 103, 83, 101, 116, 116, 105,
				110, 103, 115, 46, 99, 115, 0, 0, 0, 1,
				0, 0, 0, 42, 92, 65, 115, 115, 101, 116,
				115, 92, 69, 120, 116, 101, 114, 110, 97, 108,
				92, 65, 76, 73, 78, 69, 92, 68, 114, 97,
				119, 105, 110, 103, 85, 116, 105, 108, 105, 116,
				105, 101, 115, 46, 99, 115, 0, 0, 0, 6,
				0, 0, 0, 41, 92, 65, 115, 115, 101, 116,
				115, 92, 69, 120, 116, 101, 114, 110, 97, 108,
				92, 65, 76, 73, 78, 69, 92, 71, 101, 111,
				109, 101, 116, 114, 121, 66, 117, 105, 108, 100,
				101, 114, 46, 99, 115, 0, 0, 0, 1, 0,
				0, 0, 45, 92, 65, 115, 115, 101, 116, 115,
				92, 69, 120, 116, 101, 114, 110, 97, 108, 92,
				65, 76, 73, 78, 69, 92, 77, 111, 110, 111,
				66, 101, 104, 97, 118, 105, 111, 117, 114, 71,
				105, 122, 109, 111, 115, 46, 99, 115, 0, 0,
				0, 5, 0, 0, 0, 33, 92, 65, 115, 115,
				101, 116, 115, 92, 69, 120, 116, 101, 114, 110,
				97, 108, 92, 65, 76, 73, 78, 69, 92, 80,
				97, 108, 101, 116, 116, 101, 46, 99, 115, 0,
				0, 0, 1, 0, 0, 0, 42, 92, 65, 115,
				115, 101, 116, 115, 92, 69, 120, 116, 101, 114,
				110, 97, 108, 92, 65, 76, 73, 78, 69, 92,
				80, 101, 114, 115, 105, 115, 116, 101, 110, 116,
				70, 105, 108, 116, 101, 114, 46, 99, 115, 0,
				0, 0, 4, 0, 0, 0, 33, 92, 65, 115,
				115, 101, 116, 115, 92, 69, 120, 116, 101, 114,
				110, 97, 108, 92, 65, 76, 73, 78, 69, 92,
				83, 68, 70, 70, 111, 110, 116, 46, 99, 115,
				0, 0, 0, 1, 0, 0, 0, 40, 92, 65,
				115, 115, 101, 116, 115, 92, 69, 120, 116, 101,
				114, 110, 97, 108, 92, 65, 76, 73, 78, 69,
				92, 83, 116, 114, 101, 97, 109, 83, 112, 108,
				105, 116, 116, 101, 114, 46, 99, 115
			},
			TypesData = new byte[2124]
			{
				0, 0, 0, 0, 22, 68, 114, 97, 119, 105,
				110, 103, 124, 76, 97, 98, 101, 108, 65, 108,
				105, 103, 110, 109, 101, 110, 116, 0, 0, 0,
				0, 30, 68, 114, 97, 119, 105, 110, 103, 124,
				67, 111, 109, 109, 97, 110, 100, 66, 117, 105,
				108, 100, 101, 114, 83, 97, 109, 112, 108, 101,
				114, 115, 1, 0, 0, 0, 22, 68, 114, 97,
				119, 105, 110, 103, 124, 67, 111, 109, 109, 97,
				110, 100, 66, 117, 105, 108, 100, 101, 114, 0,
				0, 0, 0, 21, 68, 114, 97, 119, 105, 110,
				103, 46, 124, 84, 114, 105, 97, 110, 103, 108,
				101, 68, 97, 116, 97, 0, 0, 0, 0, 17,
				68, 114, 97, 119, 105, 110, 103, 46, 124, 76,
				105, 110, 101, 68, 97, 116, 97, 0, 0, 0,
				0, 19, 68, 114, 97, 119, 105, 110, 103, 46,
				124, 76, 105, 110, 101, 68, 97, 116, 97, 86,
				51, 0, 0, 0, 0, 21, 68, 114, 97, 119,
				105, 110, 103, 46, 124, 67, 105, 114, 99, 108,
				101, 88, 90, 68, 97, 116, 97, 0, 0, 0,
				0, 19, 68, 114, 97, 119, 105, 110, 103, 46,
				124, 67, 105, 114, 99, 108, 101, 68, 97, 116,
				97, 0, 0, 0, 0, 19, 68, 114, 97, 119,
				105, 110, 103, 46, 124, 83, 112, 104, 101, 114,
				101, 68, 97, 116, 97, 0, 0, 0, 0, 16,
				68, 114, 97, 119, 105, 110, 103, 46, 124, 66,
				111, 120, 68, 97, 116, 97, 0, 0, 0, 0,
				18, 68, 114, 97, 119, 105, 110, 103, 46, 124,
				80, 108, 97, 110, 101, 68, 97, 116, 97, 0,
				0, 0, 0, 20, 68, 114, 97, 119, 105, 110,
				103, 46, 124, 80, 101, 114, 115, 105, 115, 116,
				68, 97, 116, 97, 0, 0, 0, 0, 22, 68,
				114, 97, 119, 105, 110, 103, 46, 124, 76, 105,
				110, 101, 87, 105, 100, 116, 104, 68, 97, 116,
				97, 0, 0, 0, 0, 17, 68, 114, 97, 119,
				105, 110, 103, 46, 124, 84, 101, 120, 116, 68,
				97, 116, 97, 0, 0, 0, 0, 19, 68, 114,
				97, 119, 105, 110, 103, 46, 124, 84, 101, 120,
				116, 68, 97, 116, 97, 51, 68, 0, 0, 0,
				0, 20, 68, 114, 97, 119, 105, 110, 103, 46,
				124, 83, 99, 111, 112, 101, 77, 97, 116, 114,
				105, 120, 0, 0, 0, 0, 19, 68, 114, 97,
				119, 105, 110, 103, 46, 124, 83, 99, 111, 112,
				101, 67, 111, 108, 111, 114, 0, 0, 0, 0,
				21, 68, 114, 97, 119, 105, 110, 103, 46, 124,
				83, 99, 111, 112, 101, 80, 101, 114, 115, 105,
				115, 116, 0, 0, 0, 0, 19, 68, 114, 97,
				119, 105, 110, 103, 46, 124, 83, 99, 111, 112,
				101, 69, 109, 112, 116, 121, 0, 0, 0, 0,
				23, 68, 114, 97, 119, 105, 110, 103, 46, 124,
				83, 99, 111, 112, 101, 76, 105, 110, 101, 87,
				105, 100, 116, 104, 0, 0, 0, 0, 27, 68,
				114, 97, 119, 105, 110, 103, 46, 124, 80, 111,
				108, 121, 108, 105, 110, 101, 87, 105, 116, 104,
				83, 121, 109, 98, 111, 108, 0, 0, 0, 0,
				20, 68, 114, 97, 119, 105, 110, 103, 46, 124,
				74, 111, 98, 87, 105, 114, 101, 77, 101, 115,
				104, 1, 0, 0, 0, 24, 68, 114, 97, 119,
				105, 110, 103, 124, 67, 111, 109, 109, 97, 110,
				100, 66, 117, 105, 108, 100, 101, 114, 50, 68,
				1, 0, 0, 0, 24, 68, 114, 97, 119, 105,
				110, 103, 124, 67, 111, 109, 109, 97, 110, 100,
				66, 117, 105, 108, 100, 101, 114, 50, 68, 1,
				0, 0, 0, 22, 68, 114, 97, 119, 105, 110,
				103, 124, 67, 111, 109, 109, 97, 110, 100, 66,
				117, 105, 108, 100, 101, 114, 0, 0, 0, 0,
				12, 68, 114, 97, 119, 105, 110, 103, 124, 68,
				114, 97, 119, 0, 0, 0, 0, 25, 68, 114,
				97, 119, 105, 110, 103, 124, 83, 104, 97, 114,
				101, 100, 68, 114, 97, 119, 105, 110, 103, 68,
				97, 116, 97, 0, 0, 0, 0, 38, 68, 114,
				97, 119, 105, 110, 103, 46, 83, 104, 97, 114,
				101, 100, 68, 114, 97, 119, 105, 110, 103, 68,
				97, 116, 97, 124, 66, 117, 114, 115, 116, 84,
				105, 109, 101, 75, 101, 121, 0, 0, 0, 0,
				19, 68, 114, 97, 119, 105, 110, 103, 124, 82,
				101, 100, 114, 97, 119, 83, 99, 111, 112, 101,
				0, 0, 0, 0, 19, 68, 114, 97, 119, 105,
				110, 103, 124, 68, 114, 97, 119, 105, 110, 103,
				68, 97, 116, 97, 0, 0, 0, 0, 26, 68,
				114, 97, 119, 105, 110, 103, 46, 68, 114, 97,
				119, 105, 110, 103, 68, 97, 116, 97, 124, 72,
				97, 115, 104, 101, 114, 0, 0, 0, 0, 40,
				68, 114, 97, 119, 105, 110, 103, 46, 68, 114,
				97, 119, 105, 110, 103, 68, 97, 116, 97, 124,
				80, 114, 111, 99, 101, 115, 115, 101, 100, 66,
				117, 105, 108, 100, 101, 114, 68, 97, 116, 97,
				0, 0, 0, 0, 34, 68, 114, 97, 119, 105,
				110, 103, 46, 68, 114, 97, 119, 105, 110, 103,
				68, 97, 116, 97, 43, 124, 67, 97, 112, 116,
				117, 114, 101, 100, 83, 116, 97, 116, 101, 0,
				0, 0, 0, 32, 68, 114, 97, 119, 105, 110,
				103, 46, 68, 114, 97, 119, 105, 110, 103, 68,
				97, 116, 97, 43, 124, 77, 101, 115, 104, 66,
				117, 102, 102, 101, 114, 115, 0, 0, 0, 0,
				33, 68, 114, 97, 119, 105, 110, 103, 46, 68,
				114, 97, 119, 105, 110, 103, 68, 97, 116, 97,
				124, 83, 117, 98, 109, 105, 116, 116, 101, 100,
				77, 101, 115, 104, 0, 0, 0, 0, 31, 68,
				114, 97, 119, 105, 110, 103, 46, 68, 114, 97,
				119, 105, 110, 103, 68, 97, 116, 97, 124, 66,
				117, 105, 108, 100, 101, 114, 68, 97, 116, 97,
				0, 0, 0, 0, 25, 68, 114, 97, 119, 105,
				110, 103, 46, 68, 114, 97, 119, 105, 110, 103,
				68, 97, 116, 97, 43, 124, 77, 101, 116, 97,
				0, 0, 0, 0, 34, 68, 114, 97, 119, 105,
				110, 103, 46, 68, 114, 97, 119, 105, 110, 103,
				68, 97, 116, 97, 43, 124, 66, 105, 116, 80,
				97, 99, 107, 101, 100, 77, 101, 116, 97, 0,
				0, 0, 0, 40, 68, 114, 97, 119, 105, 110,
				103, 46, 68, 114, 97, 119, 105, 110, 103, 68,
				97, 116, 97, 124, 66, 117, 105, 108, 100, 101,
				114, 68, 97, 116, 97, 67, 111, 110, 116, 97,
				105, 110, 101, 114, 0, 0, 0, 0, 49, 68,
				114, 97, 119, 105, 110, 103, 46, 68, 114, 97,
				119, 105, 110, 103, 68, 97, 116, 97, 124, 80,
				114, 111, 99, 101, 115, 115, 101, 100, 66, 117,
				105, 108, 100, 101, 114, 68, 97, 116, 97, 67,
				111, 110, 116, 97, 105, 110, 101, 114, 0, 0,
				0, 0, 32, 68, 114, 97, 119, 105, 110, 103,
				46, 68, 114, 97, 119, 105, 110, 103, 68, 97,
				116, 97, 124, 77, 101, 115, 104, 87, 105, 116,
				104, 84, 121, 112, 101, 0, 0, 0, 0, 40,
				68, 114, 97, 119, 105, 110, 103, 46, 68, 114,
				97, 119, 105, 110, 103, 68, 97, 116, 97, 124,
				82, 101, 110, 100, 101, 114, 101, 100, 77, 101,
				115, 104, 87, 105, 116, 104, 84, 121, 112, 101,
				0, 0, 0, 0, 25, 68, 114, 97, 119, 105,
				110, 103, 46, 68, 114, 97, 119, 105, 110, 103,
				68, 97, 116, 97, 124, 82, 97, 110, 103, 101,
				0, 0, 0, 0, 45, 68, 114, 97, 119, 105,
				110, 103, 46, 68, 114, 97, 119, 105, 110, 103,
				68, 97, 116, 97, 124, 77, 101, 115, 104, 67,
				111, 109, 112, 97, 114, 101, 66, 121, 68, 114,
				97, 119, 105, 110, 103, 79, 114, 100, 101, 114,
				0, 0, 0, 0, 40, 68, 114, 97, 119, 105,
				110, 103, 46, 68, 114, 97, 119, 105, 110, 103,
				68, 97, 116, 97, 124, 67, 111, 109, 109, 97,
				110, 100, 66, 117, 102, 102, 101, 114, 87, 114,
				97, 112, 112, 101, 114, 0, 0, 0, 0, 20,
				68, 114, 97, 119, 105, 110, 103, 124, 71, 105,
				122, 109, 111, 67, 111, 110, 116, 101, 120, 116,
				0, 0, 0, 0, 19, 68, 114, 97, 119, 105,
				110, 103, 124, 73, 68, 114, 97, 119, 71, 105,
				122, 109, 111, 115, 0, 0, 0, 0, 22, 68,
				114, 97, 119, 105, 110, 103, 124, 68, 114, 97,
				119, 105, 110, 103, 77, 97, 110, 97, 103, 101,
				114, 0, 0, 0, 0, 39, 68, 114, 97, 119,
				105, 110, 103, 46, 68, 114, 97, 119, 105, 110,
				103, 77, 97, 110, 97, 103, 101, 114, 124, 71,
				105, 122, 109, 111, 68, 114, 97, 119, 101, 114,
				71, 114, 111, 117, 112, 0, 0, 0, 0, 23,
				68, 114, 97, 119, 105, 110, 103, 124, 68, 114,
				97, 119, 105, 110, 103, 83, 101, 116, 116, 105,
				110, 103, 115, 0, 0, 0, 0, 32, 68, 114,
				97, 119, 105, 110, 103, 46, 68, 114, 97, 119,
				105, 110, 103, 83, 101, 116, 116, 105, 110, 103,
				115, 124, 83, 101, 116, 116, 105, 110, 103, 115,
				0, 0, 0, 0, 24, 68, 114, 97, 119, 105,
				110, 103, 124, 68, 114, 97, 119, 105, 110, 103,
				85, 116, 105, 108, 105, 116, 105, 101, 115, 0,
				0, 0, 0, 23, 68, 114, 97, 119, 105, 110,
				103, 124, 71, 101, 111, 109, 101, 116, 114, 121,
				66, 117, 105, 108, 100, 101, 114, 0, 0, 0,
				0, 34, 68, 114, 97, 119, 105, 110, 103, 46,
				71, 101, 111, 109, 101, 116, 114, 121, 66, 117,
				105, 108, 100, 101, 114, 124, 67, 97, 109, 101,
				114, 97, 73, 110, 102, 111, 0, 0, 0, 0,
				19, 68, 114, 97, 119, 105, 110, 103, 124, 77,
				101, 115, 104, 76, 97, 121, 111, 117, 116, 115,
				0, 0, 0, 0, 26, 68, 114, 97, 119, 105,
				110, 103, 124, 71, 101, 111, 109, 101, 116, 114,
				121, 66, 117, 105, 108, 100, 101, 114, 74, 111,
				98, 0, 0, 0, 0, 15, 68, 114, 97, 119,
				105, 110, 103, 46, 124, 86, 101, 114, 116, 101,
				120, 0, 0, 0, 0, 19, 68, 114, 97, 119,
				105, 110, 103, 46, 124, 84, 101, 120, 116, 86,
				101, 114, 116, 101, 120, 0, 0, 0, 0, 27,
				68, 114, 97, 119, 105, 110, 103, 124, 77, 111,
				110, 111, 66, 101, 104, 97, 118, 105, 111, 117,
				114, 71, 105, 122, 109, 111, 115, 0, 0, 0,
				0, 15, 68, 114, 97, 119, 105, 110, 103, 124,
				80, 97, 108, 101, 116, 116, 101, 0, 0, 0,
				0, 20, 68, 114, 97, 119, 105, 110, 103, 46,
				80, 97, 108, 101, 116, 116, 101, 124, 80, 117,
				114, 101, 0, 0, 0, 0, 27, 68, 114, 97,
				119, 105, 110, 103, 46, 80, 97, 108, 101, 116,
				116, 101, 124, 67, 111, 108, 111, 114, 98, 114,
				101, 119, 101, 114, 0, 0, 0, 0, 32, 68,
				114, 97, 119, 105, 110, 103, 46, 80, 97, 108,
				101, 116, 116, 101, 43, 67, 111, 108, 111, 114,
				98, 114, 101, 119, 101, 114, 124, 83, 101, 116,
				49, 0, 0, 0, 0, 33, 68, 114, 97, 119,
				105, 110, 103, 46, 80, 97, 108, 101, 116, 116,
				101, 43, 67, 111, 108, 111, 114, 98, 114, 101,
				119, 101, 114, 124, 66, 108, 117, 101, 115, 0,
				0, 0, 0, 27, 68, 114, 97, 119, 105, 110,
				103, 124, 80, 101, 114, 115, 105, 115, 116, 101,
				110, 116, 70, 105, 108, 116, 101, 114, 74, 111,
				98, 0, 0, 0, 0, 25, 68, 114, 97, 119,
				105, 110, 103, 46, 84, 101, 120, 116, 124, 83,
				68, 70, 67, 104, 97, 114, 97, 99, 116, 101,
				114, 0, 0, 0, 0, 20, 68, 114, 97, 119,
				105, 110, 103, 46, 84, 101, 120, 116, 124, 83,
				68, 70, 70, 111, 110, 116, 0, 0, 0, 0,
				26, 68, 114, 97, 119, 105, 110, 103, 46, 84,
				101, 120, 116, 124, 83, 68, 70, 76, 111, 111,
				107, 117, 112, 68, 97, 116, 97, 0, 0, 0,
				0, 25, 68, 114, 97, 119, 105, 110, 103, 46,
				84, 101, 120, 116, 124, 68, 101, 102, 97, 117,
				108, 116, 70, 111, 110, 116, 115, 0, 0, 0,
				0, 22, 68, 114, 97, 119, 105, 110, 103, 124,
				83, 116, 114, 101, 97, 109, 83, 112, 108, 105,
				116, 116, 101, 114
			},
			TotalFiles = 15,
			TotalTypes = 70,
			IsEditorOnly = false
		};
	}
}
namespace Drawing
{
	public struct LabelAlignment
	{
		public float2 relativePivot;

		public float2 pixelOffset;

		public static readonly LabelAlignment TopLeft = new LabelAlignment
		{
			relativePivot = new float2(0f, 1f),
			pixelOffset = new float2(0f, 0f)
		};

		public static readonly LabelAlignment MiddleLeft = new LabelAlignment
		{
			relativePivot = new float2(0f, 0.5f),
			pixelOffset = new float2(0f, 0f)
		};

		public static readonly LabelAlignment BottomLeft = new LabelAlignment
		{
			relativePivot = new float2(0f, 0f),
			pixelOffset = new float2(0f, 0f)
		};

		public static readonly LabelAlignment BottomCenter = new LabelAlignment
		{
			relativePivot = new float2(0.5f, 0f),
			pixelOffset = new float2(0f, 0f)
		};

		public static readonly LabelAlignment BottomRight = new LabelAlignment
		{
			relativePivot = new float2(1f, 0f),
			pixelOffset = new float2(0f, 0f)
		};

		public static readonly LabelAlignment MiddleRight = new LabelAlignment
		{
			relativePivot = new float2(1f, 0.5f),
			pixelOffset = new float2(0f, 0f)
		};

		public static readonly LabelAlignment TopRight = new LabelAlignment
		{
			relativePivot = new float2(1f, 1f),
			pixelOffset = new float2(0f, 0f)
		};

		public static readonly LabelAlignment TopCenter = new LabelAlignment
		{
			relativePivot = new float2(0.5f, 1f),
			pixelOffset = new float2(0f, 0f)
		};

		public static readonly LabelAlignment Center = new LabelAlignment
		{
			relativePivot = new float2(0.5f, 0.5f),
			pixelOffset = new float2(0f, 0f)
		};

		public LabelAlignment withPixelOffset(float x, float y)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			return new LabelAlignment
			{
				relativePivot = relativePivot,
				pixelOffset = new float2(x, y)
			};
		}
	}
	public enum AllowedDelay
	{
		EndOfFrame,
		Infinite
	}
	internal static class CommandBuilderSamplers
	{
		internal static readonly ProfilerMarker MarkerConvert = new ProfilerMarker("Convert");

		internal static readonly ProfilerMarker MarkerSetLayout = new ProfilerMarker("SetLayout");

		internal static readonly ProfilerMarker MarkerUpdateVertices = new ProfilerMarker("UpdateVertices");

		internal static readonly ProfilerMarker MarkerUpdateIndices = new ProfilerMarker("UpdateIndices");

		internal static readonly ProfilerMarker MarkerSubmesh = new ProfilerMarker("Submesh");

		internal static readonly ProfilerMarker MarkerUpdateBuffer = new ProfilerMarker("UpdateComputeBuffer");

		internal static readonly ProfilerMarker MarkerProcessCommands = new ProfilerMarker("Commands");

		internal static readonly ProfilerMarker MarkerCreateTriangles = new ProfilerMarker("CreateTriangles");
	}
	[BurstCompile]
	public struct CommandBuilder : IDisposable
	{
		[Flags]
		internal enum Command
		{
			PushColorInline = 0x100,
			PushColor = 0,
			PopColor = 1,
			PushMatrix = 2,
			PushSetMatrix = 3,
			PopMatrix = 4,
			Line = 5,
			Circle = 6,
			CircleXZ = 7,
			Disc = 8,
			DiscXZ = 9,
			SphereOutline = 0xA,
			Box = 0xB,
			WirePlane = 0xC,
			WireBox = 0xD,
			SolidTriangle = 0xE,
			PushPersist = 0xF,
			PopPersist = 0x10,
			Text = 0x11,
			Text3D = 0x12,
			PushLineWidth = 0x13,
			PopLineWidth = 0x14,
			CaptureState = 0x15
		}

		internal struct TriangleData
		{
			public float3 a;

			public float3 b;

			public float3 c;
		}

		internal struct LineData
		{
			public float3 a;

			public float3 b;
		}

		internal struct LineDataV3
		{
			public Vector3 a;

			public Vector3 b;
		}

		internal struct CircleXZData
		{
			public float3 center;

			public float radius;

			public float startAngle;

			public float endAngle;
		}

		internal struct CircleData
		{
			public float3 center;

			public float3 normal;

			public float radius;
		}

		internal struct SphereData
		{
			public float3 center;

			public float radius;
		}

		internal struct BoxData
		{
			public float3 center;

			public float3 size;
		}

		internal struct PlaneData
		{
			public float3 center;

			public quaternion rotation;

			public float2 size;
		}

		internal struct PersistData
		{
			public float endTime;
		}

		internal struct LineWidthData
		{
			public float pixels;

			public bool automaticJoins;
		}

		internal struct TextData
		{
			public float3 center;

			public LabelAlignment alignment;

			public float sizeInPixels;

			public int numCharacters;
		}

		internal struct TextData3D
		{
			public float3 center;

			public quaternion rotation;

			public LabelAlignment alignment;

			public float size;

			public int numCharacters;
		}

		public struct ScopeMatrix : IDisposable
		{
			internal CommandBuilder builder;

			public unsafe void Dispose()
			{
				builder.PopMatrix();
				builder.buffer = null;
			}
		}

		public struct ScopeColor : IDisposable
		{
			internal CommandBuilder builder;

			public unsafe void Dispose()
			{
				builder.PopColor();
				builder.buffer = null;
			}
		}

		public struct ScopePersist : IDisposable
		{
			internal CommandBuilder builder;

			public unsafe void Dispose()
			{
				builder.PopDuration();
				builder.buffer = null;
			}
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct ScopeEmpty : IDisposable
		{
			public void Dispose()
			{
			}
		}

		public struct ScopeLineWidth : IDisposable
		{
			internal CommandBuilder builder;

			public unsafe void Dispose()
			{
				builder.PopLineWidth();
				builder.buffer = null;
			}
		}

		public enum SymbolDecoration
		{
			None,
			ArrowHead,
			Circle
		}

		public struct PolylineWithSymbol
		{
			private float3 prev;

			private float offset;

			private readonly float symbolSize;

			private readonly float symbolSpacing;

			private readonly float symbolPadding;

			private readonly float symbolOffset;

			private readonly SymbolDecoration symbol;

			private readonly bool reverseSymbols;

			private bool odd;

			public PolylineWithSymbol(SymbolDecoration symbol, float symbolSize, float symbolPadding, float symbolSpacing, bool reverseSymbols = false)
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				if (symbolSpacing <= 1.1754944E-38f)
				{
					throw new ArgumentOutOfRangeException("symbolSpacing", "Symbol spacing must be greater than zero");
				}
				if (symbolSize <= 1.1754944E-38f)
				{
					throw new ArgumentOutOfRangeException("symbolSize", "Symbol size must be greater than zero");
				}
				if (symbolPadding < 0f)
				{
					throw new ArgumentOutOfRangeException("symbolPadding", "Symbol padding must non-negative");
				}
				prev = float3.zero;
				this.symbol = symbol;
				this.symbolSize = symbolSize;
				this.symbolPadding = symbolPadding;
				this.symbolSpacing = math.max(0f, symbolSpacing - symbolPadding * 2f - symbolSize);
				this.reverseSymbols = reverseSymbols;
				symbolOffset = ((symbol == SymbolDecoration.ArrowHead) ? (-0.25f * symbolSize) : 0f);
				if (reverseSymbols)
				{
					symbolOffset = 0f - symbolOffset;
				}
				symbolOffset += 0.5f * symbolSize;
				offset = -1f;
				odd = false;
			}

			public void MoveTo(ref CommandBuilder draw, float3 next)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_0224: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
				if (offset == -1f)
				{
					offset = symbolSpacing * 0.5f;
					prev = next;
					return;
				}
				float num = math.length(next - prev);
				float num2 = math.rcp(num);
				float3 val = next - prev;
				float3 val2 = default(float3);
				if (symbol != SymbolDecoration.None)
				{
					val2 = math.normalizesafe(math.cross(val, math.cross(val, new float3(0f, 1f, 0f))), default(float3));
					if (math.all(val2 == 0f))
					{
						((float3)(ref val2))..ctor(0f, 0f, 1f);
					}
				}
				if (reverseSymbols)
				{
					val = -val;
				}
				if (offset > 0f && !odd)
				{
					draw.Line(prev, math.lerp(prev, next, math.min(offset * num2, 1f)));
				}
				while (offset < num)
				{
					if (odd)
					{
						float3 a = math.lerp(prev, next, offset * num2);
						offset += symbolSpacing;
						float3 b = math.lerp(prev, next, math.min(offset * num2, 1f));
						draw.Line(a, b);
						offset += symbolPadding;
					}
					else
					{
						float3 center = math.lerp(prev, next, (offset + symbolOffset) * num2);
						switch (symbol)
						{
						case SymbolDecoration.ArrowHead:
							draw.Arrowhead(center, val, val2, symbolSize);
							break;
						default:
							draw.Circle(center, val2, symbolSize * 0.5f);
							break;
						case SymbolDecoration.None:
							break;
						}
						offset += symbolSize + symbolPadding;
					}
					odd = !odd;
				}
				offset -= num;
				prev = next;
			}
		}

		[BurstCompile]
		private class JobWireMesh
		{
			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			public delegate void JobWireMeshDelegate(ref MeshData rawMeshData, ref CommandBuilder draw);

			internal unsafe delegate void WireMesh_000000FE$PostfixBurstDelegate(float3* verts, int* indices, int vertexCount, int indexCount, ref CommandBuilder draw);

			internal static class WireMesh_000000FE$BurstDirectCall
			{
				private static IntPtr Pointer;

				private static IntPtr DeferredCompilation;

				[BurstDiscard]
				private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
				{
					if (Pointer == (IntPtr)0)
					{
						Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(WireMesh_000000FE$PostfixBurstDelegate).TypeHandle);
					}
					P_0 = Pointer;
				}

				private static IntPtr GetFunctionPointer()
				{
					nint result = 0;
					GetFunctionPointerDiscard(ref result);
					return result;
				}

				public static void Constructor()
				{
					DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
				}

				public static void Initialize()
				{
				}

				static WireMesh_000000FE$BurstDirectCall()
				{
					Constructor();
				}

				public unsafe static void Invoke(float3* verts, int* indices, int vertexCount, int indexCount, ref CommandBuilder draw)
				{
					if (BurstCompiler.IsEnabled)
					{
						IntPtr functionPointer = GetFunctionPointer();
						if (functionPointer != (IntPtr)0)
						{
							((delegate* unmanaged[Cdecl]<float3*, int*, int, int, ref CommandBuilder, void>)functionPointer)(verts, indices, vertexCount, indexCount, ref draw);
							return;
						}
					}
					WireMesh$BurstManaged(verts, indices, vertexCount, indexCount, ref draw);
				}
			}

			internal delegate void Execute_000000FF$PostfixBurstDelegate(ref MeshData rawMeshData, ref CommandBuilder draw);

			internal static class Execute_000000FF$BurstDirectCall
			{
				private static IntPtr Pointer;

				private static IntPtr DeferredCompilation;

				[BurstDiscard]
				private unsafe static void GetFunctionPointerDiscard(ref IntPtr P_0)
				{
					if (Pointer == (IntPtr)0)
					{
						Pointer = (nint)BurstCompiler.GetILPPMethodFunctionPointer2(DeferredCompilation, (RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/, typeof(Execute_000000FF$PostfixBurstDelegate).TypeHandle);
					}
					P_0 = Pointer;
				}

				private static IntPtr GetFunctionPointer()
				{
					nint result = 0;
					GetFunctionPointerDiscard(ref result);
					return result;
				}

				public static void Constructor()
				{
					DeferredCompilation = BurstCompiler.CompileILPPMethod2((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/);
				}

				public static void Initialize()
				{
				}

				static Execute_000000FF$BurstDirectCall()
				{
					Constructor();
				}

				public unsafe static void Invoke(ref MeshData rawMeshData, ref CommandBuilder draw)
				{
					if (BurstCompiler.IsEnabled)
					{
						IntPtr functionPointer = GetFunctionPointer();
						if (functionPointer != (IntPtr)0)
						{
							((delegate* unmanaged[Cdecl]<ref MeshData, ref CommandBuilder, void>)functionPointer)(ref rawMeshData, ref draw);
							return;
						}
					}
					Execute$BurstManaged(ref rawMeshData, ref draw);
				}
			}

			public static readonly JobWireMeshDelegate JobWireMeshFunctionPointer = BurstCompiler.CompileFunctionPointer<JobWireMeshDelegate>((JobWireMeshDelegate)Execute).Invoke;

			[BurstCompile]
			public unsafe static void WireMesh(float3* verts, int* indices, int vertexCount, int indexCount, ref CommandBuilder draw)
			{
				WireMesh_000000FE$BurstDirectCall.Invoke(verts, indices, vertexCount, indexCount, ref draw);
			}

			[BurstCompile]
			[MonoPInvokeCallback(typeof(JobWireMeshDelegate))]
			private static void Execute(ref MeshData rawMeshData, ref CommandBuilder draw)
			{
				Execute_000000FF$BurstDirectCall.Invoke(ref rawMeshData, ref draw);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[BurstCompile]
			internal unsafe static void WireMesh$BurstManaged(float3* verts, int* indices, int vertexCount, int indexCount, ref CommandBuilder draw)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				if (indexCount % 3 != 0)
				{
					throw new ArgumentException("Invalid index count. Must be a multiple of 3");
				}
				NativeHashMap<int2, bool> val = default(NativeHashMap<int2, bool>);
				val..ctor(indexCount, AllocatorHandle.op_Implicit((Allocator)2));
				for (int i = 0; i < indexCount; i += 3)
				{
					int num = indices[i];
					int num2 = indices[i + 1];
					int num3 = indices[i + 2];
					if (num < 0 || num2 < 0 || num3 < 0 || num >= vertexCount || num2 >= vertexCount || num3 >= vertexCount)
					{
						throw new Exception("Invalid vertex index. Index out of bounds");
					}
					int num4 = math.min(num, num2);
					int num5 = math.max(num, num2);
					if (!val.ContainsKey(new int2(num4, num5)))
					{
						val.Add(new int2(num4, num5), true);
						draw.Line(((float3*)verts)[num4], ((float3*)verts)[num5]);
					}
					num4 = math.min(num2, num3);
					num5 = math.max(num2, num3);
					if (!val.ContainsKey(new int2(num4, num5)))
					{
						val.Add(new int2(num4, num5), true);
						draw.Line(((float3*)verts)[num4], ((float3*)verts)[num5]);
					}
					num4 = math.min(num3, num);
					num5 = math.max(num3, num);
					if (!val.ContainsKey(new int2(num4, num5)))
					{
						val.Add(new int2(num4, num5), true);
						draw.Line(((float3*)verts)[num4], ((float3*)verts)[num5]);
					}
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[BurstCompile]
			[MonoPInvokeCallback(typeof(JobWireMeshDelegate))]
			internal unsafe static void Execute$BurstManaged(ref MeshData rawMeshData, ref CommandBuilder draw)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				int num = 0;
				for (int i = 0; i < ((MeshData)(ref rawMeshData)).subMeshCount; i++)
				{
					int num2 = num;
					SubMeshDescriptor subMesh = ((MeshData)(ref rawMeshData)).GetSubMesh(i);
					num = math.max(num2, ((SubMeshDescriptor)(ref subMesh)).indexCount);
				}
				NativeArray<int> val = default(NativeArray<int>);
				val..ctor(num, (Allocator)2, (NativeArrayOptions)0);
				NativeArray<Vector3> val2 = default(NativeArray<Vector3>);
				val2..ctor(((MeshData)(ref rawMeshData)).vertexCount, (Allocator)2, (NativeArrayOptions)0);
				((MeshData)(ref rawMeshData)).GetVertices(val2);
				for (int j = 0; j < ((MeshData)(ref rawMeshData)).subMeshCount; j++)
				{
					SubMeshDescriptor subMesh2 = ((MeshData)(ref rawMeshData)).GetSubMesh(j);
					((MeshData)(ref rawMeshData)).GetIndices(val, j, true);
					WireMesh((float3*)NativeArrayUnsafeUtility.GetUnsafeReadOnlyPtr<Vector3>(val2), (int*)NativeArrayUnsafeUtility.GetUnsafeReadOnlyPtr<int>(val), val2.Length, ((SubMeshDescriptor)(ref subMesh2)).indexCount, ref draw);
				}
			}
		}

		[NativeDisableUnsafePtrRestriction]
		internal unsafe UnsafeAppendBuffer* buffer;

		private GCHandle gizmos;

		[NativeSetThreadIndex]
		private int threadIndex;

		private DrawingData.BuilderData.BitPackedMeta uniqueID;

		private static readonly float3 DEFAULT_UP = new float3(0f, 1f, 0f);

		internal static readonly float4x4 XZtoXYPlaneMatrix = float4x4.RotateX(-MathF.PI / 2f);

		internal static readonly float4x4 XZtoYZPlaneMatrix = float4x4.RotateZ(MathF.PI / 2f);

		internal unsafe int BufferSize
		{
			get
			{
				return ((UnsafeAppendBuffer)buffer).Length;
			}
			set
			{
				((UnsafeAppendBuffer)buffer).Length = value;
			}
		}

		public CommandBuilder2D xy => new CommandBuilder2D(this, xy: true);

		public CommandBuilder2D xz => new CommandBuilder2D(this, xy: false);

		public Camera[] cameraTargets
		{
			get
			{
				if (gizmos.IsAllocated && gizmos.Target != null)
				{
					DrawingData drawingData = gizmos.Target as DrawingData;
					if (drawingData.data.StillExists(uniqueID))
					{
						return drawingData.data.Get(uniqueID).meta.cameraTargets;
					}
				}
				throw new Exception("Cannot get cameraTargets because the command builder has already been disposed or does not exist.");
			}
			set
			{
				if (uniqueID.isBuiltInCommandBuilder)
				{
					throw new Exception("You cannot set the camera targets for a built-in command builder. Create a custom command builder instead.");
				}
				if (gizmos.IsAllocated && gizmos.Target != null)
				{
					DrawingData obj = gizmos.Target as DrawingData;
					if (!obj.data.StillExists(uniqueID))
					{
						throw new Exception("Cannot set cameraTargets because the command builder has already been disposed or does not exist.");
					}
					obj.data.Get(uniqueID).meta.cameraTargets = value;
				}
			}
		}

		internal unsafe CommandBuilder(UnsafeAppendBuffer* buffer, GCHandle gizmos, int threadIndex, DrawingData.BuilderData.BitPackedMeta uniqueID)
		{
			this.buffer = buffer;
			this.gizmos = gizmos;
			this.threadIndex = threadIndex;
			this.uniqueID = uniqueID;
		}

		internal unsafe CommandBuilder(DrawingData gizmos, DrawingData.Hasher hasher, RedrawScope frameRedrawScope, RedrawScope customRedrawScope, bool isGizmos, bool isBuiltInCommandBuilder, int sceneModeVersion)
		{
			this.gizmos = GCHandle.Alloc(gizmos, GCHandleType.Normal);
			threadIndex = 0;
			uniqueID = gizmos.data.Reserve(isBuiltInCommandBuilder);
			gizmos.data.Get(uniqueID).Init(hasher, frameRedrawScope, customRedrawScope, isGizmos, gizmos.GetNextDrawOrderIndex(), sceneModeVersion);
			buffer = gizmos.data.Get(uniqueID).bufferPtr;
		}

		public void Dispose()
		{
			if (uniqueID.isBuiltInCommandBuilder)
			{
				throw new Exception("You cannot dispose a built-in command builder");
			}
			DisposeInternal();
		}

		public void DisposeAfter(JobHandle dependency, AllowedDelay allowedDelay = AllowedDelay.EndOfFrame)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			if (!gizmos.IsAllocated)
			{
				throw new Exception("You cannot dispose an invalid command builder. Are you trying to dispose it twice?");
			}
			try
			{
				if (gizmos.IsAllocated && gizmos.Target != null)
				{
					DrawingData obj = gizmos.Target as DrawingData;
					if (!obj.data.StillExists(uniqueID))
					{
						throw new Exception("Cannot dispose the command builder because the drawing manager has been destroyed");
					}
					obj.data.Get(uniqueID).SubmitWithDependency(gizmos, dependency, allowedDelay);
				}
			}
			finally
			{
				this = default(CommandBuilder);
			}
		}

		internal void DisposeInternal()
		{
			if (!gizmos.IsAllocated)
			{
				throw new Exception("You cannot dispose an invalid command builder. Are you trying to dispose it twice?");
			}
			try
			{
				if (gizmos.IsAllocated && gizmos.Target != null)
				{
					DrawingData obj = gizmos.Target as DrawingData;
					if (!obj.data.StillExists(uniqueID))
					{
						throw new Exception("Cannot dispose the command builder because the drawing manager has been destroyed");
					}
					obj.data.Get(uniqueID).Submit(gizmos.Target as DrawingData);
				}
			}
			finally
			{
				gizmos.Free();
				this = default(CommandBuilder);
			}
		}

		public void DiscardAndDispose()
		{
			if (uniqueID.isBuiltInCommandBuilder)
			{
				throw new Exception("You cannot dispose a built-in command builder");
			}
			DiscardAndDisposeInternal();
		}

		internal void DiscardAndDisposeInternal()
		{
			try
			{
				if (gizmos.IsAllocated && gizmos.Target != null)
				{
					DrawingData obj = gizmos.Target as DrawingData;
					if (!obj.data.StillExists(uniqueID))
					{
						throw new Exception("Cannot dispose the command builder because the drawing manager has been destroyed");
					}
					obj.data.Release(uniqueID);
				}
			}
			finally
			{
				if (gizmos.IsAllocated)
				{
					gizmos.Free();
				}
				this = default(CommandBuilder);
			}
		}

		public void Preallocate(int size)
		{
			Reserve(size);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe void Reserve(int additionalSpace)
		{
			if (Hint.Unlikely(threadIndex >= 0))
			{
				buffer = (UnsafeAppendBuffer*)((byte*)buffer + (nint)threadIndex * (nint)Unsafe.SizeOf<UnsafeAppendBuffer>());
				threadIndex = -1;
			}
			int num = ((UnsafeAppendBuffer)buffer).Length + additionalSpace;
			if (num > ((UnsafeAppendBuffer)buffer).Capacity)
			{
				((UnsafeAppendBuffer)buffer).SetCapacity(math.max(num, ((UnsafeAppendBuffer)buffer).Length * 2));
			}
		}

		[BurstDiscard]
		private void AssertBufferExists()
		{
			if (!gizmos.IsAllocated || gizmos.Target == null || !(gizmos.Target as DrawingData).data.StillExists(uniqueID))
			{
				this = default(CommandBuilder);
				throw new Exception("This command builder no longer exists. Are you trying to draw to a command builder which has already been disposed?");
			}
		}

		[BurstDiscard]
		private static void AssertNotRendering()
		{
			if (!GizmoContext.drawingGizmos && !JobsUtility.IsExecutingJob && (Time.renderedFrameCount & 0x7F) == 0 && StackTraceUtility.ExtractStackTrace().Contains("OnDrawGizmos"))
			{
				throw new Exception("You are trying to use Draw.* functions from within Unity's OnDrawGizmos function. Use this package's gizmo callbacks instead (see the documentation).");
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void Reserve<A>() where A : struct
		{
			Reserve(UnsafeUtility.SizeOf<Command>() + UnsafeUtility.SizeOf<A>());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void Reserve<A, B>() where A : struct where B : struct
		{
			Reserve(UnsafeUtility.SizeOf<Command>() * 2 + UnsafeUtility.SizeOf<A>() + UnsafeUtility.SizeOf<B>());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void Reserve<A, B, C>() where A : struct where B : struct where C : struct
		{
			Reserve(UnsafeUtility.SizeOf<Command>() * 3 + UnsafeUtility.SizeOf<A>() + UnsafeUtility.SizeOf<B>() + UnsafeUtility.SizeOf<C>());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint ConvertColor(Color color)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (Sse2.IsSse2Supported)
			{
				int4 val = (int4)(255f * new float4(color.r, color.g, color.b, color.a) + 0.5f);
				v128 val2 = new v128(val.x, val.y, val.z, val.w);
				v128 val3 = Sse2.packs_epi32(val2, val2);
				return Sse2.packus_epi16(val3, val3).UInt0;
			}
			uint num = (uint)Mathf.Clamp((int)(color.r * 255f + 0.5f), 0, 255);
			uint num2 = (uint)Mathf.Clamp((int)(color.g * 255f + 0.5f), 0, 255);
			uint num3 = (uint)Mathf.Clamp((int)(color.b * 255f + 0.5f), 0, 255);
			return (uint)(Mathf.Clamp((int)(color.a * 255f + 0.5f), 0, 255) << 24) | (num3 << 16) | (num2 << 8) | num;
		}

		internal unsafe void Add<T>(T value) where T : struct
		{
			int num = UnsafeUtility.SizeOf<T>();
			UnsafeAppendBuffer* ptr = buffer;
			int length = ((UnsafeAppendBuffer)ptr).Length;
			Hint.Assume(((UnsafeAppendBuffer)ptr).Ptr != null);
			Hint.Assume(((UnsafeAppendBuffer)ptr).Ptr + length != null);
			UnsafeUtility.CopyStructureToPtr<T>(ref value, (void*)(((UnsafeAppendBuffer)ptr).Ptr + length));
			((UnsafeAppendBuffer)ptr).Length = length + num;
		}

		[BurstDiscard]
		public ScopeMatrix WithMatrix(Matrix4x4 matrix)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			PushMatrix(matrix);
			return new ScopeMatrix
			{
				builder = this
			};
		}

		[BurstDiscard]
		public ScopeMatrix WithMatrix(float3x3 matrix)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			this.PushMatrix(new float4x4(matrix, float3.zero));
			return new ScopeMatrix
			{
				builder = this
			};
		}

		[BurstDiscard]
		public ScopeColor WithColor(Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			PushColor(color);
			return new ScopeColor
			{
				builder = this
			};
		}

		[BurstDiscard]
		public ScopePersist WithDuration(float duration)
		{
			PushDuration(duration);
			return new ScopePersist
			{
				builder = this
			};
		}

		[BurstDiscard]
		public ScopeLineWidth WithLineWidth(float pixels, bool automaticJoins = true)
		{
			PushLineWidth(pixels, automaticJoins);
			return new ScopeLineWidth
			{
				builder = this
			};
		}

		[BurstDiscard]
		public ScopeMatrix InLocalSpace(Transform transform)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return WithMatrix(transform.localToWorldMatrix);
		}

		[BurstDiscard]
		public ScopeMatrix InScreenSpace(Camera camera)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			Matrix4x4 cameraToWorldMatrix = camera.cameraToWorldMatrix;
			Matrix4x4 nonJitteredProjectionMatrix = camera.nonJitteredProjectionMatrix;
			return WithMatrix(cameraToWorldMatrix * ((Matrix4x4)(ref nonJitteredProjectionMatrix)).inverse * Matrix4x4.TRS(new Vector3(-1f, -1f, 0f), Quaternion.identity, new Vector3(2f / (float)camera.pixelWidth, 2f / (float)camera.pixelHeight, 1f)));
		}

		public void PushMatrix(Matrix4x4 matrix)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			this.Reserve<float4x4>();
			Add(Command.PushMatrix);
			this.Add<Matrix4x4>(matrix);
		}

		public void PushMatrix(float4x4 matrix)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			this.Reserve<float4x4>();
			Add(Command.PushMatrix);
			this.Add<float4x4>(matrix);
		}

		public void PushSetMatrix(Matrix4x4 matrix)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			this.Reserve<float4x4>();
			Add(Command.PushSetMatrix);
			this.Add<float4x4>(float4x4.op_Implicit(matrix));
		}

		public void PushSetMatrix(float4x4 matrix)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			this.Reserve<float4x4>();
			Add(Command.PushSetMatrix);
			this.Add<float4x4>(matrix);
		}

		public void PopMatrix()
		{
			Reserve(4);
			Add(Command.PopMatrix);
		}

		public void PushColor(Color color)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			this.Reserve<Color32>();
			Add(Command.PushColor);
			Add(ConvertColor(color));
		}

		public void PopColor()
		{
			Reserve(4);
			Add(Command.PopColor);
		}

		public void PushDuration(float duration)
		{
			Reserve<PersistData>();
			Add(Command.PushPersist);
			Add(new PersistData
			{
				endTime = SharedDrawingData.BurstTime.Data + duration
			});
		}

		public void PopDuration()
		{
			Reserve(4);
			Add(Command.PopPersist);
		}

		[Obsolete("Renamed to PushDuration for consistency")]
		public void PushPersist(float duration)
		{
			PushDuration(duration);
		}

		[Obsolete("Renamed to PopDuration for consistency")]
		public void PopPersist()
		{
			PopDuration();
		}

		public void PushLineWidth(float pixels, bool automaticJoins = true)
		{
			if (pixels < 0f)
			{
				throw new ArgumentOutOfRangeException("pixels", "Line width must be positive");
			}
			Reserve<LineWidthData>();
			Add(Command.PushLineWidth);
			Add(new LineWidthData
			{
				pixels = pixels,
				automaticJoins = automaticJoins
			});
		}

		public void PopLineWidth()
		{
			Reserve(4);
			Add(Command.PopLineWidth);
		}

		public void Line(float3 a, float3 b)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Reserve<LineData>();
			Add(Command.Line);
			Add(new LineData
			{
				a = a,
				b = b
			});
		}

		public unsafe void Line(Vector3 a, Vector3 b)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			Reserve<LineData>();
			int bufferSize = BufferSize;
			int length = bufferSize + 4 + 24;
			byte* num = ((UnsafeAppendBuffer)buffer).Ptr + bufferSize;
			*(int*)num = 5;
			LineDataV3* ptr = (LineDataV3*)(num + 4);
			Unsafe.Write(&ptr->a, a);
			Unsafe.Write(&ptr->b, b);
			((UnsafeAppendBuffer)buffer).Length = length;
		}

		public unsafe void Line(Vector3 a, Vector3 b, Color color)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			this.Reserve<Color32, LineData>();
			int bufferSize = BufferSize;
			int length = bufferSize + 4 + 24 + 4;
			byte* num = ((UnsafeAppendBuffer)buffer).Ptr + bufferSize;
			*(int*)num = 261;
			((int*)num)[1] = (int)ConvertColor(color);
			LineDataV3* ptr = (LineDataV3*)(num + 8);
			Unsafe.Write(&ptr->a, a);
			Unsafe.Write(&ptr->b, b);
			((UnsafeAppendBuffer)buffer).Length = length;
		}

		public void Ray(float3 origin, float3 direction)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			Line(origin, origin + direction);
		}

		public void Ray(Ray ray, float length)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Line(((Ray)(ref ray)).origin, ((Ray)(ref ray)).origin + ((Ray)(ref ray)).direction * length);
		}

		public void Arc(float3 center, float3 start, float3 end)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			float3 val = start - center;
			float3 val2 = end - center;
			float3 val3 = math.cross(val2, val);
			if (math.any(val3 != 0f) && math.all(math.isfinite(val3)))
			{
				Matrix4x4 matrix = Matrix4x4.TRS(float3.op_Implicit(center), Quaternion.LookRotation(float3.op_Implicit(val), float3.op_Implicit(val3)), Vector3.one);
				float num = Vector3.SignedAngle(float3.op_Implicit(val), float3.op_Implicit(val2), float3.op_Implicit(val3)) * (MathF.PI / 180f);
				PushMatrix(matrix);
				CircleXZInternal(float3.zero, math.length(val), MathF.PI / 2f, MathF.PI / 2f - num);
				PopMatrix();
			}
		}

		[Obsolete("Use Draw.xz.Circle instead")]
		public void CircleXZ(float3 center, float radius, float startAngle = 0f, float endAngle = MathF.PI * 2f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			CircleXZInternal(center, radius, startAngle, endAngle);
		}

		internal void CircleXZInternal(float3 center, float radius, float startAngle = 0f, float endAngle = MathF.PI * 2f)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Reserve<CircleXZData>();
			Add(Command.CircleXZ);
			Add(new CircleXZData
			{
				center = center,
				radius = radius,
				startAngle = startAngle,
				endAngle = endAngle
			});
		}

		internal void CircleXZInternal(float3 center, float radius, float startAngle, float endAngle, Color color)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			this.Reserve<Color32, CircleXZData>();
			Add(Command.CircleXZ | Command.PushColorInline);
			Add(ConvertColor(color));
			Add(new CircleXZData
			{
				center = center,
				radius = radius,
				startAngle = startAngle,
				endAngle = endAngle
			});
		}

		[Obsolete("Use Draw.xy.Circle instead")]
		public void CircleXY(float3 center, float radius, float startAngle = 0f, float endAngle = MathF.PI * 2f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			PushMatrix(XZtoXYPlaneMatrix);
			CircleXZ(new float3(center.x, 0f - center.z, center.y), radius, startAngle, endAngle);
			PopMatrix();
		}

		public void Circle(float3 center, float3 normal, float radius)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Reserve<CircleData>();
			Add(Command.Circle);
			Add(new CircleData
			{
				center = center,
				normal = normal,
				radius = radius
			});
		}

		public void SolidArc(float3 center, float3 start, float3 end)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			float3 val = start - center;
			float3 val2 = end - center;
			float3 val3 = math.cross(val2, val);
			if (math.any(val3))
			{
				Matrix4x4 matrix = Matrix4x4.TRS(float3.op_Implicit(center), Quaternion.LookRotation(float3.op_Implicit(val), float3.op_Implicit(val3)), Vector3.one);
				float num = Vector3.SignedAngle(float3.op_Implicit(val), float3.op_Implicit(val2), float3.op_Implicit(val3)) * (MathF.PI / 180f);
				PushMatrix(matrix);
				SolidCircleXZInternal(float3.zero, math.length(val), MathF.PI / 2f, MathF.PI / 2f - num);
				PopMatrix();
			}
		}

		[Obsolete("Use Draw.xz.SolidCircle instead")]
		public void SolidCircleXZ(float3 center, float radius, float startAngle = 0f, float endAngle = MathF.PI * 2f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			SolidCircleXZInternal(center, radius, startAngle, endAngle);
		}

		internal void SolidCircleXZInternal(float3 center, float radius, float startAngle = 0f, float endAngle = MathF.PI * 2f)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Reserve<CircleXZData>();
			Add(Command.DiscXZ);
			Add(new CircleXZData
			{
				center = center,
				radius = radius,
				startAngle = startAngle,
				endAngle = endAngle
			});
		}

		internal void SolidCircleXZInternal(float3 center, float radius, float startAngle, float endAngle, Color color)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			this.Reserve<Color32, CircleXZData>();
			Add(Command.DiscXZ | Command.PushColorInline);
			Add(ConvertColor(color));
			Add(new CircleXZData
			{
				center = center,
				radius = radius,
				startAngle = startAngle,
				endAngle = endAngle
			});
		}

		[Obsolete("Use Draw.xy.SolidCircle instead")]
		public void SolidCircleXY(float3 center, float radius, float startAngle = 0f, float endAngle = MathF.PI * 2f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			PushMatrix(XZtoXYPlaneMatrix);
			SolidCircleXZInternal(new float3(center.x, 0f - center.z, center.y), radius, startAngle, endAngle);
			PopMatrix();
		}

		public void SolidCircle(float3 center, float3 normal, float radius)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Reserve<CircleData>();
			Add(Command.Disc);
			Add(new CircleData
			{
				center = center,
				normal = normal,
				radius = radius
			});
		}

		public void SphereOutline(float3 center, float radius)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			Reserve<SphereData>();
			Add(Command.SphereOutline);
			Add(new SphereData
			{
				center = center,
				radius = radius
			});
		}

		public void WireCylinder(float3 bottom, float3 top, float radius)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			WireCylinder(bottom, top - bottom, math.length(top - bottom), radius);
		}

		public void WireCylinder(float3 position, float3 up, float height, float radius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			up = math.normalizesafe(up, default(float3));
			if (!math.all(up == 0f) && !math.any(math.isnan(up)) && !math.isnan(height) && !math.isnan(radius))
			{
				OrthonormalBasis(up, out var basis, out var basis2);
				this.PushMatrix(new float4x4(new float4(basis * radius, 0f), new float4(up * height, 0f), new float4(basis2 * radius, 0f), new float4(position, 1f)));
				CircleXZInternal(float3.zero, 1f);
				if (height > 0f)
				{
					CircleXZInternal(new float3(0f, 1f, 0f), 1f);
					this.Line(new float3(1f, 0f, 0f), new float3(1f, 1f, 0f));
					this.Line(new float3(-1f, 0f, 0f), new float3(-1f, 1f, 0f));
					this.Line(new float3(0f, 0f, 1f), new float3(0f, 1f, 1f));
					this.Line(new float3(0f, 0f, -1f), new float3(0f, 1f, -1f));
				}
				PopMatrix();
			}
		}

		private static void OrthonormalBasis(float3 normal, out float3 basis1, out float3 basis2)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			basis1 = math.cross(normal, new float3(1f, 1f, 1f));
			if (math.all(basis1 == 0f))
			{
				basis1 = math.cross(normal, new float3(-1f, 1f, 1f));
			}
			basis1 = math.normalizesafe(basis1, default(float3));
			basis2 = math.cross(normal, basis1);
		}

		public void WireCapsule(float3 start, float3 end, float radius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			float3 val = end - start;
			float num = math.length(val);
			if ((double)num < 0.0001)
			{
				WireSphere(start, radius);
				return;
			}
			float3 val2 = val / num;
			WireCapsule(start - val2 * radius, val2, num + 2f * radius, radius);
		}

		public void WireCapsule(float3 position, float3 direction, float length, float radius)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			direction = math.normalizesafe(direction, default(float3));
			if (math.all(direction == 0f) || math.any(math.isnan(direction)) || math.isnan(length) || math.isnan(radius))
			{
				return;
			}
			if (radius <= 0f)
			{
				Line(position, position + direction * length);
				return;
			}
			length = math.max(length, radius * 2f);
			OrthonormalBasis(direction, out var basis, out var basis2);
			this.PushMatrix(new float4x4(new float4(basis, 0f), new float4(direction, 0f), new float4(basis2, 0f), new float4(position, 1f)));
			CircleXZInternal(new float3(0f, radius, 0f), radius);
			PushMatrix(XZtoXYPlaneMatrix);
			CircleXZInternal(new float3(0f, 0f, radius), radius, MathF.PI);
			PopMatrix();
			PushMatrix(XZtoYZPlaneMatrix);
			CircleXZInternal(new float3(radius, 0f, 0f), radius, MathF.PI / 2f, 4.712389f);
			PopMatrix();
			if (length > 0f)
			{
				float num = length - radius;
				CircleXZInternal(new float3(0f, num, 0f), radius);
				PushMatrix(XZtoXYPlaneMatrix);
				CircleXZInternal(new float3(0f, 0f, num), radius, 0f, MathF.PI);
				PopMatrix();
				PushMatrix(XZtoYZPlaneMatrix);
				CircleXZInternal(new float3(num, 0f, 0f), radius, -MathF.PI / 2f, MathF.PI / 2f);
				PopMatrix();
				this.Line(new float3(radius, radius, 0f), new float3(radius, num, 0f));
				this.Line(new float3(0f - radius, radius, 0f), new float3(0f - radius, num, 0f));
				this.Line(new float3(0f, radius, radius), new float3(0f, num, radius));
				this.Line(new float3(0f, radius, 0f - radius), new float3(0f, num, 0f - radius));
			}
			PopMatrix();
		}

		public void WireSphere(float3 position, float radius)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			SphereOutline(position, radius);
			Circle(position, new float3(1f, 0f, 0f), radius);
			Circle(position, new float3(0f, 1f, 0f), radius);
			Circle(position, new float3(0f, 0f, 1f), radius);
		}

		[BurstDiscard]
		public void Polyline(List<Vector3> points, bool cycle = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < points.Count - 1; i++)
			{
				Line(points[i], points[i + 1]);
			}
			if (cycle && points.Count > 1)
			{
				Line(points[points.Count - 1], points[0]);
			}
		}

		public void Polyline<T>(T points, bool cycle = false) where T : IReadOnlyList<float3>
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < points.Count - 1; i++)
			{
				Line(points[i], points[i + 1]);
			}
			if (cycle && points.Count > 1)
			{
				int index = points.Count - 1;
				Line(points[index], points[0]);
			}
		}

		[BurstDiscard]
		public void Polyline(Vector3[] points, bool cycle = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < points.Length - 1; i++)
			{
				Line(points[i], points[i + 1]);
			}
			if (cycle && points.Length > 1)
			{
				Line(points[^1], points[0]);
			}
		}

		[BurstDiscard]
		public void Polyline(float3[] points, bool cycle = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < points.Length - 1; i++)
			{
				Line(points[i], points[i + 1]);
			}
			if (cycle && points.Length > 1)
			{
				Line(points[^1], points[0]);
			}
		}

		public void Polyline(NativeArray<float3> points, bool cycle = false)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < points.Length - 1; i++)
			{
				Line(points[i], points[i + 1]);
			}
			if (cycle && points.Length > 1)
			{
				Line(points[points.Length - 1], points[0]);
			}
		}

		public void DashedLine(float3 a, float3 b, float dash, float gap)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			PolylineWithSymbol polylineWithSymbol = new PolylineWithSymbol(SymbolDecoration.None, gap, 0f, dash + gap);
			polylineWithSymbol.MoveTo(ref this, a);
			polylineWithSymbol.MoveTo(ref this, b);
		}

		public void DashedPolyline(List<Vector3> points, float dash, float gap)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			PolylineWithSymbol polylineWithSymbol = new PolylineWithSymbol(SymbolDecoration.None, gap, 0f, dash + gap);
			for (int i = 0; i < points.Count; i++)
			{
				polylineWithSymbol.MoveTo(ref this, float3.op_Implicit(points[i]));
			}
		}

		public void WireBox(float3 center, float3 size)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			Reserve<BoxData>();
			Add(Command.WireBox);
			Add(new BoxData
			{
				center = center,
				size = size
			});
		}

		public void WireBox(float3 center, quaternion rotation, float3 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			PushMatrix(float4x4.TRS(center, rotation, size));
			WireBox(float3.zero, new float3(1f, 1f, 1f));
			PopMatrix();
		}

		public void WireBox(Bounds bounds)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			WireBox(float3.op_Implicit(((Bounds)(ref bounds)).center), float3.op_Implicit(((Bounds)(ref bounds)).size));
		}

		public void WireMesh(Mesh mesh)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)mesh == (Object)null)
			{
				throw new ArgumentNullException();
			}
			MeshDataArray val = Mesh.AcquireReadOnlyMeshData(mesh);
			MeshData rawMeshData = ((MeshDataArray)(ref val))[0];
			JobWireMesh.JobWireMeshFunctionPointer(ref rawMeshData, ref this);
			((MeshDataArray)(ref val)).Dispose();
		}

		public unsafe void WireMesh(NativeArray<float3> vertices, NativeArray<int> triangles)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			JobWireMesh.WireMesh((float3*)NativeArrayUnsafeUtility.GetUnsafeReadOnlyPtr<float3>(vertices), (int*)NativeArrayUnsafeUtility.GetUnsafeReadOnlyPtr<int>(triangles), vertices.Length, triangles.Length, ref this);
		}

		public void SolidMesh(Mesh mesh)
		{
			SolidMeshInternal(mesh, temporary: false);
		}

		private void SolidMeshInternal(Mesh mesh, bool temporary, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			PushColor(color);
			SolidMeshInternal(mesh, temporary);
			PopColor();
		}

		private void SolidMeshInternal(Mesh mesh, bool temporary)
		{
			(gizmos.Target as DrawingData).data.Get(uniqueID).meshes.Add(new DrawingData.SubmittedMesh
			{
				mesh = mesh,
				temporary = temporary
			});
			Reserve(4);
			Add(Command.CaptureState);
		}

		[BurstDiscard]
		public void SolidMesh(List<Vector3> vertices, List<int> triangles, List<Color> colors)
		{
			if (vertices.Count != colors.Count)
			{
				throw new ArgumentException("Number of colors must be the same as the number of vertices");
			}
			Mesh mesh = (gizmos.Target as DrawingData).GetMesh(vertices.Count);
			mesh.Clear();
			mesh.SetVertices(vertices);
			mesh.SetTriangles(triangles, 0);
			mesh.SetColors(colors);
			mesh.UploadMeshData(false);
			SolidMeshInternal(mesh, temporary: true);
		}

		[BurstDiscard]
		public void SolidMesh(Vector3[] vertices, int[] triangles, Color[] colors, int vertexCount, int indexCount)
		{
			if (vertices.Length != colors.Length)
			{
				throw new ArgumentException("Number of colors must be the same as the number of vertices");
			}
			Mesh mesh = (gizmos.Target as DrawingData).GetMesh(vertices.Length);
			mesh.Clear();
			mesh.SetVertices(vertices, 0, vertexCount);
			mesh.SetTriangles(triangles, 0, indexCount, 0, true, 0);
			mesh.SetColors(colors, 0, vertexCount);
			mesh.UploadMeshData(false);
			SolidMeshInternal(mesh, temporary: true);
		}

		public void Cross(float3 position, float size = 1f)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			size *= 0.5f;
			Line(position - new float3(size, 0f, 0f), position + new float3(size, 0f, 0f));
			Line(position - new float3(0f, size, 0f), position + new float3(0f, size, 0f));
			Line(position - new float3(0f, 0f, size), position + new float3(0f, 0f, size));
		}

		[Obsolete("Use Draw.xz.Cross instead")]
		public void CrossXZ(float3 position, float size = 1f)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			size *= 0.5f;
			Line(position - new float3(size, 0f, 0f), position + new float3(size, 0f, 0f));
			Line(position - new float3(0f, 0f, size), position + new float3(0f, 0f, size));
		}

		[Obsolete("Use Draw.xy.Cross instead")]
		public void CrossXY(float3 position, float size = 1f)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			size *= 0.5f;
			Line(position - new float3(size, 0f, 0f), position + new float3(size, 0f, 0f));
			Line(position - new float3(0f, size, 0f), position + new float3(0f, size, 0f));
		}

		public static float3 EvaluateCubicBezier(float3 p0, float3 p1, float3 p2, float3 p3, float t)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			t = math.clamp(t, 0f, 1f);
			float num = 1f - t;
			return num * num * num * p0 + 3f * num * num * t * p1 + 3f * num * t * t * p2 + t * t * t * p3;
		}

		public void Bezier(float3 p0, float3 p1, float3 p2, float3 p3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			float3 a = p0;
			for (int i = 1; i <= 20; i++)
			{
				float t = (float)i / 20f;
				float3 val = EvaluateCubicBezier(p0, p1, p2, p3, t);
				Line(a, val);
				a = val;
			}
		}

		public void CatmullRom(List<Vector3> points)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (points.Count < 2)
			{
				return;
			}
			if (points.Count == 2)
			{
				Line(points[0], points[1]);
				return;
			}
			int count = points.Count;
			CatmullRom(float3.op_Implicit(points[0]), float3.op_Implicit(points[0]), float3.op_Implicit(points[1]), float3.op_Implicit(points[2]));
			for (int i = 0; i + 3 < count; i++)
			{
				CatmullRom(float3.op_Implicit(points[i]), float3.op_Implicit(points[i + 1]), float3.op_Implicit(points[i + 2]), float3.op_Implicit(points[i + 3]));
			}
			CatmullRom(float3.op_Implicit(points[count - 3]), float3.op_Implicit(points[count - 2]), float3.op_Implicit(points[count - 1]), float3.op_Implicit(points[count - 1]));
		}

		public void CatmullRom(float3 p0, float3 p1, float3 p2, float3 p3)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: