using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using TheWeavers.ZibraFireSmokeAndLiquid.NetcodePatcher;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("TheWeavers.ZibraFireSmokeAndLiquid")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.2.0")]
[assembly: AssemblyInformationalVersion("1.1.2+5970cb35427a82ac505e3b6ec8115027a2bd6ba4")]
[assembly: AssemblyProduct("ZibraFireSmokeAndLiquid")]
[assembly: AssemblyTitle("TheWeavers.ZibraFireSmokeAndLiquid")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Zibra
{
	[BepInPlugin("TheWeavers.ZibraFireSmokeAndLiquid", "ZibraFireSmokeAndLiquid", "1.1.2")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger = null;

		internal static string pluginPath = "";

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Starting to unwrap assemblies!");
			string path = Paths.PluginPath;
			string[] directories = Directory.GetDirectories(path, "TheWeavers-ZibraFireSmokeAndLiquid*");
			if (directories.Length == 0)
			{
				Logger.LogWarning((object)"No directories matching 'TheWeavers-ZibraFireSmokeAndLiquid*' found.");
				return;
			}
			pluginPath = directories[0];
			Logger.LogInfo((object)("Found matching directory: " + pluginPath));
			InjectNativeFileIntoGame();
			LoadDependencies(pluginPath);
		}

		private void LoadDependencies(string targetDirectory)
		{
			if (Directory.Exists(targetDirectory))
			{
				string[] files = Directory.GetFiles(targetDirectory, "ZibraAI*.dll");
				foreach (string path in files)
				{
					try
					{
						Assembly.LoadFile(path);
						Logger.LogInfo((object)("Loaded " + Path.GetFileName(path) + " successfully."));
					}
					catch (Exception ex)
					{
						Logger.LogError((object)("Failed to load " + Path.GetFileName(path) + ": " + ex.Message));
					}
				}
			}
			else
			{
				Logger.LogWarning((object)"Dependencies folder not found.");
			}
		}

		private void InjectNativeFileIntoGame()
		{
			string text = "Lethal Company_Data/Plugins/x86_64";
			if (!Directory.Exists(Path.Combine(Paths.GameRootPath, text)))
			{
				Directory.CreateDirectory(Path.Combine(Paths.GameRootPath, text));
			}
			File.Copy(Path.Combine(pluginPath, "ZibraLiquidNative_Win.dll"), Path.Combine(text, "ZibraLiquidNative_Win.dll"), overwrite: true);
			File.Copy(Path.Combine(pluginPath, "ZibraSmokeAndFireNative_Win.dll"), Path.Combine(text, "ZibraSmokeAndFireNative_Win.dll"), overwrite: true);
			Logger.LogInfo((object)("Successfully injected assemblies to " + text));
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "TheWeavers.ZibraFireSmokeAndLiquid";

		public const string PLUGIN_NAME = "ZibraFireSmokeAndLiquid";

		public const string PLUGIN_VERSION = "1.1.2";
	}
}
namespace TheWeavers.ZibraFireSmokeAndLiquid.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}

