Unity编辑器插件 ——等比例重新设置图片size

using UnityEngine;
using UnityEditor;
using System.IO;
using System;

public class SetTextureSize :Editor
{
    [MenuItem("重新设置图片大小/一键设置")]
    public static void OverrideAllTexture()
    {
       // List<string> filePaths = new List<string>();
        string imgtype = "*.BMP|*.JPG|*.GIF|*.PNG";
       // string[] img_suffix = { ".bmp", ".jpg", ".gif", ".png" };
        string[] ImageType = imgtype.Split('|');
        for (int i = 0; i < ImageType.Length; i++)
        {
            //获取d盘中a文件夹下所有的图片路径  
            string[] dirs = Directory.GetFiles(@"d:\\a", ImageType[i]);
            for (int j = 0; j < dirs.Length; j++)
            {
               // filePaths.Add(dirs[j]);
                string[] str = dirs[j].Split('\\');
                string picName = str[str.Length - 1];
                byte[] bytes;
                Vector2 vector;
                FileUtility.FileInfo(dirs[j],out bytes,out vector);
                float width=vector.x, height=vector.y;
                float n=1;
                if (width >= 1024)
                {
                    Debug.LogWarning("宽度度大于1024，次数宽度  " + width + " 缩放系数 " + n);
                    n = width / 1024;
                    width = 1024;
                    height = height / n;
                    Texture2D texture = ReSetTextureSize(LoadTexture(dirs[j]), (int)width, (int)height);
                    SaveTexture(texture, @"d:\\b\" + picName);
                }
                else if(height >= 1024)
                {
                    Debug.LogWarning("高度度大于1024,此时高度  " + height + " 缩放系数" + n);
                    n = height / 1024;
                    height = 1024;
                    width = width / n;
                    Texture2D texture = ReSetTextureSize(LoadTexture(dirs[j]), (int)width, (int)height);
                    SaveTexture(texture, @"d:\\b\" + picName);
                }
                Debug.Log(dirs[j] +"原来大小: "+ vector+"缩小后大小:  "+(int)width+" "+(int)height+" 缩放系数： "+n);
            }
        }
    }

    private static Texture2D  LoadTexture(string _path)
    {
        FileStream fileStream = new FileStream(_path, FileMode.Open, FileAccess.Read);
        fileStream.Seek(0, SeekOrigin.Begin);

        byte[] bytes = new byte[fileStream.Length];
        fileStream.Read(bytes, 0, (int)fileStream.Length);

        fileStream.Close();
        fileStream.Dispose();
        fileStream = null;
        int width = 1024;
        int height = 1024;

        Texture2D texture = new Texture2D(width, height);
        texture.LoadImage(bytes);
        return texture;

        //WWW www = new WWW(_path);
        //yield return www;
        //int n = www.texture.width / 1024;
        //int width = 1024;
        //int height = www.texture.height / n;
        //ReSetTextureSize(www.texture, width, height);
        //SaveTexture(www.texture,_newPath);
    }

    private static void SaveTexture(Texture2D texture, string _path)
    {
        using (var fs = File.OpenWrite(_path))

        {
            var bytes = texture.EncodeToPNG();

            fs.Write(bytes, 0, bytes.Length);
        }

    }

   
    public static Texture2D ReSetTextureSize(Texture2D tex, int width, int height)

    {

        var rendTex = new RenderTexture(width, height, 24, RenderTextureFormat.ARGB32);

        rendTex.Create();
        //设置当前渲染目标，设置为激活渲染目标的texture
        Graphics.SetRenderTarget(rendTex);
        //将模型、视图和投影矩阵保存到矩阵堆栈顶部，更改模型、视图或投影矩阵会覆盖当前的渲染矩阵。最好使用GL.PushMatrix和GL.PopMatrix保存和回复这些矩阵
        GL.PushMatrix();
        //清除当前的渲染缓冲区 清除深度缓冲区 清除颜色缓冲区 清除时使用的颜色
        //会清除屏幕或正在绘制到的活动RenderTexture、已清除区域受活动视口限制，此操作可能会改变模型、视图、投影矩阵。
        //多数情况下，摄像机将已配置为清除屏幕或 RenderTexture，因此无需 手动执行此操作。
        GL.Clear(true, true, Color.clear);
        //从矩阵堆栈顶部恢复模型、视图、投影矩阵
        GL.PopMatrix();

        var mat = new Material(Shader.Find("Unlit/Transparent"));

        mat.mainTexture = tex;

        Graphics.SetRenderTarget(rendTex);

        GL.PushMatrix();
        //用于设置正交投影。将正交投影加载到投影矩阵中，将标识加载到 模型和视图矩阵中。
        GL.LoadOrtho();

        mat.SetPass(0);
        //开始绘制3D图元
        GL.Begin(GL.QUADS);
        //为所有纹理单位均设置当前纹理坐标（x,y）
        GL.TexCoord2(0, 0);
        //提交一个顶点
        GL.Vertex3(0, 0, 0);

        GL.TexCoord2(0, 1);

        GL.Vertex3(0, 1, 0);

        GL.TexCoord2(1, 1);

        GL.Vertex3(1, 1, 0);

        GL.TexCoord2(1, 0);

        GL.Vertex3(1, 0, 0);
        //结束绘制3d图元
        GL.End();

        GL.PopMatrix();

        var finalTex = new Texture2D(rendTex.width, rendTex.height, TextureFormat.ARGB32, false);

        RenderTexture.active = rendTex;
        //将屏幕像素读取到保存的纹理数据中
        finalTex.ReadPixels(new Rect(0, 0, finalTex.width, finalTex.height), 0, 0);

        finalTex.Apply();

        return finalTex;

    }

}

public class FileUtility
{
    public enum ImageType
    {
        Null,
        Png,
        Jpg,
        Gif,
        Bmp
    }
    /// <summary>
    /// 获取图片格式
    /// </summary>
    private static ImageType GetImageType(byte[] bytes)
    {
        byte[] header = new byte[8];
        Array.Copy(bytes, header, header.Length);
        ImageType type = ImageType.Null;
        //读取图片文件头8个字节
        //Png图片 8字节：89 50 4E 47 0D 0A 1A 0A   =  [1]:P[2]:N[3]:G
        if (header[0] == 0x89 && header[1] == 0x50 && header[2] == 0x4E && header[3] == 0x47 &&
            header[4] == 0x0D && header[5] == 0x0A && header[6] == 0x1A && header[7] == 0x0A)
        {
            type = ImageType.Png;
        }
        //Jpg图片 2字节：FF D8
        else if (header[0] == 0xFF && header[1] == 0xD8)
        {
            type = ImageType.Jpg;
        }
        //Gif图片 6字节：47 49 46 38 39|37 61   =   GIF897a
        else if (header[0] == 0x47 && header[1] == 0x49 && header[2] == 0x46 && header[3] == 0x38 &&
            (header[4] == 0x39 || header[4] == 0x37) && header[5] == 0x61)
        {
            type = ImageType.Gif;
        }
        //Bmp图片 2字节：42 4D
        else if (header[0] == 0x42 && header[1] == 0x4D)
        {
            type = ImageType.Bmp;
        }
        return type;
    }

    private static byte[] _header = null;
    private static byte[] _buffer = null;

    public static void FileInfo(string filePath, out byte[] bytes, out Vector2 size)
    {
        size = Vector2.zero;
        FileStream stream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
        stream.Seek(0, SeekOrigin.Begin);
        bytes = new byte[stream.Length];
        stream.Read(bytes, 0, (int)stream.Length);

        ImageType imageType = GetImageType(bytes);
        switch (imageType)
        {
            case ImageType.Png:
                {
                    stream.Seek(0, SeekOrigin.Begin);
                    _header = new byte[8];
                    stream.Read(_header, 0, 8);
                    stream.Seek(8, SeekOrigin.Current);

                    _buffer = new byte[8];
                    stream.Read(_buffer, 0, _buffer.Length);

                    Array.Reverse(_buffer, 0, 4);
                    Array.Reverse(_buffer, 4, 4);

                    size.x = BitConverter.ToInt32(_buffer, 0);
                    size.y = BitConverter.ToInt32(_buffer, 4);
                }
                break;
            case ImageType.Jpg:
                {
                    stream.Seek(0, SeekOrigin.Begin);
                    _header = new byte[2];
                    stream.Read(_header, 0, 2);
                    //段类型
                    int type = -1;
                    int ff = -1;
                    //记录当前读取的位置
                    long ps = 0;
                    //逐个遍历所以段，查找SOFO段
                    do
                    {
                        do
                        {
                            //每个新段的开始标识为oxff，查找下一个新段
                            ff = stream.ReadByte();
                            if (ff < 0) //文件结束
                            {
                                return;
                            }
                        } while (ff != 0xff);

                        do
                        {
                            //段与段之间有一个或多个oxff间隔，跳过这些oxff之后的字节为段标识
                            type = stream.ReadByte();
                        } while (type == 0xff);

                        //记录当前位置
                        ps = stream.Position;
                        switch (type)
                        {
                            case 0x00:
                            case 0x01:
                            case 0xD0:
                            case 0xD1:
                            case 0xD2:
                            case 0xD3:
                            case 0xD4:
                            case 0xD5:
                            case 0xD6:
                            case 0xD7:
                                break;
                            case 0xc0: //SOF0段（图像基本信息）
                            case 0xc2: //JFIF格式的 SOF0段
                                {
                                    //找到SOFO段，解析宽度和高度信息
                                    //跳过2个自己长度信息和1个字节的精度信息
                                    stream.Seek(3, SeekOrigin.Current);

                                    //高度 占2字节 低位高位互换
                                    size.y = stream.ReadByte() * 256;
                                    size.y += stream.ReadByte();
                                    //宽度 占2字节 低位高位互换
                                    size.x = stream.ReadByte() * 256;
                                    size.x += stream.ReadByte();
                                    return;
                                }
                            default: //别的段都跳过
                                     //获取段长度，直接跳过
                                ps = stream.ReadByte() * 256;
                                ps = stream.Position + ps + stream.ReadByte() - 2;
                                break;
                        }
                        if (ps + 1 >= stream.Length) //文件结束
                        {
                            return;
                        }
                        stream.Position = ps; //移动指针
                    } while (type != 0xda); // 扫描行开始
                }
                break;
            case ImageType.Gif:
                {
                    stream.Seek(0, SeekOrigin.Begin);
                    _header = new byte[6];
                    stream.Read(_header, 0, 6);

                    _buffer = new byte[4];
                    stream.Read(_buffer, 0, _buffer.Length);

                    size.x = BitConverter.ToInt16(_buffer, 0);
                    size.y = BitConverter.ToInt16(_buffer, 2);
                }
                break;
            case ImageType.Bmp:
                {
                    stream.Seek(0, SeekOrigin.Begin);
                    _header = new byte[2];
                    stream.Read(_header, 0, 2);
                    //跳过16个字节
                    stream.Seek(16, SeekOrigin.Current);
                    //bmp图片的宽度信息保存在第 18-21位 4字节
                    //bmp图片的高度度信息保存在第 22-25位 4字节
                    _buffer = new byte[8];
                    stream.Read(_buffer, 0, _buffer.Length);

                    size.x = BitConverter.ToInt32(_buffer, 0);
                    size.y = BitConverter.ToInt32(_buffer, 4);
                }
                break;
            default:
                break;
        }

        stream.Close();
        stream.Dispose();
    }

}