NixelWrapperCS.cs

// E:\Graphine Granite Toolset\NixelWrapperCS.dll
// NixelWrapperCS, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// Global type: <Module>
// Architecture: x64
// Runtime: v4.0.30319
// Hash algorithm: SHA1

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using Graphine.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("Graphine NV")]
[assembly: AssemblyProduct("Granite SDK")]
[assembly: AssemblyCopyright("Copyright Graphine NV © 2013-2017")]
[assembly: AssemblyInformationalVersion("5.0.0.34144")]
[assembly: AssemblyDescription("Generated by cholleme@ZELDA from master/9a8e2032016ca90aea9bc098289abc7dc1f56d8c")]
[assembly: AssemblyTitle("NixelWrapperCS")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("fce57ce5-5771-415c-927a-97ba7bb34616")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Nixel
{
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct TiledTopology
	{
		public uint width;

		public uint height;

		public uint numLevels;

		public uint numLayers;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
		public DataType[] dataType;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
		public Color[] defaultLayerColors;

		public TiledTopology(uint width, uint height, uint numLayers)
		{
			this.width = width;
			this.height = height;
			this.numLayers = numLayers;
			uint num = ((width < height) ? width : height);
			uint num2 = 0u;
			do
			{
				num >>= 1;
				num2++;
			}
			while (num != 0);
			numLevels = num2;
			dataType = new DataType[4];
			defaultLayerColors = new Color[4];
		}

		public uint GetLevelWidth(uint level)
		{
			if (level >= numLevels)
			{
				return 0u;
			}
			uint num = width / (uint)Math.Pow(2.0, level);
			if (num == 0)
			{
				num = 1u;
			}
			return num;
		}

		public uint GetLevelHeight(uint level)
		{
			if (level >= numLevels)
			{
				return 0u;
			}
			uint num = height / (uint)Math.Pow(2.0, level);
			if (num == 0)
			{
				num = 1u;
			}
			return num;
		}

		public bool IsEqual(ref TiledTopology tiledObject)
		{
			if (tiledObject.width != width || tiledObject.height != height || tiledObject.numLayers != numLayers || tiledObject.numLevels != numLevels)
			{
				return false;
			}
			for (int i = 0; i < 4; i++)
			{
				if (tiledObject.dataType[i] != dataType[i])
				{
					return false;
				}
			}
			return true;
		}

		public bool IsValidTile(ref TileId tid)
		{
			if (tid.level >= numLevels)
			{
				return false;
			}
			if (tid.x > GetLevelWidth(tid.level))
			{
				return false;
			}
			if (tid.y > GetLevelHeight(tid.level))
			{
				return false;
			}
			return true;
		}

		public bool IsTopTile(ref TileId tid)
		{
			return tid.y == GetLevelHeight(tid.level) - 1;
		}

		public bool IsBottomTile(ref TileId tid)
		{
			return tid.y == 0;
		}

		public bool IsLeftTile(ref TileId tid)
		{
			return tid.x == 0;
		}

		public bool IsRightTile(ref TileId tid)
		{
			return tid.x == GetLevelWidth(tid.level) - 1;
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct Color
	{
		public byte r;

		public byte g;

		public byte b;

		public byte a;

		public Color(byte _r, byte _g, byte _b, byte _a)
		{
			r = _r;
			g = _g;
			b = _b;
			a = _a;
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct TileId
	{
		public uint x;

		public uint y;

		public uint level;

		public TileId(uint tx, uint ty, uint tlevel)
		{
			x = tx;
			y = ty;
			level = tlevel;
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct LayerTileId
	{
		public uint x;

		public uint y;

		public uint level;

		public uint layer;

		public LayerTileId(uint tx, uint ty, uint tlevel, uint tLayer)
		{
			x = tx;
			y = ty;
			level = tlevel;
			layer = tLayer;
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct RasterTileDimension
	{
		public uint width;

		public uint height;

		public uint border;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct MappedTileLayer
	{
		public IntPtr data;

		public uint rowPitch;

		public MappedTileLayer(IntPtr data, uint rowPitch)
		{
			this.data = data;
			this.rowPitch = rowPitch;
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct MappedTileLayerRead
	{
		public readonly IntPtr data;

		public uint rowPitch;

		public float rectX;

		public float rectY;

		public float rectWidth;

		public float rectHeight;

		public MappedTileLayerRead(IntPtr data, uint rowPitch, float rectX, float rectY, float rectWidth, float rectHeight)
		{
			this.data = data;
			this.rowPitch = rowPitch;
			this.rectX = rectX;
			this.rectY = rectY;
			this.rectWidth = rectWidth;
			this.rectHeight = rectHeight;
		}
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
	public struct TileLayerCodingGroup
	{
		public int id;

		public uint layer;

		public int codecTypeId;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 1024)]
		public string codingParameters;

		public TileLayerCodingGroup(int id)
		{
			this.id = id;
			layer = 0u;
			codecTypeId = 0;
			codingParameters = "";
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct Layout
	{
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
		public byte[] src;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
		public byte[] mask;

		public void Init()
		{
			src = new byte[4];
			mask = new byte[4];
			for (byte b = 0; b < 4; b = (byte)(b + 1))
			{
				src[b] = b;
				mask[b] = 1;
			}
		}

		public void Set(string strLayoutSrc, string strLayoutMask)
		{
			Init();
			if (Check(strLayoutSrc))
			{
				for (int i = 0; i < strLayoutSrc.Length; i++)
				{
					src[i] = (byte)char.GetNumericValue(strLayoutSrc[i]);
				}
				SetMask(strLayoutMask);
			}
		}

		public void SetMask(string strLayoutMask)
		{
			if (CheckMask(strLayoutMask))
			{
				for (int i = 0; i < strLayoutMask.Length; i++)
				{
					mask[i] = (byte)char.GetNumericValue(strLayoutMask[i]);
				}
			}
		}

		public bool IsDefault()
		{
			for (byte b = 0; b < 4; b = (byte)(b + 1))
			{
				if (src[b] != b)
				{
					return false;
				}
				if (mask[b] != 1)
				{
					return false;
				}
			}
			return true;
		}

		public void CorrectForBGR()
		{
			byte b = src[2];
			src[2] = src[0];
			src[0] = b;
		}

		public bool Swizzle(string swizzle)
		{
			if (!Check(swizzle))
			{
				return false;
			}
			byte[] array = new byte[4];
			Array.Copy(src, array, 4);
			for (int i = 0; i < swizzle.Length; i++)
			{
				src[i] = array[int.Parse(swizzle[i].ToString())];
			}
			return true;
		}

		private bool Check(string strLayout)
		{
			if (strLayout == null)
			{
				return false;
			}
			if (strLayout.Length > 4)
			{
				return false;
			}
			for (int i = 0; i < strLayout.Length; i++)
			{
				if (!char.IsNumber(strLayout[i]))
				{
					return false;
				}
				if (int.Parse(strLayout[i].ToString()) < 0 || int.Parse(strLayout[i].ToString()) >= 4)
				{
					return false;
				}
			}
			return true;
		}

		private bool CheckMask(string strLayoutMask)
		{
			if (strLayoutMask == null)
			{
				return false;
			}
			if (strLayoutMask.Length > 4)
			{
				return false;
			}
			for (int i = 0; i < strLayoutMask.Length; i++)
			{
				if (strLayoutMask[i] != '0' && strLayoutMask[i] != '1')
				{
					return false;
				}
			}
			return true;
		}

		public string Get()
		{
			string text = "";
			for (int i = 0; i < 4; i++)
			{
				text += src[i];
			}
			return text;
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct FlatTileInfo
	{
		public uint totalSize;

		public uint dataSize;

		public uint pageFileId;

		public uint pageId;

		public ulong dataOffset;

		public uint codec;

		public uint parameterBlock;

		public uint flatTileId;

		[MarshalAs(UnmanagedType.I1)]
		public bool bNoDataTile;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct TileInfo
	{
		public uint totalTileSize;

		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
		public FlatTileInfo[] layerTile;

		public void Init()
		{
			layerTile = new FlatTileInfo[4];
		}
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct GtsInfo
	{
		[MarshalAs(UnmanagedType.Struct)]
		public GraphineGuid guid;

		public uint pagesize;

		public uint numPages;

		public uint numPageFiles;

		public uint numParameterBlocks;

		public uint numTiles;

		public uint numFlatTiles;

		[MarshalAs(UnmanagedType.I4)]
		public TileFileType type;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct BuildHeader
	{
		[MarshalAs(UnmanagedType.Struct)]
		public GraphineGuid guid;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct TileOrderItem
	{
		public TileId tileId;

		public uint fileId;

		public TileOrderItem(TileId tid, uint fid)
		{
			tileId = tid;
			fileId = fid;
		}
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
	public struct BuilderSettings
	{
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string gtsFilename;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string pagesDirectoryPath;

		public uint pageSize;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
	public struct RebuilderSettings
	{
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string gtsFilename;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string pagesDirectoryPath;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string sharedMipRasterFilename;

		[MarshalAs(UnmanagedType.I1)]
		public bool useRedirection;

		[MarshalAs(UnmanagedType.I1)]
		public bool useMipStripping;

		[MarshalAs(UnmanagedType.I1)]
		public bool buildGTSForGTex;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
	public struct SoupBuilderSettings
	{
		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string soupFilename;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string soupPatchSourceFilename;

		[MarshalAs(UnmanagedType.I1)]
		public bool patchMode;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct BuildReport
	{
		[MarshalAs(UnmanagedType.Struct)]
		public GraphineGuid guid;

		public ulong slack;

		public uint numPageFiles;

		public uint numPages;

		public uint pageSize;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct Thumbnail
	{
		[MarshalAs(UnmanagedType.Struct)]
		public GraphineGuid Identifier;

		public uint width;

		public uint height;

		public readonly IntPtr rgbaData;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
	public struct PageFileInfo
	{
		[MarshalAs(UnmanagedType.I1)]
		public bool loaded;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string name;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string filename;

		public uint checksumHeader0;

		public uint checksumHeader1;

		public uint checksumHeader2;

		public uint checksumHeader3;

		public uint checksumFile0;

		public uint checksumFile1;

		public uint checksumFile2;

		public uint checksumFile3;

		public uint numPages;
	}
	[StructLayout(LayoutKind.Sequential, Pack = 1)]
	public struct PagingSettings
	{
		[MarshalAs(UnmanagedType.I1)]
		public bool autoPagesize;

		public uint pagesize;

		public uint blockSize;

		public uint targetDisk;

		public int pagingStrategy;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
	public struct CodecLogInfo
	{
		[MarshalAs(UnmanagedType.LPWStr)]
		public string codec;

		[MarshalAs(UnmanagedType.LPWStr)]
		public string file;

		public int line;

		[MarshalAs(UnmanagedType.LPWStr)]
		public string callstack;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
	public struct ErrorInfo
	{
		[MarshalAs(UnmanagedType.LPWStr)]
		public string file;

		public int line;

		[MarshalAs(UnmanagedType.LPWStr)]
		public string function;

		public int code;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
		public string message;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
	public struct LibraryVersionInfo
	{
		public int major;

		public int minor;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
		public string buildUser;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
		public string buildHost;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
		public string buildGitBranch;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 512)]
		public string buildGitHash;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
	public struct NixelInitializationInfo
	{
		public int value1;

		public int value2;

		public int value3;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string value4;
	}
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode, Pack = 1)]
	public struct PackedSoupFile
	{
		public uint packedX;

		public uint packedY;

		public uint packedWidth;

		public uint packedHeight;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string soupFilePath;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string relativeSoupFilePath;

		[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
		public string assetName;
	}
	[Obfuscation(Exclude = true, ApplyToMembers = true)]
	public enum BorderMode
	{
		Neighbor,
		Clamp,
		Repeat
	}
	[Obfuscation(Exclude = true, ApplyToMembers = true)]
	public enum BuildAction
	{
		Continue,
		Stop
	}
	[Obfuscation(Exclude = true, ApplyToMembers = true)]
	public enum BuildMode
	{
		Fast,
		High
	}
	[Obfuscation(Exclude = true, ApplyToMembers = true)]
	public enum BuildPass
	{
		Pre,
		SharedMipRasterizing,
		SharedMipMipMapping,
		RedirectionMappingSetup,
		WriteEncode,
		Post,
		RedirectionMapping,
		FinishPaging
	}
	[Obfuscation(Exclude = true, ApplyToMembers = true)]
	public enum CancelResult
	{
		Continue,
		Cancel
	}
	public enum Enum
	{
		Default,
		GTPPerLevel,
		GTPPerGTex
	}
	[Obfuscation(Exclude = true, ApplyToMembers = true)]
	public enum Error
	{
		Ok,
		InvalidParameter,
		OutOfRange,
		InvalidDimensions,
		Pagesize,
		InvalidState,
		OutOfMemory,
		IoBadPath,
		IoFileNotFound,
		IoDiskFull,
		IoAccessDenied,
		IoLocked,
		IoUnknown,
		Graphics,
		WouldBlock,
		CacheFull,
		NoData,
		HasData,
		InvalidLayerData,
		NotYetImplemented,
		InvalidPageFile,
		InvalidGtsFile,
		InvalidSoupFile,
		InvalidSoupIndex,
		InvalidSoupCoding,
		InvalidCacheFile,
		InvalidRasterIndex,
		InvalidHeader,
		InvalidVersion,
		MissingMetadata,
		MissingSoupCoding,
		MissingSoupIndex,
		MissingRasterIndex,
		MissingSoupFile,
		InvalidCodingGroupIndex,
		InvalidCodecParamter,
		BlockCodingError,
		InvalidCodecConfiguration,
		CodecIOError,
		NotEnoughChannels,
		TranscoderLoadFailed,
		Aborted,
		Unknown
	}
	public class IBuildCallback : IDisposable
	{
		public delegate void SwigDelegateIBuildCallback_0(int buildPass);

		public delegate void SwigDelegateIBuildCallback_1(int buildPass);

		public delegate void SwigDelegateIBuildCallback_2(IntPtr tid);

		public delegate int SwigDelegateIBuildCallback_3(IntPtr tid, int errorCode);

		public delegate int SwigDelegateIBuildCallback_4(IntPtr tid);

		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		private SwigDelegateIBuildCallback_0 swigDelegate0;

		private SwigDelegateIBuildCallback_1 swigDelegate1;

		private SwigDelegateIBuildCallback_2 swigDelegate2;

		private SwigDelegateIBuildCallback_3 swigDelegate3;

		private SwigDelegateIBuildCallback_4 swigDelegate4;

		private static Type[] swigMethodTypes0 = new Type[1] { typeof(BuildPass) };

		private static Type[] swigMethodTypes1 = new Type[1] { typeof(BuildPass) };

		private static Type[] swigMethodTypes2 = new Type[1] { typeof(LayerTileId) };

		private static Type[] swigMethodTypes3 = new Type[2]
		{
			typeof(LayerTileId),
			typeof(Error)
		};

		private static Type[] swigMethodTypes4 = new Type[1] { typeof(LayerTileId) };

		internal IBuildCallback(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(IBuildCallback obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~IBuildCallback()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_IBuildCallback(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual void StartingPass(BuildPass buildPass)
		{
			if (SwigDerivedClassHasMethod("StartingPass", swigMethodTypes0))
			{
				NixelWrapperCPPPINVOKE.IBuildCallback_StartingPassSwigExplicitIBuildCallback(swigCPtr, (int)buildPass);
			}
			else
			{
				NixelWrapperCPPPINVOKE.IBuildCallback_StartingPass(swigCPtr, (int)buildPass);
			}
		}

		public virtual void FinishedPass(BuildPass buildPass)
		{
			if (SwigDerivedClassHasMethod("FinishedPass", swigMethodTypes1))
			{
				NixelWrapperCPPPINVOKE.IBuildCallback_FinishedPassSwigExplicitIBuildCallback(swigCPtr, (int)buildPass);
			}
			else
			{
				NixelWrapperCPPPINVOKE.IBuildCallback_FinishedPass(swigCPtr, (int)buildPass);
			}
		}

		public virtual void OnTileStart(LayerTileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				if (SwigDerivedClassHasMethod("OnTileStart", swigMethodTypes2))
				{
					NixelWrapperCPPPINVOKE.IBuildCallback_OnTileStartSwigExplicitIBuildCallback(swigCPtr, intPtr);
				}
				else
				{
					NixelWrapperCPPPINVOKE.IBuildCallback_OnTileStart(swigCPtr, intPtr);
				}
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual BuildAction OnTileFailed(LayerTileId tid, Error errorCode)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (BuildAction)(SwigDerivedClassHasMethod("OnTileFailed", swigMethodTypes3) ? NixelWrapperCPPPINVOKE.IBuildCallback_OnTileFailedSwigExplicitIBuildCallback(swigCPtr, intPtr, (int)errorCode) : NixelWrapperCPPPINVOKE.IBuildCallback_OnTileFailed(swigCPtr, intPtr, (int)errorCode));
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual BuildAction OnTileCompleted(LayerTileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (BuildAction)(SwigDerivedClassHasMethod("OnTileCompleted", swigMethodTypes4) ? NixelWrapperCPPPINVOKE.IBuildCallback_OnTileCompletedSwigExplicitIBuildCallback(swigCPtr, intPtr) : NixelWrapperCPPPINVOKE.IBuildCallback_OnTileCompleted(swigCPtr, intPtr));
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public IBuildCallback()
			: this(NixelWrapperCPPPINVOKE.new_IBuildCallback(), cMemoryOwn: true)
		{
			SwigDirectorConnect();
		}

		private void SwigDirectorConnect()
		{
			if (SwigDerivedClassHasMethod("StartingPass", swigMethodTypes0))
			{
				swigDelegate0 = SwigDirectorStartingPass;
			}
			if (SwigDerivedClassHasMethod("FinishedPass", swigMethodTypes1))
			{
				swigDelegate1 = SwigDirectorFinishedPass;
			}
			if (SwigDerivedClassHasMethod("OnTileStart", swigMethodTypes2))
			{
				swigDelegate2 = SwigDirectorOnTileStart;
			}
			if (SwigDerivedClassHasMethod("OnTileFailed", swigMethodTypes3))
			{
				swigDelegate3 = SwigDirectorOnTileFailed;
			}
			if (SwigDerivedClassHasMethod("OnTileCompleted", swigMethodTypes4))
			{
				swigDelegate4 = SwigDirectorOnTileCompleted;
			}
			NixelWrapperCPPPINVOKE.IBuildCallback_director_connect(swigCPtr, swigDelegate0, swigDelegate1, swigDelegate2, swigDelegate3, swigDelegate4);
		}

		private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes)
		{
			return GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, methodTypes, null).DeclaringType.IsSubclassOf(typeof(IBuildCallback));
		}

		private void SwigDirectorStartingPass(int buildPass)
		{
			StartingPass((BuildPass)buildPass);
		}

		private void SwigDirectorFinishedPass(int buildPass)
		{
			FinishedPass((BuildPass)buildPass);
		}

		private void SwigDirectorOnTileStart(IntPtr tid)
		{
			LayerTileId tid2 = (LayerTileId)Marshal.PtrToStructure(tid, typeof(LayerTileId));
			OnTileStart(tid2);
		}

		private int SwigDirectorOnTileFailed(IntPtr tid, int errorCode)
		{
			LayerTileId tid2 = (LayerTileId)Marshal.PtrToStructure(tid, typeof(LayerTileId));
			return (int)OnTileFailed(tid2, (Error)errorCode);
		}

		private int SwigDirectorOnTileCompleted(IntPtr tid)
		{
			LayerTileId tid2 = (LayerTileId)Marshal.PtrToStructure(tid, typeof(LayerTileId));
			return (int)OnTileCompleted(tid2);
		}
	}
	public class IBuildProgressTracker : IDisposable
	{
		public delegate void SwigDelegateIBuildProgressTracker_0(int buildPass);

		public delegate void SwigDelegateIBuildProgressTracker_1(int buildPass);

		public delegate void SwigDelegateIBuildProgressTracker_2(IntPtr tid, uint tileCountInPass);

		public delegate void SwigDelegateIBuildProgressTracker_3(uint index, uint count);

		public delegate int SwigDelegateIBuildProgressTracker_4(uint level, uint numLevels);

		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		private SwigDelegateIBuildProgressTracker_0 swigDelegate0;

		private SwigDelegateIBuildProgressTracker_1 swigDelegate1;

		private SwigDelegateIBuildProgressTracker_2 swigDelegate2;

		private SwigDelegateIBuildProgressTracker_3 swigDelegate3;

		private SwigDelegateIBuildProgressTracker_4 swigDelegate4;

		private static Type[] swigMethodTypes0 = new Type[1] { typeof(BuildPass) };

		private static Type[] swigMethodTypes1 = new Type[1] { typeof(BuildPass) };

		private static Type[] swigMethodTypes2 = new Type[2]
		{
			typeof(LayerTileId),
			typeof(uint)
		};

		private static Type[] swigMethodTypes3 = new Type[2]
		{
			typeof(uint),
			typeof(uint)
		};

		private static Type[] swigMethodTypes4 = new Type[2]
		{
			typeof(uint),
			typeof(uint)
		};

		internal IBuildProgressTracker(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(IBuildProgressTracker obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~IBuildProgressTracker()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_IBuildProgressTracker(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual void StartingPass(BuildPass buildPass)
		{
			if (SwigDerivedClassHasMethod("StartingPass", swigMethodTypes0))
			{
				NixelWrapperCPPPINVOKE.IBuildProgressTracker_StartingPassSwigExplicitIBuildProgressTracker(swigCPtr, (int)buildPass);
			}
			else
			{
				NixelWrapperCPPPINVOKE.IBuildProgressTracker_StartingPass(swigCPtr, (int)buildPass);
			}
		}

		public virtual void FinishedPass(BuildPass buildPass)
		{
			if (SwigDerivedClassHasMethod("FinishedPass", swigMethodTypes1))
			{
				NixelWrapperCPPPINVOKE.IBuildProgressTracker_FinishedPassSwigExplicitIBuildProgressTracker(swigCPtr, (int)buildPass);
			}
			else
			{
				NixelWrapperCPPPINVOKE.IBuildProgressTracker_FinishedPass(swigCPtr, (int)buildPass);
			}
		}

		public virtual void ProcessedTile(LayerTileId tid, uint tileCountInPass)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				if (SwigDerivedClassHasMethod("ProcessedTile", swigMethodTypes2))
				{
					NixelWrapperCPPPINVOKE.IBuildProgressTracker_ProcessedTileSwigExplicitIBuildProgressTracker(swigCPtr, intPtr, tileCountInPass);
				}
				else
				{
					NixelWrapperCPPPINVOKE.IBuildProgressTracker_ProcessedTile(swigCPtr, intPtr, tileCountInPass);
				}
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual void ProcessedGTex(uint index, uint count)
		{
			if (SwigDerivedClassHasMethod("ProcessedGTex", swigMethodTypes3))
			{
				NixelWrapperCPPPINVOKE.IBuildProgressTracker_ProcessedGTexSwigExplicitIBuildProgressTracker(swigCPtr, index, count);
			}
			else
			{
				NixelWrapperCPPPINVOKE.IBuildProgressTracker_ProcessedGTex(swigCPtr, index, count);
			}
		}

		public virtual CancelResult OnMipLevelGenerated(uint level, uint numLevels)
		{
			if (!SwigDerivedClassHasMethod("OnMipLevelGenerated", swigMethodTypes4))
			{
				return (CancelResult)NixelWrapperCPPPINVOKE.IBuildProgressTracker_OnMipLevelGenerated(swigCPtr, level, numLevels);
			}
			return (CancelResult)NixelWrapperCPPPINVOKE.IBuildProgressTracker_OnMipLevelGeneratedSwigExplicitIBuildProgressTracker(swigCPtr, level, numLevels);
		}

		public IBuildProgressTracker()
			: this(NixelWrapperCPPPINVOKE.new_IBuildProgressTracker(), cMemoryOwn: true)
		{
			SwigDirectorConnect();
		}

		private void SwigDirectorConnect()
		{
			if (SwigDerivedClassHasMethod("StartingPass", swigMethodTypes0))
			{
				swigDelegate0 = SwigDirectorStartingPass;
			}
			if (SwigDerivedClassHasMethod("FinishedPass", swigMethodTypes1))
			{
				swigDelegate1 = SwigDirectorFinishedPass;
			}
			if (SwigDerivedClassHasMethod("ProcessedTile", swigMethodTypes2))
			{
				swigDelegate2 = SwigDirectorProcessedTile;
			}
			if (SwigDerivedClassHasMethod("ProcessedGTex", swigMethodTypes3))
			{
				swigDelegate3 = SwigDirectorProcessedGTex;
			}
			if (SwigDerivedClassHasMethod("OnMipLevelGenerated", swigMethodTypes4))
			{
				swigDelegate4 = SwigDirectorOnMipLevelGenerated;
			}
			NixelWrapperCPPPINVOKE.IBuildProgressTracker_director_connect(swigCPtr, swigDelegate0, swigDelegate1, swigDelegate2, swigDelegate3, swigDelegate4);
		}

		private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes)
		{
			return GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, methodTypes, null).DeclaringType.IsSubclassOf(typeof(IBuildProgressTracker));
		}

		private void SwigDirectorStartingPass(int buildPass)
		{
			StartingPass((BuildPass)buildPass);
		}

		private void SwigDirectorFinishedPass(int buildPass)
		{
			FinishedPass((BuildPass)buildPass);
		}

		private void SwigDirectorProcessedTile(IntPtr tid, uint tileCountInPass)
		{
			LayerTileId tid2 = (LayerTileId)Marshal.PtrToStructure(tid, typeof(LayerTileId));
			ProcessedTile(tid2, tileCountInPass);
		}

		private void SwigDirectorProcessedGTex(uint index, uint count)
		{
			ProcessedGTex(index, count);
		}

		private int SwigDirectorOnMipLevelGenerated(uint level, uint numLevels)
		{
			return (int)OnMipLevelGenerated(level, numLevels);
		}
	}
	public class ICodecLogger : IDisposable
	{
		public delegate void SwigDelegateICodecLogger_0(IntPtr logInfo, string error);

		public delegate void SwigDelegateICodecLogger_1(IntPtr logInfo, string warning);

		public delegate void SwigDelegateICodecLogger_2(IntPtr logInfo, string message);

		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		private SwigDelegateICodecLogger_0 swigDelegate0;

		private SwigDelegateICodecLogger_1 swigDelegate1;

		private SwigDelegateICodecLogger_2 swigDelegate2;

		private static Type[] swigMethodTypes0 = new Type[2]
		{
			typeof(CodecLogInfo),
			typeof(string)
		};

		private static Type[] swigMethodTypes1 = new Type[2]
		{
			typeof(CodecLogInfo),
			typeof(string)
		};

		private static Type[] swigMethodTypes2 = new Type[2]
		{
			typeof(CodecLogInfo),
			typeof(string)
		};

		internal ICodecLogger(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ICodecLogger obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ICodecLogger()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ICodecLogger(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual void LogError(CodecLogInfo logInfo, string error)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(CodecLogInfo)));
			Marshal.StructureToPtr((object)logInfo, intPtr, fDeleteOld: false);
			try
			{
				if (SwigDerivedClassHasMethod("LogError", swigMethodTypes0))
				{
					NixelWrapperCPPPINVOKE.ICodecLogger_LogErrorSwigExplicitICodecLogger(swigCPtr, intPtr, error);
				}
				else
				{
					NixelWrapperCPPPINVOKE.ICodecLogger_LogError(swigCPtr, intPtr, error);
				}
				if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
				{
					throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual void LogWarning(CodecLogInfo logInfo, string warning)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(CodecLogInfo)));
			Marshal.StructureToPtr((object)logInfo, intPtr, fDeleteOld: false);
			try
			{
				if (SwigDerivedClassHasMethod("LogWarning", swigMethodTypes1))
				{
					NixelWrapperCPPPINVOKE.ICodecLogger_LogWarningSwigExplicitICodecLogger(swigCPtr, intPtr, warning);
				}
				else
				{
					NixelWrapperCPPPINVOKE.ICodecLogger_LogWarning(swigCPtr, intPtr, warning);
				}
				if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
				{
					throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual void LogMessage(CodecLogInfo logInfo, string message)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(CodecLogInfo)));
			Marshal.StructureToPtr((object)logInfo, intPtr, fDeleteOld: false);
			try
			{
				if (SwigDerivedClassHasMethod("LogMessage", swigMethodTypes2))
				{
					NixelWrapperCPPPINVOKE.ICodecLogger_LogMessageSwigExplicitICodecLogger(swigCPtr, intPtr, message);
				}
				else
				{
					NixelWrapperCPPPINVOKE.ICodecLogger_LogMessage(swigCPtr, intPtr, message);
				}
				if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
				{
					throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
				}
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public ICodecLogger()
			: this(NixelWrapperCPPPINVOKE.new_ICodecLogger(), cMemoryOwn: true)
		{
			SwigDirectorConnect();
		}

		private void SwigDirectorConnect()
		{
			if (SwigDerivedClassHasMethod("LogError", swigMethodTypes0))
			{
				swigDelegate0 = SwigDirectorLogError;
			}
			if (SwigDerivedClassHasMethod("LogWarning", swigMethodTypes1))
			{
				swigDelegate1 = SwigDirectorLogWarning;
			}
			if (SwigDerivedClassHasMethod("LogMessage", swigMethodTypes2))
			{
				swigDelegate2 = SwigDirectorLogMessage;
			}
			NixelWrapperCPPPINVOKE.ICodecLogger_director_connect(swigCPtr, swigDelegate0, swigDelegate1, swigDelegate2);
		}

		private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes)
		{
			return GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, methodTypes, null).DeclaringType.IsSubclassOf(typeof(ICodecLogger));
		}

		private void SwigDirectorLogError(IntPtr logInfo, string error)
		{
			CodecLogInfo logInfo2 = (CodecLogInfo)Marshal.PtrToStructure(logInfo, typeof(CodecLogInfo));
			LogError(logInfo2, error);
		}

		private void SwigDirectorLogWarning(IntPtr logInfo, string warning)
		{
			CodecLogInfo logInfo2 = (CodecLogInfo)Marshal.PtrToStructure(logInfo, typeof(CodecLogInfo));
			LogWarning(logInfo2, warning);
		}

		private void SwigDirectorLogMessage(IntPtr logInfo, string message)
		{
			CodecLogInfo logInfo2 = (CodecLogInfo)Marshal.PtrToStructure(logInfo, typeof(CodecLogInfo));
			LogMessage(logInfo2, message);
		}
	}
	public class IGtsFileReader : ITiledRasterDataRead
	{
		private HandleRef swigCPtr;

		internal IGtsFileReader(IntPtr cPtr, bool cMemoryOwn)
			: base(NixelWrapperCPPPINVOKE.IGtsFileReader_SWIGUpcast(cPtr), cMemoryOwn)
		{
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(IGtsFileReader obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~IGtsFileReader()
		{
			Dispose();
		}

		public override void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_IGtsFileReader(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
				base.Dispose();
			}
		}

		public virtual void SetOutputMode(TileDataMode outputMode)
		{
			NixelWrapperCPPPINVOKE.IGtsFileReader_SetOutputMode(swigCPtr, (int)outputMode);
		}

		public virtual Error GetTileInfo(TileId tid, out TileInfo outInfo)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			outInfo = default(TileInfo);
			IntPtr intPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TileInfo)));
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.IGtsFileReader_GetTileInfo(swigCPtr, intPtr, intPtr2);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
				outInfo = (TileInfo)Marshal.PtrToStructure(intPtr2, typeof(TileInfo));
				Marshal.FreeHGlobal(intPtr2);
			}
		}

		public virtual Error GetFlatTileInfo(uint flatTileIndex, out FlatTileInfo outInfo)
		{
			outInfo = default(FlatTileInfo);
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(FlatTileInfo)));
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.IGtsFileReader_GetFlatTileInfo(swigCPtr, flatTileIndex, intPtr);
			}
			finally
			{
				outInfo = (FlatTileInfo)Marshal.PtrToStructure(intPtr, typeof(FlatTileInfo));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual IntPtr GetMetaData()
		{
			return NixelWrapperCPPPINVOKE.IGtsFileReader_GetMetaData(swigCPtr);
		}

		public virtual uint GetMetaDataLength()
		{
			return NixelWrapperCPPPINVOKE.IGtsFileReader_GetMetaDataLength(swigCPtr);
		}

		public virtual uint GetNumThumbnails()
		{
			return NixelWrapperCPPPINVOKE.IGtsFileReader_GetNumThumbnails(swigCPtr);
		}

		public virtual Error GetThumbnail(uint index, Layout layout, out Thumbnail thumb)
		{
			thumb = default(Thumbnail);
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Thumbnail)));
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.IGtsFileReader_GetThumbnail(swigCPtr, index, layout, intPtr);
			}
			finally
			{
				thumb = (Thumbnail)Marshal.PtrToStructure(intPtr, typeof(Thumbnail));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error GetThumbNailDataType(uint index, out DataType outDataType)
		{
			int result = NixelWrapperCPPPINVOKE.IGtsFileReader_GetThumbNailDataType(swigCPtr, index, out outDataType);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
			return (Error)result;
		}

		public virtual Error GetMipTail(uint index, uint mipLevel, Layout layout, DataType dataTypeInThumb, out Thumbnail thumb)
		{
			thumb = default(Thumbnail);
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Thumbnail)));
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.IGtsFileReader_GetMipTail(swigCPtr, index, mipLevel, layout, (int)dataTypeInThumb, intPtr);
			}
			finally
			{
				thumb = (Thumbnail)Marshal.PtrToStructure(intPtr, typeof(Thumbnail));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error GetGtsInfo(out GtsInfo arg0)
		{
			arg0 = default(GtsInfo);
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(GtsInfo)));
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.IGtsFileReader_GetGtsInfo(swigCPtr, intPtr);
			}
			finally
			{
				arg0 = (GtsInfo)Marshal.PtrToStructure(intPtr, typeof(GtsInfo));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error GetPageFileInfo(uint pageFileIndex, out PageFileInfo pageFileInfo)
		{
			pageFileInfo = default(PageFileInfo);
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PageFileInfo)));
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.IGtsFileReader_GetPageFileInfo(swigCPtr, pageFileIndex, intPtr);
			}
			finally
			{
				pageFileInfo = (PageFileInfo)Marshal.PtrToStructure(intPtr, typeof(PageFileInfo));
				Marshal.FreeHGlobal(intPtr);
			}
		}
	}
	public class ILayerIndexCollection : IDisposable
	{
		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		internal ILayerIndexCollection(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ILayerIndexCollection obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ILayerIndexCollection()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ILayerIndexCollection(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual Error Add(int value)
		{
			return (Error)NixelWrapperCPPPINVOKE.ILayerIndexCollection_Add(swigCPtr, value);
		}

		public virtual uint GetSize()
		{
			return NixelWrapperCPPPINVOKE.ILayerIndexCollection_GetSize(swigCPtr);
		}

		public virtual int GetItem(uint index)
		{
			return NixelWrapperCPPPINVOKE.ILayerIndexCollection_GetItem(swigCPtr, index);
		}

		public virtual bool Contains(int value)
		{
			return NixelWrapperCPPPINVOKE.ILayerIndexCollection_Contains(swigCPtr, value);
		}
	}
	public class IMipmapGenerator : IDisposable
	{
		public delegate void SwigDelegateIMipmapGenerator_0(IntPtr pixelData, uint width, uint height, uint rowPitchInput, IntPtr userGenMask, IntPtr outPixelData, uint rowPitchOutput, uint layer, int layerDataType, uint dstLevel);

		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		private SwigDelegateIMipmapGenerator_0 swigDelegate0;

		private static Type[] swigMethodTypes0 = new Type[10]
		{
			typeof(IntPtr),
			typeof(uint),
			typeof(uint),
			typeof(uint),
			typeof(IntPtr),
			typeof(IntPtr),
			typeof(uint),
			typeof(uint),
			typeof(DataType),
			typeof(uint)
		};

		internal IMipmapGenerator(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(IMipmapGenerator obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~IMipmapGenerator()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_IMipmapGenerator(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual void GenerateMipmapData(IntPtr pixelData, uint width, uint height, uint rowPitchInput, IntPtr userGenMask, IntPtr outPixelData, uint rowPitchOutput, uint layer, DataType layerDataType, uint dstLevel)
		{
			NixelWrapperCPPPINVOKE.IMipmapGenerator_GenerateMipmapData(swigCPtr, pixelData, width, height, rowPitchInput, userGenMask, outPixelData, rowPitchOutput, layer, (int)layerDataType, dstLevel);
		}

		public IMipmapGenerator()
			: this(NixelWrapperCPPPINVOKE.new_IMipmapGenerator(), cMemoryOwn: true)
		{
			SwigDirectorConnect();
		}

		private void SwigDirectorConnect()
		{
			if (SwigDerivedClassHasMethod("GenerateMipmapData", swigMethodTypes0))
			{
				swigDelegate0 = SwigDirectorGenerateMipmapData;
			}
			NixelWrapperCPPPINVOKE.IMipmapGenerator_director_connect(swigCPtr, swigDelegate0);
		}

		private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes)
		{
			return GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, methodTypes, null).DeclaringType.IsSubclassOf(typeof(IMipmapGenerator));
		}

		private void SwigDirectorGenerateMipmapData(IntPtr pixelData, uint width, uint height, uint rowPitchInput, IntPtr userGenMask, IntPtr outPixelData, uint rowPitchOutput, uint layer, int layerDataType, uint dstLevel)
		{
			GenerateMipmapData(pixelData, width, height, rowPitchInput, userGenMask, outPixelData, rowPitchOutput, layer, (DataType)layerDataType, dstLevel);
		}
	}
	public class IPackedSoupFileCollection : IDisposable
	{
		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		internal IPackedSoupFileCollection(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(IPackedSoupFileCollection obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~IPackedSoupFileCollection()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_IPackedSoupFileCollection(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual Error Add(PackedSoupFile psf)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PackedSoupFile)));
			Marshal.StructureToPtr((object)psf, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.IPackedSoupFileCollection_Add(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual uint GetSize()
		{
			return NixelWrapperCPPPINVOKE.IPackedSoupFileCollection_GetSize(swigCPtr);
		}

		public virtual PackedSoupFile GetItem(uint index)
		{
			return (PackedSoupFile)Marshal.PtrToStructure(NixelWrapperCPPPINVOKE.IPackedSoupFileCollection_GetItem__SWIG_0(swigCPtr, index), typeof(PackedSoupFile));
		}
	}
	public class ITiled : IDisposable
	{
		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		internal ITiled(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ITiled obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ITiled()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ITiled(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual TiledTopology GetTopology()
		{
			return (TiledTopology)Marshal.PtrToStructure(NixelWrapperCPPPINVOKE.ITiled_GetTopology(swigCPtr), typeof(TiledTopology));
		}
	}
	public class ITiledBuildParameters : ITiled
	{
		private HandleRef swigCPtr;

		internal ITiledBuildParameters(IntPtr cPtr, bool cMemoryOwn)
			: base(NixelWrapperCPPPINVOKE.ITiledBuildParameters_SWIGUpcast(cPtr), cMemoryOwn)
		{
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ITiledBuildParameters obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ITiledBuildParameters()
		{
			Dispose();
		}

		public override void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ITiledBuildParameters(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
				base.Dispose();
			}
		}

		public virtual IntPtr GetMetadata()
		{
			return NixelWrapperCPPPINVOKE.ITiledBuildParameters_GetMetadata(swigCPtr);
		}

		public virtual uint GetMetadataSize()
		{
			return NixelWrapperCPPPINVOKE.ITiledBuildParameters_GetMetadataSize(swigCPtr);
		}

		public virtual Error SetMetadata(IntPtr data, uint size)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledBuildParameters_SetMetadata(swigCPtr, data, size);
		}

		public virtual Error RemoveMetadata()
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledBuildParameters_RemoveMetadata(swigCPtr);
		}

		public virtual Error SetThumbnail(GraphineGuid identifier, uint width, uint height, uint numLevels, DataType inputFormat, IntPtr[] inputLevelData, TextureFormat compressedFormat)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledBuildParameters_SetThumbnail(swigCPtr, identifier, width, height, numLevels, (int)inputFormat, inputLevelData, (int)compressedFormat);
		}

		public virtual Error ClearThumbnail(GraphineGuid identifier)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledBuildParameters_ClearThumbnail(swigCPtr, identifier);
		}

		public virtual Error AddTileLayerCodingGroup(uint layer, int codecTypeId, string xmlCodingParameters, out int outLayerCodingGroupIndex)
		{
			int result = NixelWrapperCPPPINVOKE.ITiledBuildParameters_AddTileLayerCodingGroup(swigCPtr, layer, codecTypeId, xmlCodingParameters, out outLayerCodingGroupIndex);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
			return (Error)result;
		}

		public virtual Error ClearAllTileLayerCodingGroups()
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledBuildParameters_ClearAllTileLayerCodingGroups(swigCPtr);
		}

		public virtual Error SetTileLayerCodingGroup(LayerTileId tid, int layerCodingGroupIndex)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledBuildParameters_SetTileLayerCodingGroup(swigCPtr, intPtr, layerCodingGroupIndex);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual int GetTileLayerCodingGroupIndex(LayerTileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return NixelWrapperCPPPINVOKE.ITiledBuildParameters_GetTileLayerCodingGroupIndex(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual uint GetNumTileLayerCodingGroups()
		{
			return NixelWrapperCPPPINVOKE.ITiledBuildParameters_GetNumTileLayerCodingGroups(swigCPtr);
		}

		public virtual Error SetLayerCodingGroup(uint layer, int layerCodingGroupIndex)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledBuildParameters_SetLayerCodingGroup(swigCPtr, layer, layerCodingGroupIndex);
		}

		public virtual Error GetTileLayerCodingGroup(int layerCodingGroupIndex, out TileLayerCodingGroup codingGroup)
		{
			codingGroup = default(TileLayerCodingGroup);
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TileLayerCodingGroup)));
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledBuildParameters_GetTileLayerCodingGroup(swigCPtr, layerCodingGroupIndex, intPtr);
			}
			finally
			{
				codingGroup = (TileLayerCodingGroup)Marshal.PtrToStructure(intPtr, typeof(TileLayerCodingGroup));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual void EnableUniformCoding(int layer, bool enable)
		{
			NixelWrapperCPPPINVOKE.ITiledBuildParameters_EnableUniformCoding(swigCPtr, layer, enable);
		}

		public virtual bool IsUniformCodingEnabled(int layer)
		{
			return NixelWrapperCPPPINVOKE.ITiledBuildParameters_IsUniformCodingEnabled(swigCPtr, layer);
		}
	}
	public class ITiledRasterData : ITiledRasterDataRead
	{
		private HandleRef swigCPtr;

		internal ITiledRasterData(IntPtr cPtr, bool cMemoryOwn)
			: base(NixelWrapperCPPPINVOKE.ITiledRasterData_SWIGUpcast(cPtr), cMemoryOwn)
		{
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ITiledRasterData obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ITiledRasterData()
		{
			Dispose();
		}

		public override void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ITiledRasterData(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
				base.Dispose();
			}
		}

		public virtual Error SetPixel(uint x, uint y, uint level, uint layer, IntPtr newValue)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_SetPixel(swigCPtr, x, y, level, layer, newValue);
		}

		public virtual Error SetLine(uint offsetX, uint offsetY, uint level, uint layer, uint linePixelWidth, IntPtr pixels, Layout layout)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Layout)));
			Marshal.StructureToPtr((object)layout, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_SetLine__SWIG_0(swigCPtr, offsetX, offsetY, level, layer, linePixelWidth, pixels, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error SetLine(uint offsetX, uint offsetY, uint level, uint layer, uint linePixelWidth, IntPtr pixels)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_SetLine__SWIG_1(swigCPtr, offsetX, offsetY, level, layer, linePixelWidth, pixels);
		}

		public virtual Error ClearLine(uint offsetX, uint offsetY, uint level, uint layer, uint linePixelWidth)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_ClearLine(swigCPtr, offsetX, offsetY, level, layer, linePixelWidth);
		}

		public virtual Error ClearRectangle(uint offsetX, uint offsetY, uint width, uint height, uint level, uint layer)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_ClearRectangle(swigCPtr, offsetX, offsetY, width, height, level, layer);
		}

		public virtual Error RemoveTileRectangle(uint pixelOffsetX, uint pixelOffsetY, uint pixelWidth, uint pixelHeight, uint level, uint layer)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_RemoveTileRectangle(swigCPtr, pixelOffsetX, pixelOffsetY, pixelWidth, pixelHeight, level, layer);
		}

		public virtual Error SetRectangle(uint offsetX, uint offsetY, uint level, uint layer, uint pixelWidth, uint pixelHeight, IntPtr pixels, Layout layout)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Layout)));
			Marshal.StructureToPtr((object)layout, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_SetRectangle__SWIG_0(swigCPtr, offsetX, offsetY, level, layer, pixelWidth, pixelHeight, pixels, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error SetRectangle(uint offsetX, uint offsetY, uint level, uint layer, uint pixelWidth, uint pixelHeight, IntPtr pixels)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_SetRectangle__SWIG_1(swigCPtr, offsetX, offsetY, level, layer, pixelWidth, pixelHeight, pixels);
		}

		public virtual Error SetTile(LayerTileId tileId, IntPtr pixels, bool setBorderToUserMapped)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tileId, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_SetTile(swigCPtr, intPtr, pixels, setBorderToUserMapped);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error GetTile(LayerTileId tileId, IntPtr pixels)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tileId, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_GetTile(swigCPtr, intPtr, pixels);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error MapTileLayerWrite(LayerTileId tid, bool mapBorders, WriteMapType mapType, out MappedTileLayer outMappedTileLayer)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			outMappedTileLayer = default(MappedTileLayer);
			IntPtr intPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MappedTileLayer)));
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_MapTileLayerWrite(swigCPtr, intPtr, mapBorders, (int)mapType, intPtr2);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
				outMappedTileLayer = (MappedTileLayer)Marshal.PtrToStructure(intPtr2, typeof(MappedTileLayer));
				Marshal.FreeHGlobal(intPtr2);
			}
		}

		public virtual Error UnMapTileLayerWrite(LayerTileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_UnMapTileLayerWrite(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error SetMipmapGenerator(IMipmapGenerator mipmapGenerator)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_SetMipmapGenerator(swigCPtr, IMipmapGenerator.getCPtr(mipmapGenerator));
		}

		public virtual Error AutoGenerateLevels()
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_AutoGenerateLevels(swigCPtr);
		}

		public virtual Error AllocateTileLayer(LayerTileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_AllocateTileLayer(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error RemoveTileLayer(LayerTileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_RemoveTileLayer(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error ClearTileLayer(LayerTileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_ClearTileLayer(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error AllocateTile(TileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_AllocateTile(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error RemoveTile(TileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_RemoveTile(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error AutoGenerateTileLayer(LayerTileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_AutoGenerateTileLayer(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error AutoGenerateBorderInfo(LayerTileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_AutoGenerateBorderInfo(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error SetCubemapBorderRegion(uint tileX, uint tileY, uint numTilesX, uint numTilesY, uint level, uint cubeId, int faceIndex)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_SetCubemapBorderRegion(swigCPtr, tileX, tileY, numTilesX, numTilesY, level, cubeId, faceIndex);
		}

		public virtual Error ClearCubemapBorderRegions()
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_ClearCubemapBorderRegions(swigCPtr);
		}

		public virtual void RegisterUserSetRectangle(uint x, uint y, uint width, uint height, uint level, uint layer)
		{
			NixelWrapperCPPPINVOKE.ITiledRasterData_RegisterUserSetRectangle(swigCPtr, x, y, width, height, level, layer);
		}

		public virtual void ClearUserSetRectangles()
		{
			NixelWrapperCPPPINVOKE.ITiledRasterData_ClearUserSetRectangles(swigCPtr);
		}

		public virtual void RegisterAssetRectangle(uint x, uint y, uint width, uint height, uint id, BorderMode borderMode)
		{
			NixelWrapperCPPPINVOKE.ITiledRasterData_RegisterAssetRectangle(swigCPtr, x, y, width, height, id, (int)borderMode);
		}

		public virtual void ClearAssetRectangles()
		{
			NixelWrapperCPPPINVOKE.ITiledRasterData_ClearAssetRectangles(swigCPtr);
		}

		public virtual Error MakePersistent()
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_MakePersistent(swigCPtr);
		}

		public virtual Error SetBuildProgressTracker(IBuildProgressTracker tracker)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_SetBuildProgressTracker(swigCPtr, IBuildProgressTracker.getCPtr(tracker));
		}

		public virtual Error RegisterThumbnail(GraphineGuid identifier, uint width, uint height, uint numLevels, DataType dataType, bool dropFirst, IntPtr[] levelPointers)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterData_RegisterThumbnail(swigCPtr, identifier, width, height, numLevels, (int)dataType, dropFirst, levelPointers);
		}

		public virtual uint GetThumbnailNumLevels(GraphineGuid identifier)
		{
			return NixelWrapperCPPPINVOKE.ITiledRasterData_GetThumbnailNumLevels(swigCPtr, identifier);
		}

		public virtual IntPtr GetThumbnailData(GraphineGuid identifier, uint level, out uint outWidth, out uint outHeight, out DataType outDataType)
		{
			IntPtr result = NixelWrapperCPPPINVOKE.ITiledRasterData_GetThumbnailData(swigCPtr, identifier, level, out outWidth, out outHeight, out outDataType);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}
	}
	public class ITiledRasterDataRead : ITiled
	{
		private HandleRef swigCPtr;

		internal ITiledRasterDataRead(IntPtr cPtr, bool cMemoryOwn)
			: base(NixelWrapperCPPPINVOKE.ITiledRasterDataRead_SWIGUpcast(cPtr), cMemoryOwn)
		{
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ITiledRasterDataRead obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ITiledRasterDataRead()
		{
			Dispose();
		}

		public override void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ITiledRasterDataRead(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
				base.Dispose();
			}
		}

		public virtual RasterTileDimension GetTileDimensions()
		{
			return (RasterTileDimension)Marshal.PtrToStructure(NixelWrapperCPPPINVOKE.ITiledRasterDataRead_GetTileDimensions(swigCPtr), typeof(RasterTileDimension));
		}

		public virtual Error GetPixelSize(uint layerIndex, out uint pixelSize)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterDataRead_GetPixelSize(swigCPtr, layerIndex, out pixelSize);
		}

		public virtual Error GetPixel(uint x, uint y, uint level, uint layer, IntPtr pixel)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterDataRead_GetPixel(swigCPtr, x, y, level, layer, pixel);
		}

		public virtual Error GetLine(uint x, uint y, uint level, uint layer, uint linePixelWidth, IntPtr pixels)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterDataRead_GetLine(swigCPtr, x, y, level, layer, linePixelWidth, pixels);
		}

		public virtual Error GetRectangle(uint x, uint y, uint level, uint layer, uint rectPixelWidth, uint rectPixelHeight, IntPtr pixels)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITiledRasterDataRead_GetRectangle(swigCPtr, x, y, level, layer, rectPixelWidth, rectPixelHeight, pixels);
		}

		public virtual Error MapTileLayerRead(LayerTileId tid, bool mapBorders, out MappedTileLayerRead outMappedTileLayer)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			outMappedTileLayer = default(MappedTileLayerRead);
			IntPtr intPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(MappedTileLayerRead)));
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterDataRead_MapTileLayerRead(swigCPtr, intPtr, mapBorders, intPtr2);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
				outMappedTileLayer = (MappedTileLayerRead)Marshal.PtrToStructure(intPtr2, typeof(MappedTileLayerRead));
				Marshal.FreeHGlobal(intPtr2);
			}
		}

		public virtual Error UnMapTileLayerRead(LayerTileId tid)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tid, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITiledRasterDataRead_UnMapTileLayerRead(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}
	}
	public class ITileFileFactory : IDisposable
	{
		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		internal ITileFileFactory(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ITileFileFactory obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ITileFileFactory()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ITileFileFactory(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public static Error Initialize(ref NixelInitializationInfo initContext)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(NixelInitializationInfo)));
			Marshal.StructureToPtr((object)initContext, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileFileFactory_Initialize(intPtr);
			}
			finally
			{
				initContext = (NixelInitializationInfo)Marshal.PtrToStructure(intPtr, typeof(NixelInitializationInfo));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public static Error Release()
		{
			return (Error)NixelWrapperCPPPINVOKE.ITileFileFactory_Release();
		}

		public static Error CreateTiledRasterData(TiledTopology tiledTopology, RasterTileDimension rasterTileDimension, uint maxCacheSizeInBytes, string rasterDataCacheFilename, out ITiledRasterData tiledRasterData)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TiledTopology)));
			Marshal.StructureToPtr((object)tiledTopology, intPtr, fDeleteOld: false);
			IntPtr intPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(RasterTileDimension)));
			Marshal.StructureToPtr((object)rasterTileDimension, intPtr2, fDeleteOld: false);
			IntPtr jarg = IntPtr.Zero;
			try
			{
				int result = NixelWrapperCPPPINVOKE.ITileFileFactory_CreateTiledRasterData(intPtr, intPtr2, maxCacheSizeInBytes, rasterDataCacheFilename, out jarg);
				if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
				{
					throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
				}
				return (Error)result;
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
				Marshal.FreeHGlobal(intPtr2);
				tiledRasterData = ((jarg == IntPtr.Zero) ? null : new ITiledRasterData(jarg, cMemoryOwn: true));
			}
		}

		public static Error CreateTiledBuildParameters(TiledTopology tiledTopology, out ITiledBuildParameters tiledBuildParameters)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TiledTopology)));
			Marshal.StructureToPtr((object)tiledTopology, intPtr, fDeleteOld: false);
			IntPtr jarg = IntPtr.Zero;
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileFileFactory_CreateTiledBuildParameters(intPtr, out jarg);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
				tiledBuildParameters = ((jarg == IntPtr.Zero) ? null : new ITiledBuildParameters(jarg, cMemoryOwn: true));
			}
		}

		public static Error CreateTileSoupBuilder(ITiledRasterData tiledRasterData, ITiledBuildParameters tiledBuildParameters, BuildHeader buildHeader, out ITileSoupBuilder tileSoupBuilder)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BuildHeader)));
			Marshal.StructureToPtr((object)buildHeader, intPtr, fDeleteOld: false);
			IntPtr jarg = IntPtr.Zero;
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileFileFactory_CreateTileSoupBuilder(ITiledRasterData.getCPtr(tiledRasterData), ITiledBuildParameters.getCPtr(tiledBuildParameters), intPtr, out jarg);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
				tileSoupBuilder = ((jarg == IntPtr.Zero) ? null : new ITileSoupBuilder(jarg, cMemoryOwn: true));
			}
		}

		public static Error CreateTileSetRebuilder(out ITileSetRebuilder tileSetRebuilder)
		{
			IntPtr jarg = IntPtr.Zero;
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileFileFactory_CreateTileSetRebuilder(out jarg);
			}
			finally
			{
				tileSetRebuilder = ((jarg == IntPtr.Zero) ? null : new ITileSetRebuilder(jarg, cMemoryOwn: true));
			}
		}

		public static Error CreateTileFileReader(string fileName, uint maxCacheSizeInBytes, out ITiledRasterDataRead tileFileReader)
		{
			IntPtr jarg = IntPtr.Zero;
			try
			{
				int result = NixelWrapperCPPPINVOKE.ITileFileFactory_CreateTileFileReader(fileName, maxCacheSizeInBytes, out jarg);
				if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
				{
					throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
				}
				return (Error)result;
			}
			finally
			{
				tileFileReader = ((jarg == IntPtr.Zero) ? null : new ITiledRasterDataRead(jarg, cMemoryOwn: true));
			}
		}

		public static Error CreateGtsFileReader(string fileName, StringVector pageFileDirectories, uint maxCacheSizeInBytes, out IGtsFileReader gtsFileReader)
		{
			IntPtr jarg = IntPtr.Zero;
			try
			{
				int result = NixelWrapperCPPPINVOKE.ITileFileFactory_CreateGtsFileReader(fileName, StringVector.getCPtr(pageFileDirectories), maxCacheSizeInBytes, out jarg);
				if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
				{
					throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
				}
				return (Error)result;
			}
			finally
			{
				gtsFileReader = ((jarg == IntPtr.Zero) ? null : new IGtsFileReader(jarg, cMemoryOwn: true));
			}
		}

		public static Error CreateTileSoupFileReader(string soupFilename, out ITileSoupFileReader soupFileReader)
		{
			IntPtr jarg = IntPtr.Zero;
			try
			{
				int result = NixelWrapperCPPPINVOKE.ITileFileFactory_CreateTileSoupFileReader(soupFilename, out jarg);
				if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
				{
					throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
				}
				return (Error)result;
			}
			finally
			{
				soupFileReader = ((jarg == IntPtr.Zero) ? null : new ITileSoupFileReader(jarg, cMemoryOwn: true));
			}
		}

		public static void GetLastError(out ErrorInfo errorInfo)
		{
			errorInfo = default(ErrorInfo);
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(ErrorInfo)));
			try
			{
				NixelWrapperCPPPINVOKE.ITileFileFactory_GetLastError(intPtr);
			}
			finally
			{
				errorInfo = (ErrorInfo)Marshal.PtrToStructure(intPtr, typeof(ErrorInfo));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public static void GetLibraryVersion(out LibraryVersionInfo info)
		{
			info = default(LibraryVersionInfo);
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LibraryVersionInfo)));
			try
			{
				NixelWrapperCPPPINVOKE.ITileFileFactory_GetLibraryVersion(intPtr);
			}
			finally
			{
				info = (LibraryVersionInfo)Marshal.PtrToStructure(intPtr, typeof(LibraryVersionInfo));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public static Error CreateTileSoupCollection(out IPackedSoupFileCollection soupFileCollection)
		{
			IntPtr jarg = IntPtr.Zero;
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileFileFactory_CreateTileSoupCollection(out jarg);
			}
			finally
			{
				soupFileCollection = ((jarg == IntPtr.Zero) ? null : new IPackedSoupFileCollection(jarg, cMemoryOwn: true));
			}
		}

		public static Error CreateLayerIndexCollection(out ILayerIndexCollection outLayerIndexCollection)
		{
			IntPtr jarg = IntPtr.Zero;
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileFileFactory_CreateLayerIndexCollection(out jarg);
			}
			finally
			{
				outLayerIndexCollection = ((jarg == IntPtr.Zero) ? null : new ILayerIndexCollection(jarg, cMemoryOwn: true));
			}
		}

		public ITileFileFactory()
			: this(NixelWrapperCPPPINVOKE.new_ITileFileFactory(), cMemoryOwn: true)
		{
		}
	}
	public class ITileOrder : IDisposable
	{
		public delegate void SwigDelegateITileOrder_0();

		public delegate bool SwigDelegateITileOrder_1(IntPtr arg0);

		public delegate bool SwigDelegateITileOrder_2(IntPtr arg0, IntPtr preview, int previewCount);

		public delegate uint SwigDelegateITileOrder_3();

		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		private SwigDelegateITileOrder_0 swigDelegate0;

		private SwigDelegateITileOrder_1 swigDelegate1;

		private SwigDelegateITileOrder_2 swigDelegate2;

		private SwigDelegateITileOrder_3 swigDelegate3;

		private static Type[] swigMethodTypes0 = new Type[0];

		private static Type[] swigMethodTypes1 = new Type[1] { typeof(TileOrderItem).MakeByRefType() };

		private static Type[] swigMethodTypes2 = new Type[3]
		{
			typeof(SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem),
			typeof(SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem),
			typeof(int)
		};

		private static Type[] swigMethodTypes3 = new Type[0];

		internal ITileOrder(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ITileOrder obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ITileOrder()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ITileOrder(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual void Reset()
		{
			NixelWrapperCPPPINVOKE.ITileOrder_Reset(swigCPtr);
		}

		public virtual bool Next(out TileOrderItem arg0)
		{
			arg0 = default(TileOrderItem);
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TileOrderItem)));
			try
			{
				return NixelWrapperCPPPINVOKE.ITileOrder_Next__SWIG_0(swigCPtr, intPtr);
			}
			finally
			{
				arg0 = (TileOrderItem)Marshal.PtrToStructure(intPtr, typeof(TileOrderItem));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual bool Next(SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem arg0, SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem preview, int previewCount)
		{
			return NixelWrapperCPPPINVOKE.ITileOrder_Next__SWIG_1(swigCPtr, SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem.getCPtr(arg0), SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem.getCPtr(preview), previewCount);
		}

		public virtual uint Count()
		{
			return NixelWrapperCPPPINVOKE.ITileOrder_Count(swigCPtr);
		}

		public ITileOrder()
			: this(NixelWrapperCPPPINVOKE.new_ITileOrder(), cMemoryOwn: true)
		{
			SwigDirectorConnect();
		}

		private void SwigDirectorConnect()
		{
			if (SwigDerivedClassHasMethod("Reset", swigMethodTypes0))
			{
				swigDelegate0 = SwigDirectorReset;
			}
			if (SwigDerivedClassHasMethod("Next", swigMethodTypes1))
			{
				swigDelegate1 = SwigDirectorNext__SWIG_0;
			}
			if (SwigDerivedClassHasMethod("Next", swigMethodTypes2))
			{
				swigDelegate2 = SwigDirectorNext__SWIG_1;
			}
			if (SwigDerivedClassHasMethod("Count", swigMethodTypes3))
			{
				swigDelegate3 = SwigDirectorCount;
			}
			NixelWrapperCPPPINVOKE.ITileOrder_director_connect(swigCPtr, swigDelegate0, swigDelegate1, swigDelegate2, swigDelegate3);
		}

		private bool SwigDerivedClassHasMethod(string methodName, Type[] methodTypes)
		{
			return GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, methodTypes, null).DeclaringType.IsSubclassOf(typeof(ITileOrder));
		}

		private void SwigDirectorReset()
		{
			Reset();
		}

		private bool SwigDirectorNext__SWIG_0(IntPtr arg0)
		{
			TileOrderItem arg = default(TileOrderItem);
			try
			{
				return Next(out arg);
			}
			finally
			{
				Marshal.StructureToPtr((object)arg, arg0, fDeleteOld: true);
			}
		}

		private bool SwigDirectorNext__SWIG_1(IntPtr arg0, IntPtr preview, int previewCount)
		{
			return Next((arg0 == IntPtr.Zero) ? null : new SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem(arg0, futureUse: false), (preview == IntPtr.Zero) ? null : new SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem(preview, futureUse: false), previewCount);
		}

		private uint SwigDirectorCount()
		{
			return Count();
		}
	}
	public class ITileSetRebuilder : IDisposable
	{
		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		internal ITileSetRebuilder(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ITileSetRebuilder obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ITileSetRebuilder()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ITileSetRebuilder(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual Error SetBuildProgressTracker(IBuildProgressTracker tracker)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITileSetRebuilder_SetBuildProgressTracker(swigCPtr, IBuildProgressTracker.getCPtr(tracker));
		}

		public virtual Error Begin(RebuilderSettings rebuilderSettings)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(RebuilderSettings)));
			Marshal.StructureToPtr((object)rebuilderSettings, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSetRebuilder_Begin(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error Rebuild(RebuilderSettings rebuilderSettings, PagingSettings pagingSettings, IPackedSoupFileCollection soupCollection, ITiledBuildParameters sharedMipBuildParams, ITileOrder tileOrder)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(RebuilderSettings)));
			Marshal.StructureToPtr((object)rebuilderSettings, intPtr, fDeleteOld: false);
			IntPtr intPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PagingSettings)));
			Marshal.StructureToPtr((object)pagingSettings, intPtr2, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSetRebuilder_Rebuild__SWIG_0(swigCPtr, intPtr, intPtr2, IPackedSoupFileCollection.getCPtr(soupCollection), ITiledBuildParameters.getCPtr(sharedMipBuildParams), ITileOrder.getCPtr(tileOrder));
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
				Marshal.FreeHGlobal(intPtr2);
			}
		}

		public virtual Error Rebuild(RebuilderSettings rebuilderSettings, PagingSettings pagingSettings, IPackedSoupFileCollection soupCollection, ITiledBuildParameters sharedMipBuildParams)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(RebuilderSettings)));
			Marshal.StructureToPtr((object)rebuilderSettings, intPtr, fDeleteOld: false);
			IntPtr intPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PagingSettings)));
			Marshal.StructureToPtr((object)pagingSettings, intPtr2, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSetRebuilder_Rebuild__SWIG_1(swigCPtr, intPtr, intPtr2, IPackedSoupFileCollection.getCPtr(soupCollection), ITiledBuildParameters.getCPtr(sharedMipBuildParams));
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
				Marshal.FreeHGlobal(intPtr2);
			}
		}

		public virtual Error Rebuild(RebuilderSettings rebuilderSettings, PagingSettings pagingSettings, IPackedSoupFileCollection soupCollection)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(RebuilderSettings)));
			Marshal.StructureToPtr((object)rebuilderSettings, intPtr, fDeleteOld: false);
			IntPtr intPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(PagingSettings)));
			Marshal.StructureToPtr((object)pagingSettings, intPtr2, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSetRebuilder_Rebuild__SWIG_2(swigCPtr, intPtr, intPtr2, IPackedSoupFileCollection.getCPtr(soupCollection));
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
				Marshal.FreeHGlobal(intPtr2);
			}
		}

		public virtual Error GetBuildReport(out BuildReport report)
		{
			report = default(BuildReport);
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(BuildReport)));
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSetRebuilder_GetBuildReport(swigCPtr, intPtr);
			}
			finally
			{
				report = (BuildReport)Marshal.PtrToStructure(intPtr, typeof(BuildReport));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error GetMetaData(string soupIndexFilename, out IntPtr metaData, out uint metaDataSize)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITileSetRebuilder_GetMetaData(swigCPtr, soupIndexFilename, out metaData, out metaDataSize);
		}

		public virtual Error SetMetaData(IntPtr metaData, uint metaDataSize)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITileSetRebuilder_SetMetaData(swigCPtr, metaData, metaDataSize);
		}

		public virtual Error ClearMetaDataOverride()
		{
			return (Error)NixelWrapperCPPPINVOKE.ITileSetRebuilder_ClearMetaDataOverride(swigCPtr);
		}
	}
	public class ITileSoupBuilder : IDisposable
	{
		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		internal ITileSoupBuilder(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ITileSoupBuilder obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ITileSoupBuilder()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ITileSoupBuilder(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual Error Build(SoupBuilderSettings soupBuilderSettings, BuildMode mode, ILayerIndexCollection patchLayerIndices)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(SoupBuilderSettings)));
			Marshal.StructureToPtr((object)soupBuilderSettings, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSoupBuilder_Build(swigCPtr, intPtr, (int)mode, ILayerIndexCollection.getCPtr(patchLayerIndices));
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error Begin(SoupBuilderSettings soupBuilderSettings, BuildMode mode, ILayerIndexCollection patchLayerIndices, int maxNumEncodedTilesInCache)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(SoupBuilderSettings)));
			Marshal.StructureToPtr((object)soupBuilderSettings, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSoupBuilder_Begin(swigCPtr, intPtr, (int)mode, ILayerIndexCollection.getCPtr(patchLayerIndices), maxNumEncodedTilesInCache);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error EncodeTile(LayerTileId tileId)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tileId, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSoupBuilder_EncodeTile(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error WriteTile(LayerTileId tileId)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LayerTileId)));
			Marshal.StructureToPtr((object)tileId, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSoupBuilder_WriteTile(swigCPtr, intPtr);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error End()
		{
			return (Error)NixelWrapperCPPPINVOKE.ITileSoupBuilder_End(swigCPtr);
		}

		public virtual Error SetBuildProgressTracker(IBuildProgressTracker tracker)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITileSoupBuilder_SetBuildProgressTracker(swigCPtr, IBuildProgressTracker.getCPtr(tracker));
		}

		public virtual Error SetBuildCallback(IBuildCallback buildCallback)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITileSoupBuilder_SetBuildCallback(swigCPtr, IBuildCallback.getCPtr(buildCallback));
		}

		public virtual Error SetCodecLogger(ICodecLogger logger)
		{
			return (Error)NixelWrapperCPPPINVOKE.ITileSoupBuilder_SetCodecLogger(swigCPtr, ICodecLogger.getCPtr(logger));
		}
	}
	public class ITileSoupFileReader : IDisposable
	{
		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		internal ITileSoupFileReader(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(ITileSoupFileReader obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~ITileSoupFileReader()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_ITileSoupFileReader(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public virtual IntPtr GetMetaData()
		{
			return NixelWrapperCPPPINVOKE.ITileSoupFileReader_GetMetaData(swigCPtr);
		}

		public virtual uint GetMetaDataLength()
		{
			return NixelWrapperCPPPINVOKE.ITileSoupFileReader_GetMetaDataLength(swigCPtr);
		}

		public virtual Error GetTileDimensions(ref RasterTileDimension dimensions)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(RasterTileDimension)));
			Marshal.StructureToPtr((object)dimensions, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSoupFileReader_GetTileDimensions(swigCPtr, intPtr);
			}
			finally
			{
				dimensions = (RasterTileDimension)Marshal.PtrToStructure(intPtr, typeof(RasterTileDimension));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public virtual Error GetTiledTopology(ref TiledTopology topology)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TiledTopology)));
			Marshal.StructureToPtr((object)topology, intPtr, fDeleteOld: false);
			try
			{
				return (Error)NixelWrapperCPPPINVOKE.ITileSoupFileReader_GetTiledTopology(swigCPtr, intPtr);
			}
			finally
			{
				topology = (TiledTopology)Marshal.PtrToStructure(intPtr, typeof(TiledTopology));
				Marshal.FreeHGlobal(intPtr);
			}
		}
	}
	public class NixelWrapperCPP
	{
	}
	internal class NixelWrapperCPPPINVOKE
	{
		protected class SWIGExceptionHelper
		{
			public delegate void ExceptionDelegate(string message);

			public delegate void ExceptionArgumentDelegate(string message, string paramName);

			private static ExceptionDelegate applicationDelegate;

			private static ExceptionDelegate arithmeticDelegate;

			private static ExceptionDelegate divideByZeroDelegate;

			private static ExceptionDelegate indexOutOfRangeDelegate;

			private static ExceptionDelegate invalidCastDelegate;

			private static ExceptionDelegate invalidOperationDelegate;

			private static ExceptionDelegate ioDelegate;

			private static ExceptionDelegate nullReferenceDelegate;

			private static ExceptionDelegate outOfMemoryDelegate;

			private static ExceptionDelegate overflowDelegate;

			private static ExceptionDelegate systemDelegate;

			private static ExceptionArgumentDelegate argumentDelegate;

			private static ExceptionArgumentDelegate argumentNullDelegate;

			private static ExceptionArgumentDelegate argumentOutOfRangeDelegate;

			[DllImport("NixelWrapperCPP")]
			public static extern void SWIGRegisterExceptionCallbacks_NixelWrapperCPP(ExceptionDelegate applicationDelegate, ExceptionDelegate arithmeticDelegate, ExceptionDelegate divideByZeroDelegate, ExceptionDelegate indexOutOfRangeDelegate, ExceptionDelegate invalidCastDelegate, ExceptionDelegate invalidOperationDelegate, ExceptionDelegate ioDelegate, ExceptionDelegate nullReferenceDelegate, ExceptionDelegate outOfMemoryDelegate, ExceptionDelegate overflowDelegate, ExceptionDelegate systemExceptionDelegate);

			[DllImport("NixelWrapperCPP", EntryPoint = "SWIGRegisterExceptionArgumentCallbacks_NixelWrapperCPP")]
			public static extern void SWIGRegisterExceptionCallbacksArgument_NixelWrapperCPP(ExceptionArgumentDelegate argumentDelegate, ExceptionArgumentDelegate argumentNullDelegate, ExceptionArgumentDelegate argumentOutOfRangeDelegate);

			private static void SetPendingApplicationException(string message)
			{
				SWIGPendingException.Set(new ApplicationException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingArithmeticException(string message)
			{
				SWIGPendingException.Set(new ArithmeticException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingDivideByZeroException(string message)
			{
				SWIGPendingException.Set(new DivideByZeroException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingIndexOutOfRangeException(string message)
			{
				SWIGPendingException.Set(new IndexOutOfRangeException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingInvalidCastException(string message)
			{
				SWIGPendingException.Set(new InvalidCastException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingInvalidOperationException(string message)
			{
				SWIGPendingException.Set(new InvalidOperationException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingIOException(string message)
			{
				SWIGPendingException.Set(new IOException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingNullReferenceException(string message)
			{
				SWIGPendingException.Set(new NullReferenceException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingOutOfMemoryException(string message)
			{
				SWIGPendingException.Set(new OutOfMemoryException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingOverflowException(string message)
			{
				SWIGPendingException.Set(new OverflowException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingSystemException(string message)
			{
				SWIGPendingException.Set(new SystemException(message, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingArgumentException(string message, string paramName)
			{
				SWIGPendingException.Set(new ArgumentException(message, paramName, SWIGPendingException.Retrieve()));
			}

			private static void SetPendingArgumentNullException(string message, string paramName)
			{
				Exception ex = SWIGPendingException.Retrieve();
				if (ex != null)
				{
					message = message + " Inner Exception: " + ex.Message;
				}
				SWIGPendingException.Set(new ArgumentNullException(paramName, message));
			}

			private static void SetPendingArgumentOutOfRangeException(string message, string paramName)
			{
				Exception ex = SWIGPendingException.Retrieve();
				if (ex != null)
				{
					message = message + " Inner Exception: " + ex.Message;
				}
				SWIGPendingException.Set(new ArgumentOutOfRangeException(paramName, message));
			}

			static SWIGExceptionHelper()
			{
				applicationDelegate = SetPendingApplicationException;
				arithmeticDelegate = SetPendingArithmeticException;
				divideByZeroDelegate = SetPendingDivideByZeroException;
				indexOutOfRangeDelegate = SetPendingIndexOutOfRangeException;
				invalidCastDelegate = SetPendingInvalidCastException;
				invalidOperationDelegate = SetPendingInvalidOperationException;
				ioDelegate = SetPendingIOException;
				nullReferenceDelegate = SetPendingNullReferenceException;
				outOfMemoryDelegate = SetPendingOutOfMemoryException;
				overflowDelegate = SetPendingOverflowException;
				systemDelegate = SetPendingSystemException;
				argumentDelegate = SetPendingArgumentException;
				argumentNullDelegate = SetPendingArgumentNullException;
				argumentOutOfRangeDelegate = SetPendingArgumentOutOfRangeException;
				SWIGRegisterExceptionCallbacks_NixelWrapperCPP(applicationDelegate, arithmeticDelegate, divideByZeroDelegate, indexOutOfRangeDelegate, invalidCastDelegate, invalidOperationDelegate, ioDelegate, nullReferenceDelegate, outOfMemoryDelegate, overflowDelegate, systemDelegate);
				SWIGRegisterExceptionCallbacksArgument_NixelWrapperCPP(argumentDelegate, argumentNullDelegate, argumentOutOfRangeDelegate);
			}
		}

		public class SWIGPendingException
		{
			[ThreadStatic]
			private static Exception pendingException;

			private static int numExceptionsPending;

			public static bool Pending
			{
				get
				{
					bool result = false;
					if (numExceptionsPending > 0 && pendingException != null)
					{
						result = true;
					}
					return result;
				}
			}

			public static void Set(Exception e)
			{
				if (pendingException != null)
				{
					throw new ApplicationException("FATAL: An earlier pending exception from unmanaged code was missed and thus not thrown (" + pendingException.ToString() + ")", e);
				}
				pendingException = e;
				lock (typeof(NixelWrapperCPPPINVOKE))
				{
					numExceptionsPending++;
				}
			}

			public static Exception Retrieve()
			{
				Exception result = null;
				if (numExceptionsPending > 0 && pendingException != null)
				{
					result = pendingException;
					pendingException = null;
					lock (typeof(NixelWrapperCPPPINVOKE))
					{
						numExceptionsPending--;
						return result;
					}
				}
				return result;
			}
		}

		protected class SWIGStringHelper
		{
			public delegate string SWIGStringDelegate(string message);

			private static SWIGStringDelegate stringDelegate;

			[DllImport("NixelWrapperCPP")]
			public static extern void SWIGRegisterStringCallback_NixelWrapperCPP(SWIGStringDelegate stringDelegate);

			private static string CreateString(string cString)
			{
				return cString;
			}

			static SWIGStringHelper()
			{
				stringDelegate = CreateString;
				SWIGRegisterStringCallback_NixelWrapperCPP(stringDelegate);
			}
		}

		protected class SWIGWStringHelper
		{
			public delegate string SWIGWStringDelegate(IntPtr message);

			private static SWIGWStringDelegate wstringDelegate;

			[DllImport("NixelWrapperCPP")]
			public static extern void SWIGRegisterWStringCallback_NixelWrapperCPP(SWIGWStringDelegate wstringDelegate);

			private static string CreateWString([MarshalAs(UnmanagedType.LPWStr)] IntPtr cString)
			{
				return Marshal.PtrToStringUni(cString);
			}

			static SWIGWStringHelper()
			{
				wstringDelegate = CreateWString;
				SWIGRegisterWStringCallback_NixelWrapperCPP(wstringDelegate);
			}
		}

		protected static SWIGExceptionHelper swigExceptionHelper;

		protected static SWIGStringHelper swigStringHelper;

		protected static SWIGWStringHelper swigWStringHelper;

		static NixelWrapperCPPPINVOKE()
		{
			swigExceptionHelper = new SWIGExceptionHelper();
			swigStringHelper = new SWIGStringHelper();
			swigWStringHelper = new SWIGWStringHelper();
		}

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_Clear")]
		public static extern void StringVector_Clear(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_Add")]
		public static extern void StringVector_Add(HandleRef jarg1, [MarshalAs(UnmanagedType.LPWStr)] string jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_size")]
		public static extern uint StringVector_size(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_capacity")]
		public static extern uint StringVector_capacity(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_reserve")]
		public static extern void StringVector_reserve(HandleRef jarg1, uint jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_new_StringVector__SWIG_0")]
		public static extern IntPtr new_StringVector__SWIG_0();

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_new_StringVector__SWIG_1")]
		public static extern IntPtr new_StringVector__SWIG_1(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_new_StringVector__SWIG_2")]
		public static extern IntPtr new_StringVector__SWIG_2(int jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_getitemcopy")]
		public static extern string StringVector_getitemcopy(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_getitem")]
		public static extern string StringVector_getitem(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_setitem")]
		public static extern void StringVector_setitem(HandleRef jarg1, int jarg2, [MarshalAs(UnmanagedType.LPWStr)] string jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_AddRange")]
		public static extern void StringVector_AddRange(HandleRef jarg1, HandleRef jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_GetRange")]
		public static extern IntPtr StringVector_GetRange(HandleRef jarg1, int jarg2, int jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_Insert")]
		public static extern void StringVector_Insert(HandleRef jarg1, int jarg2, [MarshalAs(UnmanagedType.LPWStr)] string jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_InsertRange")]
		public static extern void StringVector_InsertRange(HandleRef jarg1, int jarg2, HandleRef jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_RemoveAt")]
		public static extern void StringVector_RemoveAt(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_RemoveRange")]
		public static extern void StringVector_RemoveRange(HandleRef jarg1, int jarg2, int jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_Repeat")]
		public static extern IntPtr StringVector_Repeat([MarshalAs(UnmanagedType.LPWStr)] string jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_Reverse__SWIG_0")]
		public static extern void StringVector_Reverse__SWIG_0(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_Reverse__SWIG_1")]
		public static extern void StringVector_Reverse__SWIG_1(HandleRef jarg1, int jarg2, int jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_StringVector_SetRange")]
		public static extern void StringVector_SetRange(HandleRef jarg1, int jarg2, HandleRef jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_StringVector")]
		public static extern void delete_StringVector(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_StartingPass")]
		public static extern void IBuildCallback_StartingPass(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_StartingPassSwigExplicitIBuildCallback")]
		public static extern void IBuildCallback_StartingPassSwigExplicitIBuildCallback(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_FinishedPass")]
		public static extern void IBuildCallback_FinishedPass(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_FinishedPassSwigExplicitIBuildCallback")]
		public static extern void IBuildCallback_FinishedPassSwigExplicitIBuildCallback(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_OnTileStart")]
		public static extern void IBuildCallback_OnTileStart(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_OnTileStartSwigExplicitIBuildCallback")]
		public static extern void IBuildCallback_OnTileStartSwigExplicitIBuildCallback(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_OnTileFailed")]
		public static extern int IBuildCallback_OnTileFailed(HandleRef jarg1, IntPtr jarg2, int jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_OnTileFailedSwigExplicitIBuildCallback")]
		public static extern int IBuildCallback_OnTileFailedSwigExplicitIBuildCallback(HandleRef jarg1, IntPtr jarg2, int jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_OnTileCompleted")]
		public static extern int IBuildCallback_OnTileCompleted(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_OnTileCompletedSwigExplicitIBuildCallback")]
		public static extern int IBuildCallback_OnTileCompletedSwigExplicitIBuildCallback(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_IBuildCallback")]
		public static extern void delete_IBuildCallback(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_new_IBuildCallback")]
		public static extern IntPtr new_IBuildCallback();

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildCallback_director_connect")]
		public static extern void IBuildCallback_director_connect(HandleRef jarg1, IBuildCallback.SwigDelegateIBuildCallback_0 delegate0, IBuildCallback.SwigDelegateIBuildCallback_1 delegate1, IBuildCallback.SwigDelegateIBuildCallback_2 delegate2, IBuildCallback.SwigDelegateIBuildCallback_3 delegate3, IBuildCallback.SwigDelegateIBuildCallback_4 delegate4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IMipmapGenerator_GenerateMipmapData")]
		public static extern void IMipmapGenerator_GenerateMipmapData(HandleRef jarg1, IntPtr jarg2, uint jarg3, uint jarg4, uint jarg5, IntPtr jarg6, IntPtr jarg7, uint jarg8, uint jarg9, int jarg10, uint jarg11);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_IMipmapGenerator")]
		public static extern void delete_IMipmapGenerator(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_new_IMipmapGenerator")]
		public static extern IntPtr new_IMipmapGenerator();

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IMipmapGenerator_director_connect")]
		public static extern void IMipmapGenerator_director_connect(HandleRef jarg1, IMipmapGenerator.SwigDelegateIMipmapGenerator_0 delegate0);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_StartingPass")]
		public static extern void IBuildProgressTracker_StartingPass(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_StartingPassSwigExplicitIBuildProgressTracker")]
		public static extern void IBuildProgressTracker_StartingPassSwigExplicitIBuildProgressTracker(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_FinishedPass")]
		public static extern void IBuildProgressTracker_FinishedPass(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_FinishedPassSwigExplicitIBuildProgressTracker")]
		public static extern void IBuildProgressTracker_FinishedPassSwigExplicitIBuildProgressTracker(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_ProcessedTile")]
		public static extern void IBuildProgressTracker_ProcessedTile(HandleRef jarg1, IntPtr jarg2, uint jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_ProcessedTileSwigExplicitIBuildProgressTracker")]
		public static extern void IBuildProgressTracker_ProcessedTileSwigExplicitIBuildProgressTracker(HandleRef jarg1, IntPtr jarg2, uint jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_ProcessedGTex")]
		public static extern void IBuildProgressTracker_ProcessedGTex(HandleRef jarg1, uint jarg2, uint jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_ProcessedGTexSwigExplicitIBuildProgressTracker")]
		public static extern void IBuildProgressTracker_ProcessedGTexSwigExplicitIBuildProgressTracker(HandleRef jarg1, uint jarg2, uint jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_OnMipLevelGenerated")]
		public static extern int IBuildProgressTracker_OnMipLevelGenerated(HandleRef jarg1, uint jarg2, uint jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_OnMipLevelGeneratedSwigExplicitIBuildProgressTracker")]
		public static extern int IBuildProgressTracker_OnMipLevelGeneratedSwigExplicitIBuildProgressTracker(HandleRef jarg1, uint jarg2, uint jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_IBuildProgressTracker")]
		public static extern void delete_IBuildProgressTracker(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_new_IBuildProgressTracker")]
		public static extern IntPtr new_IBuildProgressTracker();

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IBuildProgressTracker_director_connect")]
		public static extern void IBuildProgressTracker_director_connect(HandleRef jarg1, IBuildProgressTracker.SwigDelegateIBuildProgressTracker_0 delegate0, IBuildProgressTracker.SwigDelegateIBuildProgressTracker_1 delegate1, IBuildProgressTracker.SwigDelegateIBuildProgressTracker_2 delegate2, IBuildProgressTracker.SwigDelegateIBuildProgressTracker_3 delegate3, IBuildProgressTracker.SwigDelegateIBuildProgressTracker_4 delegate4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileOrder_Reset")]
		public static extern void ITileOrder_Reset(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileOrder_Next__SWIG_0")]
		public static extern bool ITileOrder_Next__SWIG_0(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileOrder_Next__SWIG_1")]
		public static extern bool ITileOrder_Next__SWIG_1(HandleRef jarg1, HandleRef jarg2, HandleRef jarg3, int jarg4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileOrder_Count")]
		public static extern uint ITileOrder_Count(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ITileOrder")]
		public static extern void delete_ITileOrder(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_new_ITileOrder")]
		public static extern IntPtr new_ITileOrder();

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileOrder_director_connect")]
		public static extern void ITileOrder_director_connect(HandleRef jarg1, ITileOrder.SwigDelegateITileOrder_0 delegate0, ITileOrder.SwigDelegateITileOrder_1 delegate1, ITileOrder.SwigDelegateITileOrder_2 delegate2, ITileOrder.SwigDelegateITileOrder_3 delegate3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ICodecLogger")]
		public static extern void delete_ICodecLogger(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ICodecLogger_LogError")]
		public static extern void ICodecLogger_LogError(HandleRef jarg1, IntPtr jarg2, [MarshalAs(UnmanagedType.LPWStr)] string jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ICodecLogger_LogErrorSwigExplicitICodecLogger")]
		public static extern void ICodecLogger_LogErrorSwigExplicitICodecLogger(HandleRef jarg1, IntPtr jarg2, [MarshalAs(UnmanagedType.LPWStr)] string jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ICodecLogger_LogWarning")]
		public static extern void ICodecLogger_LogWarning(HandleRef jarg1, IntPtr jarg2, [MarshalAs(UnmanagedType.LPWStr)] string jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ICodecLogger_LogWarningSwigExplicitICodecLogger")]
		public static extern void ICodecLogger_LogWarningSwigExplicitICodecLogger(HandleRef jarg1, IntPtr jarg2, [MarshalAs(UnmanagedType.LPWStr)] string jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ICodecLogger_LogMessage")]
		public static extern void ICodecLogger_LogMessage(HandleRef jarg1, IntPtr jarg2, [MarshalAs(UnmanagedType.LPWStr)] string jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ICodecLogger_LogMessageSwigExplicitICodecLogger")]
		public static extern void ICodecLogger_LogMessageSwigExplicitICodecLogger(HandleRef jarg1, IntPtr jarg2, [MarshalAs(UnmanagedType.LPWStr)] string jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_new_ICodecLogger")]
		public static extern IntPtr new_ICodecLogger();

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ICodecLogger_director_connect")]
		public static extern void ICodecLogger_director_connect(HandleRef jarg1, ICodecLogger.SwigDelegateICodecLogger_0 delegate0, ICodecLogger.SwigDelegateICodecLogger_1 delegate1, ICodecLogger.SwigDelegateICodecLogger_2 delegate2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiled_GetTopology")]
		public static extern IntPtr ITiled_GetTopology(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ITiled")]
		public static extern void delete_ITiled(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterDataRead_GetTileDimensions")]
		public static extern IntPtr ITiledRasterDataRead_GetTileDimensions(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterDataRead_GetPixelSize")]
		public static extern int ITiledRasterDataRead_GetPixelSize(HandleRef jarg1, uint jarg2, out uint jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterDataRead_GetPixel")]
		public static extern int ITiledRasterDataRead_GetPixel(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, IntPtr jarg6);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterDataRead_GetLine")]
		public static extern int ITiledRasterDataRead_GetLine(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, IntPtr jarg7);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterDataRead_GetRectangle")]
		public static extern int ITiledRasterDataRead_GetRectangle(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, uint jarg7, IntPtr jarg8);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterDataRead_MapTileLayerRead")]
		public static extern int ITiledRasterDataRead_MapTileLayerRead(HandleRef jarg1, IntPtr jarg2, bool jarg3, IntPtr jarg4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterDataRead_UnMapTileLayerRead")]
		public static extern int ITiledRasterDataRead_UnMapTileLayerRead(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ITiledRasterDataRead")]
		public static extern void delete_ITiledRasterDataRead(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_SetPixel")]
		public static extern int ITiledRasterData_SetPixel(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, IntPtr jarg6);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_SetLine__SWIG_0")]
		public static extern int ITiledRasterData_SetLine__SWIG_0(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, IntPtr jarg7, IntPtr jarg8);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_SetLine__SWIG_1")]
		public static extern int ITiledRasterData_SetLine__SWIG_1(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, IntPtr jarg7);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_ClearLine")]
		public static extern int ITiledRasterData_ClearLine(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_ClearRectangle")]
		public static extern int ITiledRasterData_ClearRectangle(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, uint jarg7);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_RemoveTileRectangle")]
		public static extern int ITiledRasterData_RemoveTileRectangle(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, uint jarg7);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_SetRectangle__SWIG_0")]
		public static extern int ITiledRasterData_SetRectangle__SWIG_0(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, uint jarg7, IntPtr jarg8, IntPtr jarg9);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_SetRectangle__SWIG_1")]
		public static extern int ITiledRasterData_SetRectangle__SWIG_1(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, uint jarg7, IntPtr jarg8);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_SetTile")]
		public static extern int ITiledRasterData_SetTile(HandleRef jarg1, IntPtr jarg2, IntPtr jarg3, bool jarg4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_GetTile")]
		public static extern int ITiledRasterData_GetTile(HandleRef jarg1, IntPtr jarg2, IntPtr jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_MapTileLayerWrite")]
		public static extern int ITiledRasterData_MapTileLayerWrite(HandleRef jarg1, IntPtr jarg2, bool jarg3, int jarg4, IntPtr jarg5);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_UnMapTileLayerWrite")]
		public static extern int ITiledRasterData_UnMapTileLayerWrite(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_SetMipmapGenerator")]
		public static extern int ITiledRasterData_SetMipmapGenerator(HandleRef jarg1, HandleRef jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_AutoGenerateLevels")]
		public static extern int ITiledRasterData_AutoGenerateLevels(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_AllocateTileLayer")]
		public static extern int ITiledRasterData_AllocateTileLayer(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_RemoveTileLayer")]
		public static extern int ITiledRasterData_RemoveTileLayer(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_ClearTileLayer")]
		public static extern int ITiledRasterData_ClearTileLayer(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_AllocateTile")]
		public static extern int ITiledRasterData_AllocateTile(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_RemoveTile")]
		public static extern int ITiledRasterData_RemoveTile(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_AutoGenerateTileLayer")]
		public static extern int ITiledRasterData_AutoGenerateTileLayer(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_AutoGenerateBorderInfo")]
		public static extern int ITiledRasterData_AutoGenerateBorderInfo(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_SetCubemapBorderRegion")]
		public static extern int ITiledRasterData_SetCubemapBorderRegion(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, uint jarg7, int jarg8);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_ClearCubemapBorderRegions")]
		public static extern int ITiledRasterData_ClearCubemapBorderRegions(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_RegisterUserSetRectangle")]
		public static extern void ITiledRasterData_RegisterUserSetRectangle(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, uint jarg7);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_ClearUserSetRectangles")]
		public static extern void ITiledRasterData_ClearUserSetRectangles(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_RegisterAssetRectangle")]
		public static extern void ITiledRasterData_RegisterAssetRectangle(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5, uint jarg6, int jarg7);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_ClearAssetRectangles")]
		public static extern void ITiledRasterData_ClearAssetRectangles(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_MakePersistent")]
		public static extern int ITiledRasterData_MakePersistent(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_SetBuildProgressTracker")]
		public static extern int ITiledRasterData_SetBuildProgressTracker(HandleRef jarg1, HandleRef jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_RegisterThumbnail")]
		public static extern int ITiledRasterData_RegisterThumbnail(HandleRef jarg1, GraphineGuid jarg2, uint jarg3, uint jarg4, uint jarg5, int jarg6, bool jarg7, [In][MarshalAs(UnmanagedType.LPArray)] IntPtr[] jarg8);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_GetThumbnailNumLevels")]
		public static extern uint ITiledRasterData_GetThumbnailNumLevels(HandleRef jarg1, GraphineGuid jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_GetThumbnailData")]
		public static extern IntPtr ITiledRasterData_GetThumbnailData(HandleRef jarg1, GraphineGuid jarg2, uint jarg3, out uint jarg4, out uint jarg5, out DataType jarg6);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ITiledRasterData")]
		public static extern void delete_ITiledRasterData(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_GetMetadata")]
		public static extern IntPtr ITiledBuildParameters_GetMetadata(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_GetMetadataSize")]
		public static extern uint ITiledBuildParameters_GetMetadataSize(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_SetMetadata")]
		public static extern int ITiledBuildParameters_SetMetadata(HandleRef jarg1, IntPtr jarg2, uint jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_RemoveMetadata")]
		public static extern int ITiledBuildParameters_RemoveMetadata(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_SetThumbnail")]
		public static extern int ITiledBuildParameters_SetThumbnail(HandleRef jarg1, GraphineGuid jarg2, uint jarg3, uint jarg4, uint jarg5, int jarg6, [In][MarshalAs(UnmanagedType.LPArray)] IntPtr[] jarg7, int jarg8);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_ClearThumbnail")]
		public static extern int ITiledBuildParameters_ClearThumbnail(HandleRef jarg1, GraphineGuid jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_AddTileLayerCodingGroup")]
		public static extern int ITiledBuildParameters_AddTileLayerCodingGroup(HandleRef jarg1, uint jarg2, int jarg3, [MarshalAs(UnmanagedType.LPWStr)] string jarg4, out int jarg5);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_ClearAllTileLayerCodingGroups")]
		public static extern int ITiledBuildParameters_ClearAllTileLayerCodingGroups(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_SetTileLayerCodingGroup")]
		public static extern int ITiledBuildParameters_SetTileLayerCodingGroup(HandleRef jarg1, IntPtr jarg2, int jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_GetTileLayerCodingGroupIndex")]
		public static extern int ITiledBuildParameters_GetTileLayerCodingGroupIndex(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_GetNumTileLayerCodingGroups")]
		public static extern uint ITiledBuildParameters_GetNumTileLayerCodingGroups(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_SetLayerCodingGroup")]
		public static extern int ITiledBuildParameters_SetLayerCodingGroup(HandleRef jarg1, uint jarg2, int jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_GetTileLayerCodingGroup")]
		public static extern int ITiledBuildParameters_GetTileLayerCodingGroup(HandleRef jarg1, int jarg2, IntPtr jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_EnableUniformCoding")]
		public static extern void ITiledBuildParameters_EnableUniformCoding(HandleRef jarg1, int jarg2, bool jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_IsUniformCodingEnabled")]
		public static extern bool ITiledBuildParameters_IsUniformCodingEnabled(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ITiledBuildParameters")]
		public static extern void delete_ITiledBuildParameters(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_SetOutputMode")]
		public static extern void IGtsFileReader_SetOutputMode(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_GetTileInfo")]
		public static extern int IGtsFileReader_GetTileInfo(HandleRef jarg1, IntPtr jarg2, IntPtr jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_GetFlatTileInfo")]
		public static extern int IGtsFileReader_GetFlatTileInfo(HandleRef jarg1, uint jarg2, IntPtr jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_GetMetaData")]
		public static extern IntPtr IGtsFileReader_GetMetaData(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_GetMetaDataLength")]
		public static extern uint IGtsFileReader_GetMetaDataLength(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_GetNumThumbnails")]
		public static extern uint IGtsFileReader_GetNumThumbnails(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_GetThumbnail")]
		public static extern int IGtsFileReader_GetThumbnail(HandleRef jarg1, uint jarg2, Layout jarg3, IntPtr jarg4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_GetThumbNailDataType")]
		public static extern int IGtsFileReader_GetThumbNailDataType(HandleRef jarg1, uint jarg2, out DataType jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_GetMipTail")]
		public static extern int IGtsFileReader_GetMipTail(HandleRef jarg1, uint jarg2, uint jarg3, Layout jarg4, int jarg5, IntPtr jarg6);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_GetGtsInfo")]
		public static extern int IGtsFileReader_GetGtsInfo(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_GetPageFileInfo")]
		public static extern int IGtsFileReader_GetPageFileInfo(HandleRef jarg1, uint jarg2, IntPtr jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_IGtsFileReader")]
		public static extern void delete_IGtsFileReader(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupFileReader_GetMetaData")]
		public static extern IntPtr ITileSoupFileReader_GetMetaData(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupFileReader_GetMetaDataLength")]
		public static extern uint ITileSoupFileReader_GetMetaDataLength(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupFileReader_GetTileDimensions")]
		public static extern int ITileSoupFileReader_GetTileDimensions(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupFileReader_GetTiledTopology")]
		public static extern int ITileSoupFileReader_GetTiledTopology(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ITileSoupFileReader")]
		public static extern void delete_ITileSoupFileReader(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IPackedSoupFileCollection_Add")]
		public static extern int IPackedSoupFileCollection_Add(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IPackedSoupFileCollection_GetSize")]
		public static extern uint IPackedSoupFileCollection_GetSize(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IPackedSoupFileCollection_GetItem__SWIG_0")]
		public static extern IntPtr IPackedSoupFileCollection_GetItem__SWIG_0(HandleRef jarg1, uint jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_IPackedSoupFileCollection")]
		public static extern void delete_IPackedSoupFileCollection(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ILayerIndexCollection_Add")]
		public static extern int ILayerIndexCollection_Add(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ILayerIndexCollection_GetSize")]
		public static extern uint ILayerIndexCollection_GetSize(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ILayerIndexCollection_GetItem")]
		public static extern int ILayerIndexCollection_GetItem(HandleRef jarg1, uint jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ILayerIndexCollection_Contains")]
		public static extern bool ILayerIndexCollection_Contains(HandleRef jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ILayerIndexCollection")]
		public static extern void delete_ILayerIndexCollection(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSetRebuilder_SetBuildProgressTracker")]
		public static extern int ITileSetRebuilder_SetBuildProgressTracker(HandleRef jarg1, HandleRef jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSetRebuilder_Begin")]
		public static extern int ITileSetRebuilder_Begin(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSetRebuilder_Rebuild__SWIG_0")]
		public static extern int ITileSetRebuilder_Rebuild__SWIG_0(HandleRef jarg1, IntPtr jarg2, IntPtr jarg3, HandleRef jarg4, HandleRef jarg5, HandleRef jarg6);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSetRebuilder_Rebuild__SWIG_1")]
		public static extern int ITileSetRebuilder_Rebuild__SWIG_1(HandleRef jarg1, IntPtr jarg2, IntPtr jarg3, HandleRef jarg4, HandleRef jarg5);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSetRebuilder_Rebuild__SWIG_2")]
		public static extern int ITileSetRebuilder_Rebuild__SWIG_2(HandleRef jarg1, IntPtr jarg2, IntPtr jarg3, HandleRef jarg4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSetRebuilder_GetBuildReport")]
		public static extern int ITileSetRebuilder_GetBuildReport(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSetRebuilder_GetMetaData")]
		public static extern int ITileSetRebuilder_GetMetaData(HandleRef jarg1, [MarshalAs(UnmanagedType.LPWStr)] string jarg2, out IntPtr jarg3, out uint jarg4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSetRebuilder_SetMetaData")]
		public static extern int ITileSetRebuilder_SetMetaData(HandleRef jarg1, IntPtr jarg2, uint jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSetRebuilder_ClearMetaDataOverride")]
		public static extern int ITileSetRebuilder_ClearMetaDataOverride(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ITileSetRebuilder")]
		public static extern void delete_ITileSetRebuilder(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupBuilder_Build")]
		public static extern int ITileSoupBuilder_Build(HandleRef jarg1, IntPtr jarg2, int jarg3, HandleRef jarg4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupBuilder_Begin")]
		public static extern int ITileSoupBuilder_Begin(HandleRef jarg1, IntPtr jarg2, int jarg3, HandleRef jarg4, int jarg5);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupBuilder_EncodeTile")]
		public static extern int ITileSoupBuilder_EncodeTile(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupBuilder_WriteTile")]
		public static extern int ITileSoupBuilder_WriteTile(HandleRef jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupBuilder_End")]
		public static extern int ITileSoupBuilder_End(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupBuilder_SetBuildProgressTracker")]
		public static extern int ITileSoupBuilder_SetBuildProgressTracker(HandleRef jarg1, HandleRef jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupBuilder_SetBuildCallback")]
		public static extern int ITileSoupBuilder_SetBuildCallback(HandleRef jarg1, HandleRef jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileSoupBuilder_SetCodecLogger")]
		public static extern int ITileSoupBuilder_SetCodecLogger(HandleRef jarg1, HandleRef jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ITileSoupBuilder")]
		public static extern void delete_ITileSoupBuilder(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_Initialize")]
		public static extern int ITileFileFactory_Initialize(IntPtr jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_Release")]
		public static extern int ITileFileFactory_Release();

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_CreateTiledRasterData")]
		public static extern int ITileFileFactory_CreateTiledRasterData(IntPtr jarg1, IntPtr jarg2, uint jarg3, [MarshalAs(UnmanagedType.LPWStr)] string jarg4, out IntPtr jarg5);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_CreateTiledBuildParameters")]
		public static extern int ITileFileFactory_CreateTiledBuildParameters(IntPtr jarg1, out IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_CreateTileSoupBuilder")]
		public static extern int ITileFileFactory_CreateTileSoupBuilder(HandleRef jarg1, HandleRef jarg2, IntPtr jarg3, out IntPtr jarg4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_CreateTileSetRebuilder")]
		public static extern int ITileFileFactory_CreateTileSetRebuilder(out IntPtr jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_CreateTileFileReader")]
		public static extern int ITileFileFactory_CreateTileFileReader([MarshalAs(UnmanagedType.LPWStr)] string jarg1, uint jarg2, out IntPtr jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_CreateGtsFileReader")]
		public static extern int ITileFileFactory_CreateGtsFileReader([MarshalAs(UnmanagedType.LPWStr)] string jarg1, HandleRef jarg2, uint jarg3, out IntPtr jarg4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_CreateTileSoupFileReader")]
		public static extern int ITileFileFactory_CreateTileSoupFileReader([MarshalAs(UnmanagedType.LPWStr)] string jarg1, out IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_GetLastError")]
		public static extern void ITileFileFactory_GetLastError(IntPtr jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_GetLibraryVersion")]
		public static extern void ITileFileFactory_GetLibraryVersion(IntPtr jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_CreateTileSoupCollection")]
		public static extern int ITileFileFactory_CreateTileSoupCollection(out IntPtr jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITileFileFactory_CreateLayerIndexCollection")]
		public static extern int ITileFileFactory_CreateLayerIndexCollection(out IntPtr jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_new_ITileFileFactory")]
		public static extern IntPtr new_ITileFileFactory();

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_ITileFileFactory")]
		public static extern void delete_ITileFileFactory(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_Tools_ConvertData__SWIG_0")]
		public static extern int Tools_ConvertData__SWIG_0(int jarg1, IntPtr jarg2, uint jarg3, int jarg4, IntPtr jarg5, float jarg6, float jarg7);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_Tools_ConvertData__SWIG_1")]
		public static extern int Tools_ConvertData__SWIG_1(int jarg1, IntPtr jarg2, uint jarg3, int jarg4, IntPtr jarg5, float jarg6);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_Tools_ConvertData__SWIG_2")]
		public static extern int Tools_ConvertData__SWIG_2(int jarg1, IntPtr jarg2, uint jarg3, int jarg4, IntPtr jarg5);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_Tools_IsConvertible")]
		public static extern bool Tools_IsConvertible(int jarg1, int jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_Tools_SwizzleDataChannels")]
		public static extern bool Tools_SwizzleDataChannels(int jarg1, uint jarg2, IntPtr jarg3, IntPtr jarg4);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_Tools_IsUniformData")]
		public static extern bool Tools_IsUniformData(HandleRef jarg1, uint jarg2, uint jarg3, uint jarg4, uint jarg5);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_Tools_IsUniformTileData")]
		public static extern bool Tools_IsUniformTileData(HandleRef jarg1, IntPtr jarg2, int jarg3);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_Tools_GetDefaultColorForLayerType")]
		public static extern void Tools_GetDefaultColorForLayerType(int jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_Tools_GetRawTileByteSize")]
		public static extern uint Tools_GetRawTileByteSize(IntPtr jarg1, IntPtr jarg2);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_new_Tools")]
		public static extern IntPtr new_Tools();

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_delete_Tools")]
		public static extern void delete_Tools(HandleRef jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterDataRead_SWIGUpcast")]
		public static extern IntPtr ITiledRasterDataRead_SWIGUpcast(IntPtr jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledRasterData_SWIGUpcast")]
		public static extern IntPtr ITiledRasterData_SWIGUpcast(IntPtr jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_ITiledBuildParameters_SWIGUpcast")]
		public static extern IntPtr ITiledBuildParameters_SWIGUpcast(IntPtr jarg1);

		[DllImport("NixelWrapperCPP", EntryPoint = "CSharp_IGtsFileReader_SWIGUpcast")]
		public static extern IntPtr IGtsFileReader_SWIGUpcast(IntPtr jarg1);
	}
	public class StringVector : IDisposable, IEnumerable, IEnumerable<string>
	{
		public sealed class StringVectorEnumerator : IEnumerator, IEnumerator<string>, IDisposable
		{
			private StringVector collectionRef;

			private int currentIndex;

			private object currentObject;

			private int currentSize;

			public string Current
			{
				get
				{
					if (currentIndex == -1)
					{
						throw new InvalidOperationException("Enumeration not started.");
					}
					if (currentIndex > currentSize - 1)
					{
						throw new InvalidOperationException("Enumeration finished.");
					}
					if (currentObject == null)
					{
						throw new InvalidOperationException("Collection modified.");
					}
					return (string)currentObject;
				}
			}

			object IEnumerator.Current => Current;

			public StringVectorEnumerator(StringVector collection)
			{
				collectionRef = collection;
				currentIndex = -1;
				currentObject = null;
				currentSize = collectionRef.Count;
			}

			public bool MoveNext()
			{
				int count = collectionRef.Count;
				int num;
				if (currentIndex + 1 < count)
				{
					num = ((count == currentSize) ? 1 : 0);
					if (num != 0)
					{
						currentIndex++;
						currentObject = collectionRef[currentIndex];
						return (byte)num != 0;
					}
				}
				else
				{
					num = 0;
				}
				currentObject = null;
				return (byte)num != 0;
			}

			public void Reset()
			{
				currentIndex = -1;
				currentObject = null;
				if (collectionRef.Count != currentSize)
				{
					throw new InvalidOperationException("Collection modified.");
				}
			}

			public void Dispose()
			{
				currentIndex = -1;
				currentObject = null;
			}
		}

		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		public bool IsFixedSize => false;

		public bool IsReadOnly => false;

		public string this[int index]
		{
			get
			{
				return getitem(index);
			}
			set
			{
				setitem(index, value);
			}
		}

		public int Capacity
		{
			get
			{
				return (int)capacity();
			}
			set
			{
				if (value < size())
				{
					throw new ArgumentOutOfRangeException("Capacity");
				}
				reserve((uint)value);
			}
		}

		public int Count => (int)size();

		public bool IsSynchronized => false;

		internal StringVector(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(StringVector obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~StringVector()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_StringVector(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public StringVector(ICollection c)
			: this()
		{
			if (c == null)
			{
				throw new ArgumentNullException("c");
			}
			foreach (string item in c)
			{
				Add(item);
			}
		}

		public void CopyTo(string[] array)
		{
			CopyTo(0, array, 0, Count);
		}

		public void CopyTo(string[] array, int arrayIndex)
		{
			CopyTo(0, array, arrayIndex, Count);
		}

		public void CopyTo(int index, string[] array, int arrayIndex, int count)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index", "Value is less than zero");
			}
			if (arrayIndex < 0)
			{
				throw new ArgumentOutOfRangeException("arrayIndex", "Value is less than zero");
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", "Value is less than zero");
			}
			if (array.Rank > 1)
			{
				throw new ArgumentException("Multi dimensional array.", "array");
			}
			if (index + count > Count || arrayIndex + count > array.Length)
			{
				throw new ArgumentException("Number of elements to copy is too large.");
			}
			for (int i = 0; i < count; i++)
			{
				array.SetValue(getitemcopy(index + i), arrayIndex + i);
			}
		}

		IEnumerator<string> IEnumerable<string>.GetEnumerator()
		{
			return new StringVectorEnumerator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new StringVectorEnumerator(this);
		}

		public StringVectorEnumerator GetEnumerator()
		{
			return new StringVectorEnumerator(this);
		}

		public void Clear()
		{
			NixelWrapperCPPPINVOKE.StringVector_Clear(swigCPtr);
		}

		public void Add(string x)
		{
			NixelWrapperCPPPINVOKE.StringVector_Add(swigCPtr, x);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		private uint size()
		{
			return NixelWrapperCPPPINVOKE.StringVector_size(swigCPtr);
		}

		private uint capacity()
		{
			return NixelWrapperCPPPINVOKE.StringVector_capacity(swigCPtr);
		}

		private void reserve(uint n)
		{
			NixelWrapperCPPPINVOKE.StringVector_reserve(swigCPtr, n);
		}

		public StringVector()
			: this(NixelWrapperCPPPINVOKE.new_StringVector__SWIG_0(), cMemoryOwn: true)
		{
		}

		public StringVector(StringVector other)
			: this(NixelWrapperCPPPINVOKE.new_StringVector__SWIG_1(getCPtr(other)), cMemoryOwn: true)
		{
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public StringVector(int capacity)
			: this(NixelWrapperCPPPINVOKE.new_StringVector__SWIG_2(capacity), cMemoryOwn: true)
		{
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		private string getitemcopy(int index)
		{
			string result = NixelWrapperCPPPINVOKE.StringVector_getitemcopy(swigCPtr, index);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		private string getitem(int index)
		{
			string result = NixelWrapperCPPPINVOKE.StringVector_getitem(swigCPtr, index);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		private void setitem(int index, string val)
		{
			NixelWrapperCPPPINVOKE.StringVector_setitem(swigCPtr, index, val);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void AddRange(StringVector values)
		{
			NixelWrapperCPPPINVOKE.StringVector_AddRange(swigCPtr, getCPtr(values));
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public StringVector GetRange(int index, int count)
		{
			IntPtr intPtr = NixelWrapperCPPPINVOKE.StringVector_GetRange(swigCPtr, index, count);
			StringVector result = ((intPtr == IntPtr.Zero) ? null : new StringVector(intPtr, cMemoryOwn: true));
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void Insert(int index, string x)
		{
			NixelWrapperCPPPINVOKE.StringVector_Insert(swigCPtr, index, x);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void InsertRange(int index, StringVector values)
		{
			NixelWrapperCPPPINVOKE.StringVector_InsertRange(swigCPtr, index, getCPtr(values));
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void RemoveAt(int index)
		{
			NixelWrapperCPPPINVOKE.StringVector_RemoveAt(swigCPtr, index);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void RemoveRange(int index, int count)
		{
			NixelWrapperCPPPINVOKE.StringVector_RemoveRange(swigCPtr, index, count);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public static StringVector Repeat(string value, int count)
		{
			IntPtr intPtr = NixelWrapperCPPPINVOKE.StringVector_Repeat(value, count);
			StringVector result = ((intPtr == IntPtr.Zero) ? null : new StringVector(intPtr, cMemoryOwn: true));
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
			return result;
		}

		public void Reverse()
		{
			NixelWrapperCPPPINVOKE.StringVector_Reverse__SWIG_0(swigCPtr);
		}

		public void Reverse(int index, int count)
		{
			NixelWrapperCPPPINVOKE.StringVector_Reverse__SWIG_1(swigCPtr, index, count);
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}

		public void SetRange(int index, StringVector values)
		{
			NixelWrapperCPPPINVOKE.StringVector_SetRange(swigCPtr, index, getCPtr(values));
			if (NixelWrapperCPPPINVOKE.SWIGPendingException.Pending)
			{
				throw NixelWrapperCPPPINVOKE.SWIGPendingException.Retrieve();
			}
		}
	}
	public class SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem
	{
		private HandleRef swigCPtr;

		internal SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem(IntPtr cPtr, bool futureUse)
		{
			swigCPtr = new HandleRef(this, cPtr);
		}

		protected SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem()
		{
			swigCPtr = new HandleRef(null, IntPtr.Zero);
		}

		internal static HandleRef getCPtr(SWIGTYPE_p_p_Graphine__Nixel__TileOrderItem obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}
	}
	public class SWIGTYPE_p_unsigned_char
	{
		private HandleRef swigCPtr;

		internal SWIGTYPE_p_unsigned_char(IntPtr cPtr, bool futureUse)
		{
			swigCPtr = new HandleRef(this, cPtr);
		}

		protected SWIGTYPE_p_unsigned_char()
		{
			swigCPtr = new HandleRef(null, IntPtr.Zero);
		}

		internal static HandleRef getCPtr(SWIGTYPE_p_unsigned_char obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}
	}
	[Obfuscation(Exclude = true, ApplyToMembers = true)]
	public enum TileDataMode
	{
		Decoded,
		DecodedMip,
		Encoded,
		Transcoded
	}
	public class Tools : IDisposable
	{
		private HandleRef swigCPtr;

		protected bool swigCMemOwn;

		internal Tools(IntPtr cPtr, bool cMemoryOwn)
		{
			swigCMemOwn = cMemoryOwn;
			swigCPtr = new HandleRef(this, cPtr);
		}

		internal static HandleRef getCPtr(Tools obj)
		{
			return obj?.swigCPtr ?? new HandleRef(null, IntPtr.Zero);
		}

		~Tools()
		{
			Dispose();
		}

		public virtual void Dispose()
		{
			lock (this)
			{
				if (swigCPtr.Handle != IntPtr.Zero)
				{
					if (swigCMemOwn)
					{
						swigCMemOwn = false;
						NixelWrapperCPPPINVOKE.delete_Tools(swigCPtr);
					}
					swigCPtr = new HandleRef(null, IntPtr.Zero);
				}
				GC.SuppressFinalize(this);
			}
		}

		public static Error ConvertData(DataType srcType, IntPtr srcData, uint numPixels, DataType dstType, IntPtr dstData, float hdrMin, float hdrMax)
		{
			return (Error)NixelWrapperCPPPINVOKE.Tools_ConvertData__SWIG_0((int)srcType, srcData, numPixels, (int)dstType, dstData, hdrMin, hdrMax);
		}

		public static Error ConvertData(DataType srcType, IntPtr srcData, uint numPixels, DataType dstType, IntPtr dstData, float hdrMin)
		{
			return (Error)NixelWrapperCPPPINVOKE.Tools_ConvertData__SWIG_1((int)srcType, srcData, numPixels, (int)dstType, dstData, hdrMin);
		}

		public static Error ConvertData(DataType srcType, IntPtr srcData, uint numPixels, DataType dstType, IntPtr dstData)
		{
			return (Error)NixelWrapperCPPPINVOKE.Tools_ConvertData__SWIG_2((int)srcType, srcData, numPixels, (int)dstType, dstData);
		}

		public static bool IsConvertible(DataType srcType, DataType dstType)
		{
			return NixelWrapperCPPPINVOKE.Tools_IsConvertible((int)srcType, (int)dstType);
		}

		public static bool SwizzleDataChannels(DataType dataType, uint numPixels, Layout swizzleLayout, IntPtr data)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Layout)));
			Marshal.StructureToPtr((object)swizzleLayout, intPtr, fDeleteOld: false);
			try
			{
				return NixelWrapperCPPPINVOKE.Tools_SwizzleDataChannels((int)dataType, numPixels, intPtr, data);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public static bool IsUniformData(SWIGTYPE_p_unsigned_char data, uint width, uint height, uint stride, uint elementSize)
		{
			return NixelWrapperCPPPINVOKE.Tools_IsUniformData(SWIGTYPE_p_unsigned_char.getCPtr(data), width, height, stride, elementSize);
		}

		public static bool IsUniformTileData(SWIGTYPE_p_unsigned_char data, RasterTileDimension tileDim, DataType dataType)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(RasterTileDimension)));
			Marshal.StructureToPtr((object)tileDim, intPtr, fDeleteOld: false);
			try
			{
				return NixelWrapperCPPPINVOKE.Tools_IsUniformTileData(SWIGTYPE_p_unsigned_char.getCPtr(data), intPtr, (int)dataType);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public static void GetDefaultColorForLayerType(DataType dataType, ref Color color)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Color)));
			Marshal.StructureToPtr((object)color, intPtr, fDeleteOld: false);
			try
			{
				NixelWrapperCPPPINVOKE.Tools_GetDefaultColorForLayerType((int)dataType, intPtr);
			}
			finally
			{
				color = (Color)Marshal.PtrToStructure(intPtr, typeof(Color));
				Marshal.FreeHGlobal(intPtr);
			}
		}

		public static uint GetRawTileByteSize(TiledTopology topology, RasterTileDimension tileDim)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(TiledTopology)));
			Marshal.StructureToPtr((object)topology, intPtr, fDeleteOld: false);
			IntPtr intPtr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(RasterTileDimension)));
			Marshal.StructureToPtr((object)tileDim, intPtr2, fDeleteOld: false);
			try
			{
				return NixelWrapperCPPPINVOKE.Tools_GetRawTileByteSize(intPtr, intPtr2);
			}
			finally
			{
				Marshal.FreeHGlobal(intPtr);
				Marshal.FreeHGlobal(intPtr2);
			}
		}

		public Tools()
			: this(NixelWrapperCPPPINVOKE.new_Tools(), cMemoryOwn: true)
		{
		}
	}
	[Obfuscation(Exclude = true, ApplyToMembers = true)]
	public enum WriteMapType
	{
		Write,
		WriteDiscard
	}
}