using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.Rendering;
using UnityEngine.Serialization;
using UnityEngine.Timeline;
using com.zibra.common.DataStructures;
using com.zibra.common.Utilities;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("2.1.5.0")]
[assembly: InternalsVisibleTo("ZibraAI.ZibraEffects.Editor")]
[assembly: InternalsVisibleTo("ZibraAI.ZibraEffects.Liquid")]
[assembly: InternalsVisibleTo("ZibraAI.ZibraEffects.Liquid.Editor")]
[assembly: InternalsVisibleTo("ZibraAI.ZibraEffects.SmokeAndFire")]
[assembly: InternalsVisibleTo("ZibraAI.ZibraEffects.SmokeAndFire.Editor")]
[assembly: AssemblyVersion("2.1.5.0")]
[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()
	{
		MonoScriptData result = default(MonoScriptData);
		result.FilePathsData = new byte[1383]
		{
			0, 0, 0, 1, 0, 0, 0, 39, 92, 65,
			115, 115, 101, 116, 115, 92, 80, 108, 117, 103,
			105, 110, 115, 92, 90, 105, 98, 114, 97, 92,
			67, 111, 109, 109, 111, 110, 92, 69, 102, 102,
			101, 99, 116, 115, 46, 99, 115, 0, 0, 0,
			2, 0, 0, 0, 73, 92, 65, 115, 115, 101,
			116, 115, 92, 80, 108, 117, 103, 105, 110, 115,
			92, 90, 105, 98, 114, 97, 92, 67, 111, 109,
			109, 111, 110, 92, 83, 99, 114, 105, 112, 116,
			115, 92, 68, 97, 116, 97, 83, 116, 114, 117,
			99, 116, 117, 114, 101, 115, 92, 77, 101, 115,
			104, 82, 101, 112, 114, 101, 115, 101, 110, 116,
			97, 116, 105, 111, 110, 46, 99, 115, 0, 0,
			0, 1, 0, 0, 0, 69, 92, 65, 115, 115,
			101, 116, 115, 92, 80, 108, 117, 103, 105, 110,
			115, 92, 90, 105, 98, 114, 97, 92, 67, 111,
			109, 109, 111, 110, 92, 83, 99, 114, 105, 112,
			116, 115, 92, 68, 97, 116, 97, 83, 116, 114,
			117, 99, 116, 117, 114, 101, 115, 92, 86, 111,
			120, 101, 108, 69, 109, 98, 101, 100, 100, 105,
			110, 103, 46, 99, 115, 0, 0, 0, 3, 0,
			0, 0, 74, 92, 65, 115, 115, 101, 116, 115,
			92, 80, 108, 117, 103, 105, 110, 115, 92, 90,
			105, 98, 114, 97, 92, 67, 111, 109, 109, 111,
			110, 92, 83, 99, 114, 105, 112, 116, 115, 92,
			68, 97, 116, 97, 83, 116, 114, 117, 99, 116,
			117, 114, 101, 115, 92, 86, 111, 120, 101, 108,
			82, 101, 112, 114, 101, 115, 101, 110, 116, 97,
			116, 105, 111, 110, 46, 99, 115, 0, 0, 0,
			1, 0, 0, 0, 58, 92, 65, 115, 115, 101,
			116, 115, 92, 80, 108, 117, 103, 105, 110, 115,
			92, 90, 105, 98, 114, 97, 92, 67, 111, 109,
			109, 111, 110, 92, 83, 99, 114, 105, 112, 116,
			115, 92, 83, 111, 108, 118, 101, 114, 92, 77,
			97, 110, 105, 112, 117, 108, 97, 116, 111, 114,
			46, 99, 115, 0, 0, 0, 1, 0, 0, 0,
			75, 92, 65, 115, 115, 101, 116, 115, 92, 80,
			108, 117, 103, 105, 110, 115, 92, 90, 105, 98,
			114, 97, 92, 67, 111, 109, 109, 111, 110, 92,
			83, 99, 114, 105, 112, 116, 115, 92, 83, 111,
			108, 118, 101, 114, 92, 77, 97, 110, 105, 112,
			117, 108, 97, 116, 111, 114, 115, 92, 83, 68,
			70, 92, 65, 110, 97, 108, 121, 116, 105, 99,
			83, 68, 70, 46, 99, 115, 0, 0, 0, 2,
			0, 0, 0, 73, 92, 65, 115, 115, 101, 116,
			115, 92, 80, 108, 117, 103, 105, 110, 115, 92,
			90, 105, 98, 114, 97, 92, 67, 111, 109, 109,
			111, 110, 92, 83, 99, 114, 105, 112, 116, 115,
			92, 83, 111, 108, 118, 101, 114, 92, 77, 97,
			110, 105, 112, 117, 108, 97, 116, 111, 114, 115,
			92, 83, 68, 70, 92, 78, 101, 117, 114, 97,
			108, 83, 68, 70, 46, 99, 115, 0, 0, 0,
			1, 0, 0, 0, 73, 92, 65, 115, 115, 101,
			116, 115, 92, 80, 108, 117, 103, 105, 110, 115,
			92, 90, 105, 98, 114, 97, 92, 67, 111, 109,
			109, 111, 110, 92, 83, 99, 114, 105, 112, 116,
			115, 92, 83, 111, 108, 118, 101, 114, 92, 77,
			97, 110, 105, 112, 117, 108, 97, 116, 111, 114,
			115, 92, 83, 68, 70, 92, 83, 68, 70, 79,
			98, 106, 101, 99, 116, 46, 99, 115, 0, 0,
			0, 1, 0, 0, 0, 78, 92, 65, 115, 115,
			101, 116, 115, 92, 80, 108, 117, 103, 105, 110,
			115, 92, 90, 105, 98, 114, 97, 92, 67, 111,
			109, 109, 111, 110, 92, 83, 99, 114, 105, 112,
			116, 115, 92, 83, 111, 108, 118, 101, 114, 92,
			77, 97, 110, 105, 112, 117, 108, 97, 116, 111,
			114, 115, 92, 83, 68, 70, 92, 83, 107, 105,
			110, 110, 101, 100, 77, 101, 115, 104, 83, 68,
			70, 46, 99, 115, 0, 0, 0, 1, 0, 0,
			0, 74, 92, 65, 115, 115, 101, 116, 115, 92,
			80, 108, 117, 103, 105, 110, 115, 92, 90, 105,
			98, 114, 97, 92, 67, 111, 109, 109, 111, 110,
			92, 83, 99, 114, 105, 112, 116, 115, 92, 83,
			111, 108, 118, 101, 114, 92, 77, 97, 110, 105,
			112, 117, 108, 97, 116, 111, 114, 115, 92, 83,
			68, 70, 92, 84, 101, 114, 114, 97, 105, 110,
			83, 68, 70, 46, 99, 115, 0, 0, 0, 2,
			0, 0, 0, 59, 92, 65, 115, 115, 101, 116,
			115, 92, 80, 108, 117, 103, 105, 110, 115, 92,
			90, 105, 98, 114, 97, 92, 67, 111, 109, 109,
			111, 110, 92, 83, 99, 114, 105, 112, 116, 115,
			92, 83, 111, 108, 118, 101, 114, 92, 83, 116,
			97, 116, 82, 101, 112, 111, 114, 116, 101, 114,
			46, 99, 115, 0, 0, 0, 1, 0, 0, 0,
			61, 92, 65, 115, 115, 101, 116, 115, 92, 80,
			108, 117, 103, 105, 110, 115, 92, 90, 105, 98,
			114, 97, 92, 67, 111, 109, 109, 111, 110, 92,
			83, 99, 114, 105, 112, 116, 115, 92, 84, 105,
			109, 101, 108, 105, 110, 101, 92, 67, 111, 110,
			116, 114, 111, 108, 65, 115, 115, 101, 116, 46,
			99, 115, 0, 0, 0, 1, 0, 0, 0, 65,
			92, 65, 115, 115, 101, 116, 115, 92, 80, 108,
			117, 103, 105, 110, 115, 92, 90, 105, 98, 114,
			97, 92, 67, 111, 109, 109, 111, 110, 92, 83,
			99, 114, 105, 112, 116, 115, 92, 84, 105, 109,
			101, 108, 105, 110, 101, 92, 67, 111, 110, 116,
			114, 111, 108, 66, 101, 104, 97, 118, 105, 111,
			117, 114, 46, 99, 115, 0, 0, 0, 1, 0,
			0, 0, 64, 92, 65, 115, 115, 101, 116, 115,
			92, 80, 108, 117, 103, 105, 110, 115, 92, 90,
			105, 98, 114, 97, 92, 67, 111, 109, 109, 111,
			110, 92, 83, 99, 114, 105, 112, 116, 115, 92,
			84, 105, 109, 101, 108, 105, 110, 101, 92, 80,
			108, 97, 121, 98, 97, 99, 107, 67, 111, 110,
			116, 114, 111, 108, 46, 99, 115, 0, 0, 0,
			1, 0, 0, 0, 66, 92, 65, 115, 115, 101,
			116, 115, 92, 80, 108, 117, 103, 105, 110, 115,
			92, 90, 105, 98, 114, 97, 92, 67, 111, 109,
			109, 111, 110, 92, 83, 99, 114, 105, 112, 116,
			115, 92, 84, 105, 109, 101, 108, 105, 110, 101,
			92, 90, 105, 98, 114, 97, 67, 111, 110, 116,
			114, 111, 108, 84, 114, 97, 99, 107, 46, 99,
			115, 0, 0, 0, 1, 0, 0, 0, 67, 92,
			65, 115, 115, 101, 116, 115, 92, 80, 108, 117,
			103, 105, 110, 115, 92, 90, 105, 98, 114, 97,
			92, 67, 111, 109, 109, 111, 110, 92, 83, 99,
			114, 105, 112, 116, 115, 92, 85, 116, 105, 108,
			105, 116, 105, 101, 115, 92, 65, 114, 114, 97,
			121, 67, 111, 109, 112, 97, 99, 116, 105, 102,
			105, 101, 114, 46, 99, 115, 0, 0, 0, 1,
			0, 0, 0, 64, 92, 65, 115, 115, 101, 116,
			115, 92, 80, 108, 117, 103, 105, 110, 115, 92,
			90, 105, 98, 114, 97, 92, 67, 111, 109, 109,
			111, 110, 92, 85, 116, 105, 108, 105, 116, 105,
			101, 115, 92, 82, 101, 110, 100, 101, 114, 80,
			105, 112, 101, 108, 105, 110, 101, 68, 101, 116,
			101, 99, 116, 111, 114, 46, 99, 115, 0, 0,
			0, 2, 0, 0, 0, 55, 92, 65, 115, 115,
			101, 116, 115, 92, 80, 108, 117, 103, 105, 110,
			115, 92, 90, 105, 98, 114, 97, 92, 67, 111,
			109, 109, 111, 110, 92, 85, 116, 105, 108, 105,
			116, 105, 101, 115, 92, 90, 105, 98, 114, 97,
			74, 115, 111, 110, 85, 116, 105, 108, 46, 99,
			115, 0, 0, 0, 1, 0, 0, 0, 44, 92,
			65, 115, 115, 101, 116, 115, 92, 80, 108, 117,
			103, 105, 110, 115, 92, 90, 105, 98, 114, 97,
			92, 67, 111, 109, 109, 111, 110, 92, 90, 105,
			98, 114, 97, 72, 97, 115, 104, 49, 50, 56,
			46, 99, 115
		};
		result.TypesData = new byte[1209]
		{
			0, 0, 0, 0, 24, 99, 111, 109, 46, 122,
			105, 98, 114, 97, 46, 99, 111, 109, 109, 111,
			110, 124, 69, 102, 102, 101, 99, 116, 115, 0,
			0, 0, 0, 50, 99, 111, 109, 46, 122, 105,
			98, 114, 97, 46, 99, 111, 109, 109, 111, 110,
			46, 68, 97, 116, 97, 83, 116, 114, 117, 99,
			116, 117, 114, 101, 115, 124, 77, 101, 115, 104,
			82, 101, 112, 114, 101, 115, 101, 110, 116, 97,
			116, 105, 111, 110, 0, 0, 0, 0, 57, 99,
			111, 109, 46, 122, 105, 98, 114, 97, 46, 99,
			111, 109, 109, 111, 110, 46, 68, 97, 116, 97,
			83, 116, 114, 117, 99, 116, 117, 114, 101, 115,
			124, 83, 107, 105, 110, 110, 101, 100, 77, 101,
			115, 104, 82, 101, 112, 114, 101, 115, 101, 110,
			116, 97, 116, 105, 111, 110, 0, 0, 0, 0,
			46, 99, 111, 109, 46, 122, 105, 98, 114, 97,
			46, 99, 111, 109, 109, 111, 110, 46, 68, 97,
			116, 97, 83, 116, 114, 117, 99, 116, 117, 114,
			101, 115, 124, 86, 111, 120, 101, 108, 69, 109,
			98, 101, 100, 100, 105, 110, 103, 0, 0, 0,
			0, 47, 99, 111, 109, 46, 122, 105, 98, 114,
			97, 46, 99, 111, 109, 109, 111, 110, 46, 68,
			97, 116, 97, 83, 116, 114, 117, 99, 116, 117,
			114, 101, 115, 124, 79, 98, 106, 101, 99, 116,
			84, 114, 97, 110, 115, 102, 111, 114, 109, 0,
			0, 0, 0, 51, 99, 111, 109, 46, 122, 105,
			98, 114, 97, 46, 99, 111, 109, 109, 111, 110,
			46, 68, 97, 116, 97, 83, 116, 114, 117, 99,
			116, 117, 114, 101, 115, 124, 86, 111, 120, 101,
			108, 82, 101, 112, 114, 101, 115, 101, 110, 116,
			97, 116, 105, 111, 110, 0, 0, 0, 0, 58,
			99, 111, 109, 46, 122, 105, 98, 114, 97, 46,
			99, 111, 109, 109, 111, 110, 46, 68, 97, 116,
			97, 83, 116, 114, 117, 99, 116, 117, 114, 101,
			115, 124, 83, 107, 105, 110, 110, 101, 100, 86,
			111, 120, 101, 108, 82, 101, 112, 114, 101, 115,
			101, 110, 116, 97, 116, 105, 111, 110, 0, 0,
			0, 0, 41, 99, 111, 109, 46, 122, 105, 98,
			114, 97, 46, 99, 111, 109, 109, 111, 110, 46,
			77, 97, 110, 105, 112, 117, 108, 97, 116, 111,
			114, 115, 124, 77, 97, 110, 105, 112, 117, 108,
			97, 116, 111, 114, 0, 0, 0, 0, 39, 99,
			111, 109, 46, 122, 105, 98, 114, 97, 46, 99,
			111, 109, 109, 111, 110, 46, 83, 68, 70, 79,
			98, 106, 101, 99, 116, 115, 124, 65, 110, 97,
			108, 121, 116, 105, 99, 83, 68, 70, 0, 0,
			0, 0, 37, 99, 111, 109, 46, 122, 105, 98,
			114, 97, 46, 99, 111, 109, 109, 111, 110, 46,
			83, 68, 70, 79, 98, 106, 101, 99, 116, 115,
			124, 78, 101, 117, 114, 97, 108, 83, 68, 70,
			0, 0, 0, 0, 51, 99, 111, 109, 46, 122,
			105, 98, 114, 97, 46, 99, 111, 109, 109, 111,
			110, 46, 83, 68, 70, 79, 98, 106, 101, 99,
			116, 115, 124, 78, 101, 117, 114, 97, 108, 83,
			68, 70, 82, 101, 112, 114, 101, 115, 101, 110,
			116, 97, 116, 105, 111, 110, 0, 0, 0, 0,
			37, 99, 111, 109, 46, 122, 105, 98, 114, 97,
			46, 99, 111, 109, 109, 111, 110, 46, 83, 68,
			70, 79, 98, 106, 101, 99, 116, 115, 124, 83,
			68, 70, 79, 98, 106, 101, 99, 116, 0, 0,
			0, 0, 42, 99, 111, 109, 46, 122, 105, 98,
			114, 97, 46, 99, 111, 109, 109, 111, 110, 46,
			83, 68, 70, 79, 98, 106, 101, 99, 116, 115,
			124, 83, 107, 105, 110, 110, 101, 100, 77, 101,
			115, 104, 83, 68, 70, 0, 0, 0, 0, 38,
			99, 111, 109, 46, 122, 105, 98, 114, 97, 46,
			99, 111, 109, 109, 111, 110, 46, 83, 68, 70,
			79, 98, 106, 101, 99, 116, 115, 124, 84, 101,
			114, 114, 97, 105, 110, 83, 68, 70, 0, 0,
			0, 0, 36, 99, 111, 109, 46, 122, 105, 98,
			114, 97, 46, 99, 111, 109, 109, 111, 110, 46,
			83, 111, 108, 118, 101, 114, 124, 83, 116, 97,
			116, 82, 101, 112, 111, 114, 116, 101, 114, 0,
			0, 0, 0, 46, 99, 111, 109, 46, 122, 105,
			98, 114, 97, 46, 99, 111, 109, 109, 111, 110,
			46, 83, 111, 108, 118, 101, 114, 124, 83, 116,
			97, 116, 82, 101, 112, 111, 114, 116, 101, 114,
			67, 111, 108, 108, 101, 99, 116, 105, 111, 110,
			0, 0, 0, 0, 38, 99, 111, 109, 46, 122,
			105, 98, 114, 97, 46, 99, 111, 109, 109, 111,
			110, 46, 84, 105, 109, 101, 108, 105, 110, 101,
			124, 67, 111, 110, 116, 114, 111, 108, 65, 115,
			115, 101, 116, 0, 0, 0, 0, 42, 99, 111,
			109, 46, 122, 105, 98, 114, 97, 46, 99, 111,
			109, 109, 111, 110, 46, 84, 105, 109, 101, 108,
			105, 110, 101, 124, 67, 111, 110, 116, 114, 111,
			108, 66, 101, 104, 97, 118, 105, 111, 117, 114,
			0, 0, 0, 0, 41, 99, 111, 109, 46, 122,
			105, 98, 114, 97, 46, 99, 111, 109, 109, 111,
			110, 46, 84, 105, 109, 101, 108, 105, 110, 101,
			124, 80, 108, 97, 121, 98, 97, 99, 107, 67,
			111, 110, 116, 114, 111, 108, 0, 0, 0, 0,
			43, 99, 111, 109, 46, 122, 105, 98, 114, 97,
			46, 99, 111, 109, 109, 111, 110, 46, 84, 105,
			109, 101, 108, 105, 110, 101, 124, 90, 105, 98,
			114, 97, 67, 111, 110, 116, 114, 111, 108, 84,
			114, 97, 99, 107, 0, 0, 0, 0, 44, 99,
			111, 109, 46, 122, 105, 98, 114, 97, 46, 99,
			111, 109, 109, 111, 110, 46, 85, 116, 105, 108,
			105, 116, 105, 101, 115, 124, 65, 114, 114, 97,
			121, 67, 111, 109, 112, 97, 99, 116, 105, 102,
			105, 101, 114, 0, 0, 0, 0, 49, 99, 111,
			109, 46, 122, 105, 98, 114, 97, 46, 99, 111,
			109, 109, 111, 110, 46, 85, 116, 105, 108, 105,
			116, 105, 101, 115, 124, 82, 101, 110, 100, 101,
			114, 80, 105, 112, 101, 108, 105, 110, 101, 68,
			101, 116, 101, 99, 116, 111, 114, 0, 0, 0,
			0, 40, 99, 111, 109, 46, 122, 105, 98, 114,
			97, 46, 99, 111, 109, 109, 111, 110, 46, 85,
			116, 105, 108, 105, 116, 105, 101, 115, 124, 90,
			105, 98, 114, 97, 74, 115, 111, 110, 85, 116,
			105, 108, 0, 0, 0, 0, 48, 99, 111, 109,
			46, 122, 105, 98, 114, 97, 46, 99, 111, 109,
			109, 111, 110, 46, 85, 116, 105, 108, 105, 116,
			105, 101, 115, 46, 90, 105, 98, 114, 97, 74,
			115, 111, 110, 85, 116, 105, 108, 124, 87, 114,
			97, 112, 112, 101, 114, 0, 0, 0, 0, 39,
			99, 111, 109, 46, 122, 105, 98, 114, 97, 46,
			99, 111, 109, 109, 111, 110, 46, 85, 116, 105,
			108, 105, 116, 105, 101, 115, 124, 90, 105, 98,
			114, 97, 72, 97, 115, 104, 49, 50, 56
		};
		result.TotalFiles = 19;
		result.TotalTypes = 25;
		result.IsEditorOnly = false;
		return result;
	}
}
namespace com.zibra.common
{
	public static class Effects
	{
		public const string VersionStandard = "2.1.5.0";

