public Texture(Bitmap bmp, int xTiles, int yTiles, TextureMinFilter minFilter, TextureMagFilter magFilter, TextureWrapMode wrapS, TextureWrapMode wrapT)
        {
            this.bmp = bmp;
            this.xSize = bmp.Width;
            this.ySize = bmp.Height;
            this.xTiles = xTiles;
            this.yTiles = yTiles;
            if (xTiles == 0 || yTiles == 0)
            {
                this.xPixels = xSize;
                this.yPixels = ySize;
            }
            else
            {
                this.xPixels = xSize / xTiles;
                this.yPixels = ySize / yTiles;
            }

            this.minFilter = minFilter;
            this.magFilter = magFilter;
            this.wrapS = wrapS;
            this.wrapT = wrapT;

            offsetX = 1.0f / (float)(2 * xSize);
            offsetY = 1.0f / (float)(2 * ySize);

            Load();
        }

		public Texture Find(string file, TextureMagFilter magFilter, TextureMinFilter minFilter, TextureWrapMode wrapModeS, TextureWrapMode wrapModeT)
		{
			try
			{
				string key = string.Format("{0}:{1}:{2}:{3}:{4}", file, magFilter, minFilter, wrapModeS, wrapModeT);
			
				Texture texture;
				if(textures.TryGetValue(key, out texture))return texture;

				TextureLoaderParameters.MagnificationFilter = magFilter;
				TextureLoaderParameters.MinificationFilter = minFilter;
				TextureLoaderParameters.WrapModeS = wrapModeS;
				TextureLoaderParameters.WrapModeT = wrapModeT;
				
				uint handle;
				TextureTarget dimension;
				ImageDDS.LoadFromDisk(file, out handle, out dimension);
				
				texture = new Texture(handle);
				
				textures[key]=texture;
				
				return texture;
			}
			catch
			{
				Console.WriteLine(string.Format("TextureManager: Failed to load texture {0}", file));
				return new Texture(0); // TODO remove
			}
		}

        public VO64SimpleTexture(Bitmap texture, TextureWrapMode wrapS, TextureWrapMode wrapT)
        {
            Texture = texture;

            WrapS = wrapS;
            WrapT = wrapT;
        }

 /// <summary>
 /// Sets the given wrap mode on all dimensions R, S and T.
 /// </summary>
 /// <param name="wrapMode">The wrap mode to apply.</param>
 public void SetWrapMode(TextureWrapMode wrapMode)
 {
     var mode = (int) wrapMode;
     SetParameter(SamplerParameterName.TextureWrapR, mode);
     SetParameter(SamplerParameterName.TextureWrapS, mode);
     SetParameter(SamplerParameterName.TextureWrapT, mode);
 }

    /// <summary>
    /// Get GIF texture list (This is a possibility of lock up)
    /// </summary>
    /// <param name="bytes">GIF file byte data</param>
    /// <param name="loopCount">out Animation loop count</param>
    /// <param name="width">out GIF image width (px)</param>
    /// <param name="height">out GIF image height (px)</param>
    /// <param name="filterMode">Textures filter mode</param>
    /// <param name="wrapMode">Textures wrap mode</param>
    /// <param name="debugLog">Debug Log Flag</param>
    /// <returns>GIF texture list</returns>
    public static List<GifTexture> GetTextureList (byte[] bytes, out int loopCount, out int width, out int height,
        FilterMode filterMode = FilterMode.Bilinear, TextureWrapMode wrapMode = TextureWrapMode.Clamp, bool debugLog = false)
    {
        loopCount = -1;
        width = 0;
        height = 0;

        // Set GIF data
        var gifData = new GifData ();
        if (SetGifData (bytes, ref gifData, debugLog) == false) {
            Debug.LogError ("GIF file data set error.");
            return null;
        }

        // Decode to textures from GIF data
        var gifTexList = new List<GifTexture> ();
        if (DecodeTexture (gifData, gifTexList, filterMode, wrapMode) == false) {
            Debug.LogError ("GIF texture decode error.");
            return null;
        }

        loopCount = gifData.appEx.loopCount;
        width = gifData.logicalScreenWidth;
        height = gifData.logicalScreenHeight;
        return gifTexList;
    }

 private static void ApplyWrapMode(Texture2D lut2D, TextureWrapMode prevWrapMode)
 {
     TextureImporter importer = GetTextureImporter(lut2D);
     importer.wrapMode = prevWrapMode;
     AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(lut2D));
     AssetDatabase.Refresh();
 }

        /// <summary>
        /// Initializes a new instance of the Texture class. Generates and stores a bitmap in VRAM.
        /// </summary>
        /// <param name="bmp">The bitmap to be copied to VRAM.</param>
        /// <param name="minFilter">A filter applied when the rendered texture is smaller than the texture at 100%.</param>
        /// <param name="magFilter">A filter applied when the rendered texture is larger than the texture at 100%.</param>
        /// <param name="wrapS">The way OpenGL will handle texture coordinates larger than <c>1.0f</c> on the S axis (X axis).</param>
        /// <param name="wrapT">The way OpenGL will handle texture coordinates larger than <c>1.0f</c> on the T axis (Y axis).</param>
        public Texture(Bitmap bmp, TextureMinFilter minFilter, TextureMagFilter magFilter, TextureWrapMode wrapS, TextureWrapMode wrapT)
        {
            this.Size = bmp.Size;

            //Generate a new texture ID
            ID = GL.GenTexture();

            //Texture parameters
            MinFilter = minFilter;
            MagFilter = magFilter;
            WrapS = wrapS;
            WrapT = wrapT;

            //Bind texture
            GL.BindTexture(TextureTarget.Texture2D, ID);

            //Send bitmap data up to VRAM
            bmp.RotateFlip(RotateFlipType.RotateNoneFlipY);
            BitmapData bmpData = bmp.LockBits(new Rectangle(new Point(0, 0), Size), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
            GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, Size.Width, Size.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, bmpData.Scan0);
            bmp.UnlockBits(bmpData);

            //unbind texture
            GL.BindTexture(TextureTarget.Texture2D, 0);
        }

		///<summary>
		/// Create new texture generator
		///</summary>
		///<param name="texture">Texture to use. It must be readable. The texture is read in constructor, so any later changes to it will not affect this generator</param>
		///<param name="wrapMode">Wrapping mode</param>
		public TexturePattern(Texture2D texture, TextureWrapMode wrapMode)
		{
			m_colors = texture.GetPixels();
			m_width = texture.width;
			m_height = texture.height;

			m_wrapMode = wrapMode;
		}

    /// <summary>
    /// Decode to textures from GIF data
    /// </summary>
    /// <param name="gifData">GIF data</param>
    /// <param name="gifTexList">GIF texture list</param>
    /// <param name="filterMode">Textures filter mode</param>
    /// <param name="wrapMode">Textures wrap mode</param>
    /// <returns>IEnumerator</returns>
    static IEnumerator DecodeTextureCoroutine(GifData gifData, List<GifTexture> gifTexList, FilterMode filterMode, TextureWrapMode wrapMode)
    {
        if (gifData.imageBlockList == null || gifData.imageBlockList.Count < 1) {
            yield break;
        }

        Color32? bgColor = GetGlobalBgColor (gifData);

        // Disposal Method
        // 0 (No disposal specified)
        // 1 (Do not dispose)
        // 2 (Restore to background color)
        // 3 (Restore to previous)
        ushort disposalMethod = 0;

        int imgBlockIndex = 0;
        foreach (var imgBlock in gifData.imageBlockList) {
            var decodedData = GetDecodedData (imgBlock);

            var colorTable = GetColorTable (gifData, imgBlock, ref bgColor);

            var graphicCtrlEx = GetGraphicCtrlExt (gifData, imgBlockIndex);

            int transparentIndex = GetTransparentIndex (graphicCtrlEx);

            // avoid lock up
            yield return 0;

            bool useBeforeTex = false;
            var tex = CreateTexture2D (gifData, gifTexList, imgBlockIndex, disposalMethod, filterMode, wrapMode, ref useBeforeTex);

            // Set pixel data
            int dataIndex = 0;
            // Reverse set pixels. because GIF data starts from the top left.
            for (int y = tex.height - 1; y >= 0; y--) {
                SetTexturePixelRow (tex, y, imgBlock, decodedData, ref dataIndex, colorTable, bgColor, transparentIndex, useBeforeTex);

                // avoid lock up
                //if (y % 10 == 0) {
                //    yield return 0;
                //}
            }
            tex.Apply ();

            float delaySec = GetDelaySec (graphicCtrlEx);

            // Add to GIF texture list
            gifTexList.Add (new GifTexture (tex, delaySec));

            disposalMethod = GetDisposalMethod (graphicCtrlEx);

            imgBlockIndex++;

            // avoid lock up
            yield return 0;
        }
    }

 public RenderTexture Get(int width, int height, int depthBuffer = 0, RenderTextureFormat format = RenderTextureFormat.ARGBHalf, RenderTextureReadWrite rw = RenderTextureReadWrite.Default, FilterMode filterMode = FilterMode.Bilinear, TextureWrapMode wrapMode = TextureWrapMode.Clamp, string name = "FactoryTempTexture")
 {
     var rt = RenderTexture.GetTemporary(width, height, depthBuffer, format);
     rt.filterMode = filterMode;
     rt.wrapMode = wrapMode;
     rt.name = name;
     m_TemporaryRTs.Add(rt);
     return rt;
 }

        /// <summary>
        /// Creates a texture instance
        /// </summary>
        /// <param name="_Name"></param>
        /// <param name="_Width"></param>
        /// <param name="_Height"></param>
        /// <param name="_Format"></param>
        /// <param name="_bUseMipMaps">Create mip maps for the texture</param>
        /// <param name="_FilterMode">Filter mode to use to sample the texture</param>
        /// <param name="_WrapMode">Wrap mode to use to address the texture</param>
        /// <returns></returns>
        public NuajTexture2D( string _Name, int _Width, int _Height, TextureFormat _Format, bool _bUseMipMaps, FilterMode _FilterMode, TextureWrapMode _WrapMode )
        {
            Help.LogDebug( "Nuaj.Help.CreateTexture() \"" + _Name + "\" => " + _Width + "x" + _Height + "x" + _Format );
            if ( _Width < 1 || _Height < 1 )
                throw new Exception( "NuajTexture2D.ctor() => Invalid resolution !" );

            m_Texture = new Texture2D( _Width, _Height, _Format, _bUseMipMaps );
            m_Texture.name = _Name;
            m_Texture.filterMode = _FilterMode;
            m_Texture.wrapMode = _WrapMode;
            m_Texture.hideFlags = HideFlags.HideAndDontSave;
        }

 public static void CheckMaterialMode(Material aMat, TextureWrapMode aDesiredMode)
 {
     if (aMat != null && aMat.mainTexture != null && aMat.mainTexture.wrapMode != aDesiredMode) {
         if (EditorUtility.DisplayDialog("Ferr2D Terrain", "The Material's texture 'Wrap Mode' generally works best when set to "+aDesiredMode+"! Would you like this texture to be updated?", "Yes", "No")) {
             string          path = AssetDatabase.GetAssetPath(aMat.mainTexture);
             TextureImporter imp  = AssetImporter.GetAtPath   (path) as TextureImporter;
             if (imp != null) {
                 imp.wrapMode = aDesiredMode;
                 AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
             }
         }
     }
 }

 public MRT(int width, int height, RenderTextureFormat format = RenderTextureFormat.ARGBFloat, FilterMode filterMode = FilterMode.Point, TextureWrapMode wrapMode = TextureWrapMode.Repeat)
 {
     RTs = new RenderTexture[3];
     for(int i = 0, n = RTs.Length; i < n; i++) {
         int depth = (i == 0) ? 24 : 0;
         RTs[i] = new RenderTexture(width, height, depth);
         RTs[i].hideFlags = HideFlags.DontSave;
         RTs[i].format = format;
         RTs[i].filterMode = filterMode;
         RTs[i].wrapMode = wrapMode;
         RTs[i].Create();
     }
 }

 /// <summary>
 /// Constructs a new TextureSlot.
 /// </summary>
 /// <param name="filePath">Texture filepath</param>
 /// <param name="typeSemantic">Texture type semantic</param>
 /// <param name="texIndex">Texture index in the material</param>
 /// <param name="mapping">Texture mapping</param>
 /// <param name="uvIndex">UV channel in mesh that corresponds to this texture</param>
 /// <param name="blendFactor">Blend factor</param>
 /// <param name="texOp">Texture operation</param>
 /// <param name="wrapMode">Texture wrap mode</param>
 /// <param name="flags">Misc flags</param>
 public TextureSlot(String filePath, TextureType typeSemantic, uint texIndex, TextureMapping mapping, uint uvIndex, float blendFactor,
     TextureOperation texOp, TextureWrapMode wrapMode, uint flags)
 {
     _filePath = (filePath == null) ? String.Empty : filePath;
         _type = typeSemantic;
         _index = texIndex;
         _mapping = mapping;
         _uvIndex = uvIndex;
         _blendFactor = blendFactor;
         _texOp = texOp;
         _wrapMode = wrapMode;
         _flags = flags;
 }

        public SamplerStateDesc(SamplerStateTypes type)
        {
            switch (type)
            {
                case SamplerStateTypes.Point_Wrap:
                    filterMin = TextureFilterMode.Nearest;
                    filterMinMiped = TextureFilterMode.Nearest;
                    filterMag = TextureFilterMode.Nearest;
                    addressU = TextureWrapMode.Repeat;
                    addressV = TextureWrapMode.Repeat;
                    addressW = TextureWrapMode.Repeat;
                    break;

                case SamplerStateTypes.Point_Clamp:
                    filterMin = TextureFilterMode.Nearest;
                    filterMinMiped = TextureFilterMode.Nearest;
                    filterMag = TextureFilterMode.Nearest;
                    addressU = TextureWrapMode.ClampToEdge;
                    addressV = TextureWrapMode.ClampToEdge;
                    addressW = TextureWrapMode.ClampToEdge;
                    break;

                case SamplerStateTypes.Linear_Wrap:
                    filterMin = TextureFilterMode.Linear;
                    filterMinMiped = TextureFilterMode.Linear;
                    filterMag = TextureFilterMode.Linear;
                    addressU = TextureWrapMode.Repeat;
                    addressV = TextureWrapMode.Repeat;
                    addressW = TextureWrapMode.Repeat;
                    break;

                case SamplerStateTypes.Linear_Clamp:
                    filterMin = TextureFilterMode.Linear;
                    filterMinMiped = TextureFilterMode.Linear;
                    filterMag = TextureFilterMode.Linear;
                    addressU = TextureWrapMode.ClampToEdge;
                    addressV = TextureWrapMode.ClampToEdge;
                    addressW = TextureWrapMode.ClampToEdge;
                    break;

                default:
                    Debug.ThrowError("SamplerStateDesc", "Unsuported SamplerStateType");
                    break;
            }
        }

	public TextureAtlasInfo()
	{
		anisoLevel = 1;
		compressTexturesInMemory = true;
		filterMode = FilterMode.Trilinear;
		ignoreAlpha = true;
		wrapMode = TextureWrapMode.Clamp;	
	
		shaderPropertiesToLookFor = new ShaderProperties[]
		{
			new ShaderProperties(false, "_MainTex"), 
			new ShaderProperties(true, "_BumpMap"), 
			new ShaderProperties(false, "_Cube"), 
			new ShaderProperties(false, "_DecalTex"), 
			new ShaderProperties(false, "_Detail"), 
			new ShaderProperties(false, "_ParallaxMap")
		};
	}

 private void ConvertTextureWrapSettings(TextureWrapMode mode,
     out F3DEX_G_SetTile.TextureMirrorSetting mirror, out F3DEX_G_SetTile.TextureWrapSetting wrap)
 {
     if (mode == TextureWrapMode.MirroredRepeat)
     {
         mirror = F3DEX_G_SetTile.TextureMirrorSetting.G_TX_MIRROR;
         wrap = F3DEX_G_SetTile.TextureWrapSetting.G_TX_WRAP;
     }
     else if (mode == TextureWrapMode.Repeat)
     {
         mirror = F3DEX_G_SetTile.TextureMirrorSetting.G_TX_NOMIRROR;
         wrap = F3DEX_G_SetTile.TextureWrapSetting.G_TX_WRAP;
     }
     else
     {
         mirror = F3DEX_G_SetTile.TextureMirrorSetting.G_TX_NOMIRROR;
         wrap = F3DEX_G_SetTile.TextureWrapSetting.G_TX_CLAMP;
     }
 }

    /// <summary>
    /// Get GIF texture list Coroutine (Avoid lock up but more slow)
    /// </summary>
    /// <param name="mb">MonoBehaviour to start the coroutine</param>
    /// <param name="bytes">GIF file byte data</param>
    /// <param name="cb">Callback method(param is GIF texture list, Animation loop count, GIF image width (px), GIF image height (px))</param>
    /// <param name="filterMode">Textures filter mode</param>
    /// <param name="wrapMode">Textures wrap mode</param>
    /// <param name="debugLog">Debug Log Flag</param>
    /// <returns>IEnumerator</returns>
    public static IEnumerator GetTextureListCoroutine (MonoBehaviour mb, byte[] bytes, Action<List<GifTexture>, int, int, int> cb,
        FilterMode filterMode = FilterMode.Bilinear, TextureWrapMode wrapMode = TextureWrapMode.Clamp, bool debugLog = false)
    {
        int loopCount = -1;
        int width = 0;
        int height = 0;

        // Set GIF data
        var gifData = new GifData ();
        if (SetGifData (bytes, ref gifData, debugLog) == false) {
            Debug.LogError ("GIF file data set error.");
            if (cb != null) {
                cb (null, loopCount, width, height);
            }
            yield break;
        }

        // avoid lock up
        yield return 0;

        // Decode to textures from GIF data
        List<GifTexture> gifTexList = null;
        yield return mb.StartCoroutine (UniGif.DecodeTextureCoroutine (gifData, gtList => {
            gifTexList = gtList;
        }, filterMode, wrapMode));

        if (gifTexList == null) {
            Debug.LogError ("GIF texture decode error.");
            if (cb != null) {
                cb (null, loopCount, width, height);
            }
            yield break;
        }

        loopCount = gifData.appEx.loopCount;
        width = gifData.logicalScreenWidth;
        height = gifData.logicalScreenHeight;

        if (cb != null) {
            cb (gifTexList, loopCount, width, height);
        }
    }

 public Texture(Bitmap bitmap, TextureMagFilter minMagFilter = TextureMagFilter.Linear,
                               TextureWrapMode wrapMode = TextureWrapMode.ClampToEdge)
 {
     GL.GenTextures(1, out _object);
     GL.BindTexture(TextureTarget.Texture2D, _object);
     GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minMagFilter);
     GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)minMagFilter);
     GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)wrapMode);
     GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)wrapMode);
     GL.TexImage2D(TextureTarget.Texture2D,
                   0,
                   TextureFormatForBitmapFormat(bitmap.Format),
                   (int)bitmap.Width,
                   (int)bitmap.Height,
                   0,
                   PixelFormatForBitmap(bitmap.Format),
                   PixelType.UnsignedByte,
                   bitmap.PixelBuffer);
     GL.BindTexture(TextureTarget.Texture2D, 0);
     bitmap.Unlock();
 }

        public Texture(Bitmap bitmap, TextureMinFilter minFilter = TextureMinFilter.Linear, TextureMagFilter magFilter = TextureMagFilter.Nearest, TextureWrapMode wrapS = TextureWrapMode.ClampToBorderSgis, TextureWrapMode wrapT = TextureWrapMode.ClampToBorderSgis)
        {
            int textureID;
            GL.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Nicest);

            GL.GenTextures(1, out textureID);
            GL.BindTexture(TextureTarget.Texture2D, textureID);
            GL.Ext.GenerateMipmap(GenerateMipmapTarget.Texture2D);
            BitmapData data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);

            GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, data.Width, data.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0);
            bitmap.UnlockBits(data);

            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)minFilter);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)magFilter);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)wrapS);
            GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)wrapT);

            GL.BindTexture(TextureTarget.Texture2D, 0);

            this.textureID = textureID;
            Width = bitmap.Width;
            Height = bitmap.Height;
        }