/// <summary>
        /// Generates a texture containing the given graph's noise output.
        /// If this is being called very often, create a permanent render target and material and
        ///     use the other version of this method instead for much better performance.
        /// If an error occurred, outputs to the Unity debug console and returns "null".
        /// </summary>
        /// <param name="outputComponents">
        /// The texture output.
        /// For example, pass "rgb" or "xyz" to output the noise into the red, green, and blue channels
        ///     but not the alpha channel.
        /// </param>
        /// <param name="defaultColor">
        /// The color (generally 0-1) of the color components which aren't set by the noise.
        /// </param>
        public static Texture2D GenerateToTexture(Graph g, GraphParamCollection c, int width, int height,
												  string outputComponents, float defaultColor,
												  TextureFormat format = TextureFormat.RGBAFloat)
        {
            //Generate a shader from the graph and have Unity compile it.
            string shaderPath = Path.Combine(Application.dataPath, "gpuNoiseShaderTemp.shader");
            Shader shader = SaveShader(g, shaderPath, "TempGPUNoiseShader", outputComponents, defaultColor);
            if (shader == null)
            {
                return null;
            }

            //Render the shader's output into a render texture and copy the data to a Texture2D.
            RenderTexture target = new RenderTexture(width, height, 16, RenderTextureFormat.ARGBFloat);
            target.Create();
            Texture2D resultTex = new Texture2D(width, height, format, false, true);

            //Create the material and set its parameters.
            Material mat = new Material(shader);
            c.SetParams(mat);

            GraphUtils.GenerateToTexture(target, mat, resultTex);

            //Clean up.
            target.Release();
            if (!AssetDatabase.DeleteAsset(StringUtils.GetRelativePath(shaderPath, "Assets")))
            {
                Debug.LogError("Unable to delete temp file: " + shaderPath);
            }

            return resultTex;
        }

        public static Texture2D LoadTextureDXT( string path, TextureFormat format, bool mipmap = true )
        {
            var a = Path.Combine( GenFilePaths.CoreModsFolderPath, LoadedModManager.LoadedMods.ToList().Find( s => s.name == "LT_RedistHeat" ).name );
            var b = Path.Combine( a, "Textures" );
            var filePath = Path.Combine( b,  path + ".dds");
            var bytes = File.ReadAllBytes( filePath );

            if (format != TextureFormat.DXT1 && format != TextureFormat.DXT5)
                throw new Exception("Invalid TextureFormat. Only DXT1 and DXT5 formats are supported by this method.");

            var ddsSizeCheck = bytes[4];
            if (ddsSizeCheck != 124)
                throw new Exception("Invalid DDS DXT texture. Unable to read");  //this header byte should be 124 for DDS image files

            var height = bytes[13] * 256 + bytes[12];
            var width = bytes[17] * 256 + bytes[16];

            var dxtBytes = new byte[bytes.Length - DDSHeaderSize];
            Buffer.BlockCopy(bytes, DDSHeaderSize, dxtBytes, 0, bytes.Length - DDSHeaderSize);

            var texture = new Texture2D(width, height, format, mipmap);
            texture.LoadRawTextureData(dxtBytes);
            texture.Apply();

            return (texture);
        }

        public static Texture2D CreateClipMask(float[] heightMap, int size, float shoreLevel, TextureFormat format)
        {
            Texture2D mask = new Texture2D(size, size, format, false, true);
            mask.filterMode = FilterMode.Bilinear;

            int s2 = size * size;

            Color[] colors = new Color[s2];

            for (int i = 0; i < s2; i++)
            {
                float h = Mathf.Clamp(heightMap[i] - shoreLevel, 0.0f, 1.0f);

                if (h > 0.0f) h = 1.0f;

                colors[i].r = h;
                colors[i].g = h;
                colors[i].b = h;
                colors[i].a = h;
            }

            mask.SetPixels(colors);

            mask.Apply();

            return mask;
        }

        public void OpenTexture(Stream data, string fname, TextureFormat format)
        {
            Bitmap textureBitmap;
            Texture.Read(data, out textureBitmap, format);

            DisplayTexture(textureBitmap, fname, format);
        }

        public static void GetDXT(Texture2D texture, int i, byte[] bytes, TextureFormat format)
        {
            Color32[] colors = texture.GetPixels32(i);
            uint w = (uint) texture.width>>i;
            uint h = (uint) texture.height>>i;

            ColorBlock rgba = new ColorBlock();
            BlockDXT1 block1 = new BlockDXT1();
            BlockDXT5 block5 = new BlockDXT5();

            int blocksize = format == TextureFormat.DXT1 ? 8 : 16;
            int index = 0;
            for (uint y = 0; y < h; y += 4) {
                for (uint x = 0; x < w; x += 4) {
                    rgba.init(w, h, colors, x, y);

                    if (format == TextureFormat.DXT1)
                    {
                        QuickCompress.compressDXT1(rgba, block1);
                        block1.WriteBytes(bytes, index);
                    }
                    else
                    {
                        QuickCompress.compressDXT5(rgba, block5, 0);
                        block5.WriteBytes(bytes, index);
                    }

                    index += blocksize;
                }
            }
        }

 public static uint GetPixelSize(TextureFormat textureFormat, int width, int height)
 {
     switch (textureFormat)
     {
         case TextureFormat.Rgba8:
             return (uint)(4 * width * height);
         case TextureFormat.Rgb8:
             return (uint)(3 * width * height);
         case TextureFormat.Rgb5551:
         case TextureFormat.Rgb565:
         case TextureFormat.Rgba4:
         case TextureFormat.La8:
         case TextureFormat.Hilo8:
             return (uint)(2 * width * height);
         case TextureFormat.L8:
         case TextureFormat.A8:
         case TextureFormat.La4:
             return (uint)(1 * width * height);
         case TextureFormat.L4: //TODO: Verify this is correct
         case TextureFormat.A4:
             return (uint)((1 * width * height) / 2);
         case TextureFormat.Etc1:
             return (uint)Etc.GetEtc1Length(new Size(width, height), false);
         case TextureFormat.Etc1A4:
             return (uint)Etc.GetEtc1Length(new Size(width, height), true);
         default:
             throw new Exception("Unsupported Texture Format " + (int)textureFormat);
     }
 }

        /// <summary>
        /// Creates a bitmap from the currently bound texture
        /// </summary>
        public static unsafe Bitmap CreateBitmapFromTexture( int target, int level, TextureFormat format )
        {
            int width = GetTextureLevelParameterInt32( target, level, Gl.GL_TEXTURE_WIDTH );
            int height = GetTextureLevelParameterInt32( target, level, Gl.GL_TEXTURE_HEIGHT );

            GraphicsLog.Verbose( "Creating bitmap from level {0} in {1}x{2} {3} texture", level, width, height, format );

            if ( ( format == TextureFormat.Depth16 ) || ( format == TextureFormat.Depth24 ) || ( format == TextureFormat.Depth32 ) )
            {
                return CreateBitmapFromDepthTexture( target, level, width, height );
            }

            //	Handle colour textures

            //	Get texture memory
            int bytesPerPixel = TextureFormatInfo.GetSizeInBytes( format );
            TextureInfo info = CheckTextureFormat( format );
            byte[] textureMemory = new byte[ width * height * bytesPerPixel ];
            Gl.glGetTexImage( Gl.GL_TEXTURE_2D, level, info.GlFormat, info.GlType, textureMemory );

            //	TODO: Same problem as above...

            //	Create a Bitmap object from image memory
            fixed ( byte* textureMemoryPtr = textureMemory )
            {
                //	TODO: Add per-case check of Format - in cases with no mapping (see TextureFormatToPixelFormat()), do a manual conversion
                return new Bitmap( width, height, width * bytesPerPixel, TextureFormatInfo.ToPixelFormat( format ), ( IntPtr )textureMemoryPtr );
            }
        }

    public static Texture3D LoadVolumeFromFile(string fileName, TextureFormat format, int elementSize ,int width, int height, int depth)
    {
        BinaryReader br = new BinaryReader(File.Open(fileName, FileMode.Open, FileAccess.Read));
        Texture3D noiseTex = new Texture3D(width, height, depth, TextureFormat.RGBA32, false);
        noiseTex.filterMode = FilterMode.Bilinear;
        noiseTex.wrapMode = TextureWrapMode.Repeat;

        int numElements = width * height * depth;
        List<Color> colors = new List<Color>(numElements);


        // Get pixels from 2d texture for each slize in z direction
        for (int z = 0; z < depth; z++)
        {
            Texture2D tex2d = LoadTexture2DRaw(br, width, height, format, elementSize);
            colors.AddRange(tex2d.GetPixels());
        }
        //colors should now be filled with all pixels
        noiseTex.SetPixels(colors.ToArray());
        noiseTex.Apply(false);

        br.Close();
        return noiseTex;
   
    }

 /// <summary>
 /// Creates the texture data
 /// </summary>
 public void Create( int width, int height, TextureFormat format )
 {
     m_Width = width;
     m_Height = height;
     m_Format = format;
     m_Data = new byte[ width * height * TextureFormatInfo.GetSizeInBytes( format ) ];
 }

        public Corona.Image ConvertDown(Corona.Image sourceImage, TextureFormat toFormat)
        {
            int bits = -1;
            if (toFormat == TextureFormat.Format2_I2) bits = 2;
            if (toFormat == TextureFormat.Format3_I4) bits = 4;
            if (toFormat == TextureFormat.Format4_I8) bits = 8;
            if (toFormat == TextureFormat.Format7_16bpp) bits = 16;

            int colors = 1<<bits;

            Corona.Image ret = null;

            using (Util.TempFile tmpIn = new Util.TempFile("png"), tmpOut = new Util.TempFile("png"))
            {
                sourceImage.Save(tmpIn.Path, Corona.FileFormat.PNG);

                string output = Run("-treedepth", 4, "-colors", colors, tmpIn, tmpOut);

                if (toFormat == TextureFormat.Format7_16bpp)
                    ret = Corona.Image.Open(tmpOut.Path, Corona.PixelFormat.R8G8B8A8, Corona.FileFormat.PNG);
                else
                    ret = Corona.Image.Open(tmpOut.Path, Corona.PixelFormat.I8, Corona.FileFormat.PNG);

            }
            return ret;
        }

 public static byte[] GetScreenBytes(TextureFormat textureFormat)
 {
     Texture2D screenTexture = new Texture2D(Screen.width, Screen.height,textureFormat,true);
     screenTexture.ReadPixels(new Rect(0f, 0f, Screen.width, Screen.height),0,0);
     screenTexture.Apply();
     byte[] byteArray = screenTexture.EncodeToPNG();
     return byteArray;
 }

		public TileMeshSettings (IVector2 tiles, int tileResolution, float tileSize, MeshMode meshMode, TextureFormat textureFormat)
		{
			Tiles			= tiles;
			TileResolution	= tileResolution;
			TileSize		= tileSize;
			MeshMode		= meshMode;
			TextureFormat	= textureFormat;
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="Tango.YUVTexture"/> class.
 /// NOTE : Texture resolutions will be reset by the API. The sizes passed
 /// into the constructor are not guaranteed to persist when running on device.
 /// </summary>
 /// <param name="width">Width.</param>
 /// <param name="height">Height.</param>
 /// <param name="format">Format.</param>
 /// <param name="mipmap">If set to <c>true</c> mipmap.</param>
 public YUVTexture(int yPlaneWidth, int yPlaneHeight,
                   int uvPlaneWidth, int uvPlaneHeight,
                   TextureFormat format, bool mipmap)
 {
     m_videoOverlayTextureY = new Texture2D(yPlaneWidth, yPlaneHeight, format, mipmap);
     m_videoOverlayTextureCb = new Texture2D(uvPlaneWidth, uvPlaneHeight, format, mipmap);
     m_videoOverlayTextureCr = new Texture2D(uvPlaneWidth, uvPlaneHeight, format, mipmap);
 }

	public Texture2DInfo(int width, int height, TextureFormat format, bool hasMipmaps, byte[] rawData)
	{
		this.width = width;
		this.height = height;
		this.format = format;
		this.hasMipmaps = hasMipmaps;
		this.rawData = rawData;
	}

 public TileMeshSettings(int tilesX, int tilesY, int tileResolution, float tileSize, MeshMode meshMode, TextureFormat textureFormat)
 {
     TilesX = tilesX;
     TilesY = tilesY;
     TileResolution = tileResolution;
     TileSize = tileSize;
     MeshMode = meshMode;
     TextureFormat = textureFormat;
 }

 public static int GetBitsPerPixel(TextureFormat format)
 {
     switch (format)
     {
     case TextureFormat.Alpha8: //	 Alpha-only texture format.
         return 8;
     case TextureFormat.ARGB4444: //	 A 16 bits/pixel texture format. Texture stores color with an alpha channel.
         return 16;
     case TextureFormat.RGBA4444: //	 A 16 bits/pixel texture format.
         return 16;
     case TextureFormat.RGB24:	// A color texture format.
         return 24;
     case TextureFormat.RGBA32:	//Color with an alpha channel texture format.
         return 32;
     case TextureFormat.ARGB32:	//Color with an alpha channel texture format.
         return 32;
     case TextureFormat.RGB565:	//	 A 16 bit color texture format.
         return 16;
     case TextureFormat.DXT1:	// Compressed color texture format.
         return 4;
     case TextureFormat.DXT5:	// Compressed color with alpha channel texture format.
         return 8;
         /*
         case TextureFormat.WiiI4:	// Wii texture format.
         case TextureFormat.WiiI8:	// Wii texture format. Intensity 8 bit.
         case TextureFormat.WiiIA4:	// Wii texture format. Intensity + Alpha 8 bit (4 + 4).
         case TextureFormat.WiiIA8:	// Wii texture format. Intensity + Alpha 16 bit (8 + 8).
         case TextureFormat.WiiRGB565:	// Wii texture format. RGB 16 bit (565).
         case TextureFormat.WiiRGB5A3:	// Wii texture format. RGBA 16 bit (4443).
         case TextureFormat.WiiRGBA8:	// Wii texture format. RGBA 32 bit (8888).
         case TextureFormat.WiiCMPR:	//	 Compressed Wii texture format. 4 bits/texel, ~RGB8A1 (Outline alpha is not currently supported).
             return 0;  //Not supported yet
         */
     case TextureFormat.PVRTC_RGB2://	 PowerVR (iOS) 2 bits/pixel compressed color texture format.
         return 2;
     case TextureFormat.PVRTC_RGBA2://	 PowerVR (iOS) 2 bits/pixel compressed with alpha channel texture format
         return 2;
     case TextureFormat.PVRTC_RGB4://	 PowerVR (iOS) 4 bits/pixel compressed color texture format.
         return 4;
     case TextureFormat.PVRTC_RGBA4://	 PowerVR (iOS) 4 bits/pixel compressed with alpha channel texture format
         return 4;
     case TextureFormat.ETC_RGB4://	 ETC (GLES2.0) 4 bits/pixel compressed RGB texture format.
         return 4;
     case TextureFormat.ATC_RGB4://	 ATC (ATITC) 4 bits/pixel compressed RGB texture format.
         return 4;
     case TextureFormat.ATC_RGBA8://	 ATC (ATITC) 8 bits/pixel compressed RGB texture format.
         return 8;
     case TextureFormat.BGRA32://	 Format returned by iPhone camera
         return 32;
     // case TextureFormat.ATF_RGB_DXT1://	 Flash-specific RGB DXT1 compressed color texture format.
     // case TextureFormat.ATF_RGBA_JPG://	 Flash-specific RGBA JPG-compressed color texture format.
     // case TextureFormat.ATF_RGB_JPG://	 Flash-specific RGB JPG-compressed color texture format.
     // 	return 0; //Not supported yet
     }
     return 0;
 }

 /// <summary>
 /// Returns true if the specified texture format supports an alpha channel
 /// </summary>
 public static bool HasAlphaChannel( TextureFormat texFormat )
 {
     switch ( texFormat )
     {
         case TextureFormat.R8G8B8A8:
         case TextureFormat.B8G8R8A8:
         case TextureFormat.A8R8G8B8:
         case TextureFormat.A8B8G8R8: return true;
     }
     return false;
 }

 public static bool getTextureFormat(ref TextureFormat result, SerializedObject serialTex)
 {
     if(serialTex == null) return false;
     SerializedProperty prop = serialTex.FindProperty("m_TextureFormat");
     if( prop != null ) {
         result = (TextureFormat)prop.intValue;
         return true;
     }
     Debug.LogError("m_TextureFormat SerializedProperty not found!");
     return false;
 }

		// Load a texture with the specified height and calculating width by respecting the aspect ratio
		public static Texture2D LoadFixedHeightFromFile(string filePath, int fixedHeight, TextureFormat textureFormat = TextureFormat.R16)
		{
			Vector2 imageSize = ImageHelper.GetDimensions(filePath);
			float width = fixedHeight;
			if (imageSize.y != 0)
			{
				width = imageSize.x * fixedHeight / imageSize.y;
			}
			
			return LoadFromFile(filePath, (int)width, fixedHeight, textureFormat);
		}

 public static IEnumerator LoadImage(this Texture2D texture2D, string url, Vector2 size, TextureFormat format = TextureFormat.RGB24, bool mipmap = false)
 {
     Texture2D tex = new Texture2D((int)size.x, (int)size.y, format, mipmap);
     WWW www = new WWW(url);
     yield return www;
     if (string.IsNullOrEmpty(www.error))
     {
         www.LoadImageIntoTexture(tex);
         texture2D = tex;
     }
 }