		public const string Version = "2.1.5";

		public const bool IsPreReleaseVersion = false;

		public const string DistributionType = "OTP";

		public const string BaseMenuBarPath = "ZibraAI/";

		public const string LiquidGameObjectMenuPath = "GameObject/Zibra Liquid/";

		public const string LiquidComponentMenuPath = "Zibra Liquid/";

		public const string SmokeAndFireGameObjectMenuPath = "GameObject/Zibra Smoke and Fire/";

		public const string SmokeAndFireComponentMenuPath = "Zibra Smoke & Fire/";

		public const string ZibraVDBComponentMenuPath = "ZibraVDB/";

		public const string ZibraVDBGameObjectMenuPath = "GameObject/ZibraVDB/";

		public const string ScalableComponentMenuPath = "Zibra Scalable/";

		public const string ScalableGameObjectMenuPath = "GameObject/Zibra Scalable/";

		public const string SDFsComponentMenuPath = "Zibra SDFs/";
	}
}
namespace com.zibra.common.Utilities
{
	internal static class ArrayCompactifier
	{
		public static string IntToString(this IEnumerable<int> array)
		{
			return Convert.ToBase64String(array.SelectMany(BitConverter.GetBytes).ToArray());
		}

		public static string FloatToString(this IEnumerable<float> array)
		{
			return Convert.ToBase64String(array.SelectMany(BitConverter.GetBytes).ToArray());
		}

		public static byte[] StringToBytes(this string input)
		{
			return Convert.FromBase64String(input);
		}

		public static float[] StringToFloat(this string input)
		{
			byte[] array = Convert.FromBase64String(input);
			float[] array2 = new float[Mathf.CeilToInt((float)array.Length / 4f)];
			for (int i = 0; i < array2.Length; i++)
			{
				array2[i] = BitConverter.ToSingle(array, i * 4);
			}
			return array2;
		}

		public static string Vector3ToString(this IEnumerable<Vector3> array)
		{
			return Convert.ToBase64String(array.SelectMany((Vector3 vec) => BitConverter.GetBytes(vec.x).Concat(BitConverter.GetBytes(vec.y)).Concat(BitConverter.GetBytes(vec.z))).ToArray());
		}
	}
	public static class RenderPipelineDetector
	{
		public enum RenderPipeline
		{
			BuiltInRP,
			URP,
			HDRP
		}

		public static RenderPipeline GetRenderPipelineType()
		{
			if (Object.op_Implicit((Object)(object)GraphicsSettings.currentRenderPipeline))
			{
				if (((object)GraphicsSettings.currentRenderPipeline).GetType().ToString().Contains("HighDefinition"))
				{
					return RenderPipeline.HDRP;
				}
				Debug.LogError((object)"Current detected render pipeline is URP, but UNITY_PIPELINE_URP is not defined");
				return RenderPipeline.URP;
			}
			return RenderPipeline.BuiltInRP;
		}

		internal static bool IsURPMissingRenderComponent(string name)
		{
			return false;
		}

		public static bool IsURPMissingDepthBuffer()
		{
			return false;
		}
	}
	internal static class ZibraJsonUtil
	{
		[Serializable]
		private struct Wrapper<T>
		{
			public T data;
		}

		private const string WRAPPER_PREFIX = "{\"data\":";

		private const string WRAPPER_SUFFIX = "}";

		public static T FromJson<T>(string json)
		{
			if (typeof(T).IsArray)
			{
				return JsonUtility.FromJson<Wrapper<T>>("{\"data\":" + json + "}").data;
			}
			return JsonUtility.FromJson<T>(json);
		}

		public static string ToJson<T>(T obj)
		{
			if (typeof(T).IsArray)
			{
				Wrapper<T> wrapper = default(Wrapper<T>);
				wrapper.data = obj;
				string text = JsonUtility.ToJson((object)wrapper);
				return text.Substring("{\"data\":".Length, text.Length - "{\"data\":".Length - "}".Length);
			}
			return JsonUtility.ToJson((object)obj);
		}
	}
	[StructLayout(LayoutKind.Sequential)]
	internal class ZibraHash128
	{
		private ulong M0;

		private ulong M1;

		private const ulong POLYNOMIAL0 = 9223372036854775808uL;

		private const ulong POLYNOMIAL1 = 3uL;

		public void Init()
		{
			M0 = 0uL;
			M1 = 0uL;
		}

		public void Append(bool input)
		{
			ulong num = (ulong)(input ? 1 : 0) ^ (M1 & 1);
			M1 >>= 1;
			M1 += (ulong)((long)(M0 & 1) * long.MinValue);
			M0 >>= 1;
			M0 ^= (ulong)((long)num * long.MinValue);
			M1 ^= num * 3;
		}

		public void Append(int input)
		{
			for (int i = 0; i < 32; i++)
			{
				Append((input & 1) != 0);
				input >>= 1;
			}
		}

		public void Append(Color32[] input)
		{
			//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_000f: 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_0027: 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)
			foreach (Color32 val in input)
			{
				Append(val.r);
				Append(val.g);
				Append(val.b);
				Append(val.a);
			}
		}

		public static bool operator ==(ZibraHash128 hash1, ZibraHash128 hash2)
		{
			if ((object)hash1 == null && (object)hash2 == null)
			{
				return true;
			}
			if ((object)hash1 == null || (object)hash2 == null)
			{
				return false;
			}
			if (hash1.M0 == hash2.M0)
			{
				return hash1.M1 == hash2.M1;
			}
			return false;
		}

		public static bool operator !=(ZibraHash128 hash1, ZibraHash128 hash2)
		{
			if ((object)hash1 == null && (object)hash2 == null)
			{
				return false;
			}
			if ((object)hash1 == null || (object)hash2 == null)
			{
				return true;
			}
			if (hash1.M0 == hash2.M0)
			{
				return hash1.M1 != hash2.M1;
			}
			return true;
		}

		public static bool operator <(ZibraHash128 hash1, ZibraHash128 hash2)
		{
			if ((object)hash1 == null && (object)hash2 == null)
			{
				return false;
			}
			if ((object)hash1 == null || (object)hash2 == null)
			{
				return (object)hash1 == null;
			}
			if (hash1.M0 >= hash2.M0)
			{
				if (hash1.M0 == hash2.M0)
				{
					return hash1.M1 < hash2.M1;
				}
				return false;
			}
			return true;
		}

		public static bool operator >(ZibraHash128 hash1, ZibraHash128 hash2)
		{
			if ((object)hash1 == null && (object)hash2 == null)
			{
				return false;
			}
			if ((object)hash1 == null || (object)hash2 == null)
			{
				return (object)hash2 == null;
			}
			if (hash1.M0 <= hash2.M0)
			{
				if (hash1.M0 == hash2.M0)
				{
					return hash1.M1 > hash2.M1;
				}
				return false;
			}
			return true;
		}

		public override bool Equals(object obj)
		{
			if (obj == null || !typeof(ZibraHash128).Equals(obj.GetType()))
			{
				return false;
			}
			ZibraHash128 zibraHash = (ZibraHash128)obj;
			return this == zibraHash;
		}

		public override int GetHashCode()
		{
			return (int)(((M0 >> 16) & 0xFFFFFFFFu) ^ (M0 & 0xFFFFFFFFu) ^ ((M1 >> 16) & 0xFFFFFFFFu) ^ (M1 & 0xFFFFFFFFu));
		}
	}
}
namespace com.zibra.common.Timeline
{
	public class ControlAsset : PlayableAsset
	{
		public float FrameRate = 30f;

		internal float ClipStart;

		internal float ClipEnd;

		public override Playable CreatePlayable(PlayableGraph graph, GameObject owner)
		{
			//IL_0000: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			ScriptPlayable<ControlBehaviour> val = ScriptPlayable<ControlBehaviour>.Create(graph, 0);
			ControlBehaviour behaviour = val.GetBehaviour();
			behaviour.FrameRate = FrameRate;
			behaviour.FrameOffset = 0;
			behaviour.ClipStart = ClipStart;
			behaviour.ClipEnd = ClipEnd;
			return ScriptPlayable<ControlBehaviour>.op_Implicit(val);
		}
	}
	public class ControlBehaviour : PlayableBehaviour
	{
		public float FrameRate;

		public int FrameOffset;

		public float ClipStart;

		public float ClipEnd;

		public float Duration => ClipEnd - ClipStart;

		public override void ProcessFrame(Playable playable, FrameData info, object playerData)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			PlaybackControl playbackControl = playerData as PlaybackControl;
			if ((Object)(object)playbackControl != (Object)null)
			{
				playbackControl.SetTime((float)(PlayableExtensions.GetTime<Playable>(playable) + (double)((float)FrameOffset / FrameRate)));
				playbackControl.SetFadeCoefficient(((FrameData)(ref info)).effectiveWeight);
			}
		}

		public override void OnBehaviourPlay(Playable playable, FrameData info)
		{
			//IL_0002: 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)
			PlaybackControl playbackControl = PlayableOutputExtensions.GetUserData<PlayableOutput>(((FrameData)(ref info)).output) as PlaybackControl;
			if ((Object)(object)playbackControl != (Object)null)
			{
				playbackControl.StartPlayback(this);
				playbackControl.SetTime((float)(PlayableExtensions.GetTime<Playable>(playable) + (double)((float)FrameOffset / FrameRate)));
				playbackControl.SetFadeCoefficient(((FrameData)(ref info)).effectiveWeight);
			}
		}

		public override void OnBehaviourPause(Playable playable, FrameData info)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			PlaybackControl playbackControl = PlayableOutputExtensions.GetUserData<PlayableOutput>(((FrameData)(ref info)).output) as PlaybackControl;
			if ((Object)(object)playbackControl != (Object)null)
			{
				playbackControl.StopPlayback();
			}
		}
	}
	public abstract class PlaybackControl : MonoBehaviour
	{
		public abstract void SetTime(float time);

		public abstract void SetFadeCoefficient(float fadeCoefficient);

		public abstract void StartPlayback(ControlBehaviour controller);

		public abstract void StopPlayback();
	}
	[TrackClipType(typeof(ControlAsset))]
	[TrackBindingType(typeof(PlaybackControl))]
	public class ZibraControlTrack : TrackAsset
	{
		private void OnEnable()
		{
			foreach (TimelineClip clip in ((TrackAsset)this).GetClips())
			{
				ControlAsset controlAsset = clip.asset as ControlAsset;
				if ((Object)(object)controlAsset != (Object)null)
				{
					controlAsset.ClipStart = (float)clip.start;
					controlAsset.ClipEnd = (float)clip.end;
				}
			}
		}
	}
}
namespace com.zibra.common.Solver
{
	public interface StatReporter
	{
		List<string> GetStats();
	}
	public static class StatReporterCollection
	{
		private static List<StatReporter> StatReporters = new List<StatReporter>();

		public static ReadOnlyCollection<StatReporter> GetStatReporters()
		{
			return StatReporters.AsReadOnly();
		}

		public static void Add(StatReporter obj)
		{
			StatReporters.Add(obj);
		}

		public static void Remove(StatReporter obj)
		{
			StatReporters.Remove(obj);
		}
	}
}
namespace com.zibra.common.SDFObjects
{
	[AddComponentMenu("Zibra SDFs/Zibra Analytic SDF")]
	[DisallowMultipleComponent]
	public class AnalyticSDF : SDFObject
	{
		public enum SDFType
		{
			Sphere,
			Box,
			Capsule,
			Torus,
			Cylinder
		}

		[FormerlySerializedAs("chosenSDFType")]
		[Tooltip("Currently chosen analytic shape")]
		public SDFType ChosenSDFType;

		[NonSerialized]
		[HideInInspector]
		[Obsolete("chosenSDFType is deprecated. Use ChosenSDFType instead.", true)]
		public SDFType chosenSDFType;

		public Vector3 GetBBoxSize()
		{
			//IL_0006: 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)
			//IL_0033: 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_0045: 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_0051: 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_005d: 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)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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)
			Vector3 lossyScale = ((Component)this).transform.lossyScale;
			return (Vector3)(ChosenSDFType switch
			{
				SDFType.Capsule => new Vector3(lossyScale.x, lossyScale.y, lossyScale.x), 
				SDFType.Torus => new Vector3(lossyScale.x, lossyScale.y, lossyScale.x), 
				SDFType.Cylinder => new Vector3(lossyScale.x, lossyScale.y, lossyScale.x), 
				_ => 0.5f * lossyScale, 
			});
		}

		public override ulong GetVRAMFootprint()
		{
			return 0uL;
		}

		public override SDFObjectType GetSDFType()
		{
			return SDFObjectType.Analytic;
		}
	}
	[ExecuteInEditMode]
	[AddComponentMenu("Zibra SDFs/Zibra Neural SDF")]
	[DisallowMultipleComponent]
	public class NeuralSDF : SDFObject
	{
		internal const ulong NEURAL_SDF_VRAM_FOOTPRINT = 213712uL;

		[SerializeField]
		[FormerlySerializedAs("objectRepresentation")]
		internal NeuralSDFRepresentation ObjectRepresentation = new NeuralSDFRepresentation();

		public bool HasRepresentation()
		{
			if (ObjectRepresentation != null)
			{
				return ObjectRepresentation.HasRepresentationV3;
			}
			return false;
		}

		public override ulong GetVRAMFootprint()
		{
			if (!HasRepresentation())
			{
				return 0uL;
			}
			return 213712uL;
		}

		public override SDFObjectType GetSDFType()
		{
			return SDFObjectType.Neural;
		}
	}
	[Serializable]
	internal class NeuralSDFRepresentation
	{
		public const int BLOCK_SDF_APPROX_DIMENSION = 32;

		public const int BLOCK_EMBEDDING_GRID_DIMENSION = 21;

		public const int DEFAULT_SDF_APPROX_DIMENSION = 32;

		public const int DEFAULT_EMBEDDING_GRID_DIMENSION = 21;

		public const int PACKING = 4;

		public const int EMBEDDING_BASE_SIZE = 16;

		public const int EMBEDDING_SIZE = 4;

		[SerializeField]
		public Vector3 BoundingBoxCenter;

		[SerializeField]
		public Vector3 BoundingBoxSize;

		public Matrix4x4 ObjectTransform;

		[SerializeField]
		internal VoxelRepresentation CurrentRepresentationV3 = new VoxelRepresentation();

		[HideInInspector]
		public bool HasRepresentationV3;

		[SerializeField]
		internal VoxelEmbedding VoxelInfo;

		[SerializeField]
		public int EmbeddingResolution;

		[SerializeField]
		public int GridResolution;

		[SerializeField]
		internal ZibraHash128 ObjectHash;

		public byte GetSDGrid(int i, int j, int k, int t)
		{
			int num = i + GridResolution * (j + k * GridResolution);
			return VoxelInfo.grid[2 * num + t];
		}

		public Color32 GetEmbedding(int i, int j, int k, int t)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			int num = i + t * EmbeddingResolution + 4 * EmbeddingResolution * (j + k * EmbeddingResolution);
			return VoxelInfo.embeds[num];
		}

		internal ZibraHash128 GetHash()
		{
			if ((object)ObjectHash == null)
			{
				ObjectHash = new ZibraHash128();
				ObjectHash.Init();
				ObjectHash.Append(VoxelInfo.embeds);
			}
			return ObjectHash;
		}

		public void CreateRepresentation(int embeddingResolution, int gridResolution)
		{
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: 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_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: 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)
			HasRepresentationV3 = true;
			byte[] array = CurrentRepresentationV3.embeds.StringToBytes();
			VoxelInfo.grid = CurrentRepresentationV3.sd_grid.StringToBytes();
			EmbeddingResolution = embeddingResolution;
			GridResolution = gridResolution;
			int num = embeddingResolution * embeddingResolution * embeddingResolution;
			Array.Resize(ref VoxelInfo.embeds, num * 4);
			Color32 val = default(Color32);
			for (int i = 0; i < embeddingResolution; i++)
			{
				for (int j = 0; j < embeddingResolution; j++)
				{
					for (int k = 0; k < embeddingResolution; k++)
					{
						for (int l = 0; l < 4; l++)
						{
							int num2 = i + l * embeddingResolution + 4 * embeddingResolution * (j + k * embeddingResolution);
							int num3 = l + (i + embeddingResolution * (j + k * embeddingResolution)) * 4;
							((Color32)(ref val))..ctor(array[4 * num3], array[4 * num3 + 1], array[4 * num3 + 2], array[4 * num3 + 3]);
							VoxelInfo.embeds[num2] = val;
						}
					}
				}
			}
			CurrentRepresentationV3.embeds = null;
			CurrentRepresentationV3.sd_grid = null;
			float[] array2 = CurrentRepresentationV3.transform.Q.StringToFloat();
			float[] array3 = CurrentRepresentationV3.transform.T.StringToFloat();
			float[] array4 = CurrentRepresentationV3.transform.S.StringToFloat();
			Quaternion val2 = default(Quaternion);
			((Quaternion)(ref val2))..ctor(0f - array2[1], 0f - array2[2], 0f - array2[3], array2[0]);
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(array4[0], array4[1], array4[2]);
			Vector3 val4 = default(Vector3);
			((Vector3)(ref val4))..ctor(0f - array3[0], 0f - array3[1], 0f - array3[2]);
			ObjectTransform = Matrix4x4.Rotate(val2) * Matrix4x4.Translate(val4) * Matrix4x4.Scale(val3);
		}
	}
	[ExecuteInEditMode]
	[DisallowMultipleComponent]
	public abstract class SDFObject : MonoBehaviour
	{
		public enum SDFObjectType
		{
			Heightmap = -3,
			Group,
			Neural,
			Analytic
		}

		[Tooltip("Inverts collider so volume can only exist inside.")]
		public bool InvertSDF;

		[Tooltip("How far is the SDF surface from the object surface")]
		public float SurfaceDistance;

		public abstract ulong GetVRAMFootprint();

		public abstract SDFObjectType GetSDFType();
	}
	[AddComponentMenu("Zibra SDFs/Zibra Skinned Mesh SDF")]
	[DisallowMultipleComponent]
	public class SkinnedMeshSDF : SDFObject
	{
		[SerializeField]
		[FormerlySerializedAs("boneSDFs")]
		internal List<SDFObject> BoneSDFList = new List<SDFObject>();

		public bool HasRepresentation()
		{
			if (BoneSDFList.Count == 0)
			{
				return false;
			}
			foreach (SDFObject boneSDF in BoneSDFList)
			{
				NeuralSDF neuralSDF = boneSDF as NeuralSDF;
				if ((Object)(object)neuralSDF != (Object)null && !neuralSDF.HasRepresentation())
				{
					return false;
				}
			}
			return true;
		}

		public override ulong GetVRAMFootprint()
		{
			if (!HasRepresentation())
			{
				return 0uL;
			}
			return (ulong)BoneSDFList.Count * 213712uL;
		}

		public override SDFObjectType GetSDFType()
		{
			return SDFObjectType.Group;
		}
	}
	[AddComponentMenu("Zibra SDFs/Zibra Terrain SDF")]
	[DisallowMultipleComponent]
	public class TerrainSDF : SDFObject
	{
		internal int Resolution = 256;

		public Vector3 GetBBoxSize()
		{
			//IL_0024: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			Terrain component = ((Component)this).GetComponent<Terrain>();
			if ((Object)(object)component != (Object)null)
			{
				Bounds bounds = component.terrainData.bounds;
				return ((Bounds)(ref bounds)).size;
			}
			return Vector3.zero;
		}

		public override ulong GetVRAMFootprint()
		{
			if ((Object)(object)((Component)this).GetComponent<Terrain>() != (Object)null)
			{
				return (ulong)(Resolution * Resolution) * 2uL;
			}
			return 0uL;
		}

		public override SDFObjectType GetSDFType()
		{
			return SDFObjectType.Heightmap;
		}
	}
}
namespace com.zibra.common.Manipulators
{
	public abstract class Manipulator : MonoBehaviour
	{
	}
}
namespace com.zibra.common.DataStructures
{
	[Serializable]
	internal class MeshRepresentation
	{
		public string faces;

		public string vertices;

		public int vox_dim;

		public int sdf_dim;

		public float cutoff_weight;

		public bool static_quantization;
	}
	[Serializable]
	internal class SkinnedMeshRepresentation
	{
		public string faces;

		public string vertices;

		public string bone_ids;

		public string bone_weights;

		public int vox_dim;

		public int sdf_dim;

		public float cutoff_weight;

		public bool static_quantization;
	}
	[Serializable]
	internal struct VoxelEmbedding
	{
		public Color32[] embeds;

		public byte[] grid;
	}
	[Serializable]
	internal class ObjectTransform
	{
		public string Q;

		public string T;

		public string S;
	}
	[Serializable]
	internal class VoxelRepresentation
	{
		public string embeds;

		public string sd_grid;

		public ObjectTransform transform;
	}
	[Serializable]
	internal class SkinnedVoxelRepresentation
	{
		public VoxelRepresentation[] meshes_data;
	}
}