private static GUIStyle _style;

    [MenuItem("Textures/CutTexturesWindow")]

    public static void CutTesturesCenter()

    {

        _style = new GUIStyle();

        GetWindow<TexturesCutWindow>();

    }

    private string _path;

    // 截取中间部分

    private bool _isCutCenter;

    // 截取分辨率

    private Vector2Int _cutPixels = new Vector2Int(1280, 360);

    private void OnGUI()

    {

        EditorGUILayout.BeginHorizontal();

        if (GUILayout.Button("选择"))

            _path = EditorUtility.OpenFolderPanel("选择一个待处理文件夹", _path, "");

        EditorGUILayout.LabelField("目录：");

        if (string.IsNullOrEmpty(_path))

        {

            _style.normal.textColor = UnityEngine.Color.red;

            GUILayout.Label("请选择一个目录！", _style);

        }

        else GUILayout.Label(_path);

        EditorGUILayout.EndHorizontal();

        _isCutCenter = EditorGUILayout.Toggle("截取中间部分", _isCutCenter);

        _cutPixels = EditorGUILayout.Vector2IntField("分辨率", _cutPixels);

        if (GUILayout.Button("截取"))

        {

            if (string.IsNullOrEmpty(_path))

            {

                EditorUtility.DisplayDialog("提示", "请选择一个目录！", "OK");

                return;

            }

            CutTestures(_path, _isCutCenter, _cutPixels.x, _cutPixels.y);

        }

    }

    public static void CutTestures(string path, bool isCenter, int width, int height)

    {

        string[] textures = Directory.GetFiles(path, "*.jpg");

        string resultPath = path + "_CutResult_CenterPixel_" + isCenter;

        if (Directory.Exists(resultPath))

            Directory.Delete(resultPath, true);

        Directory.CreateDirectory(resultPath);

        string texPath;

        int texNum = textures.Length;

        for (int i = 0; i < texNum; i++)

        {

            texPath = textures[i];

            EditorUtility.DisplayProgressBar("提示", "处理中：" + texPath, (i + 1) / (float)texNum);

            Bitmap bitmap = ZoomImage(new Bitmap(texPath), width, height);

            bitmap.Save(Path.Combine(resultPath, Path.GetFileName(texPath)),);

            Debug.Log("处理完毕：" + texPath);

        }

        EditorUtility.ClearProgressBar();

    }

    // 等比例缩放图片

    private static Bitmap ZoomImage(Bitmap bitmap, int destWidth, int destHeight)

    {

        try

        {

            System.Drawing.Image sourImage = bitmap;

            Bitmap destBitmap = new Bitmap(destWidth, destHeight);

            System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(destBitmap);

            g.Clear(System.Drawing.Color.Transparent);

            g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;

            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;

            g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;

            // 尝试以宽度为基准，截取缩放

            g.DrawImage(sourImage, new Rectangle(0, 0, destWidth, destHeight), 0, 0, sourImage.Width, sourImage.Width / (destWidth / (float)destHeight), GraphicsUnit.Pixel);

            g.Dispose();

            sourImage.Dispose();

            return destBitmap;

        }

        catch

        {

            return bitmap;

        }

    }

int startX = 0, startY = 0;

// 先计算原图比例

float scaleRatio = image.Width / (float)image.Height;

// 再按照比例映射至新图时，什么分辨率合适

// 保持不变的情况下，若基于宽度

int newHeight = (int)(data.Width / scaleRatio);

// 保持不变的情况下，若基于高度

int newWidth = (int)(data.Height * scaleRatio);

// 新的正确比例情况下，哪个正确不越界

if (newHeight > data.Height)

{

    // 基于宽度，新的高度越界了那么，取基于高度

    newHeight = data.Height;

}

else

{

    // 基于高度，新的宽度越界了那么，取基于宽度

    newWidth = data.Width;

}

startX = (data.Width - newWidth) / 2;

startY = (data.Height - newHeight) / 2;

image.Mutate(x => x.Resize(data.Width, data.Height, data.ResamplerAlgorithm, new Rectangle(0, 0, image.Width, image.Height), new Rectangle(startX, startY, newWidth, newHeight), false));

//

    // 摘要:

    //     Provides enumeration over how the image should be resized.

    public enum ResizeMode

    {

        //

        // 摘要:

        //     Crops the resized image to fit the bounds of its container.

        Crop,

        //

        // 摘要:

        //     Pads the resized image to fit the bounds of its container. If only one dimension

        //     is passed, will maintain the original aspect ratio.

        Pad,

        //

        // 摘要:

        //     Pads the image to fit the bound of the container without resizing the original

        //     source. When downscaling, performs the same functionality as SixLabors.ImageSharp.Processing.ResizeMode.Pad

        BoxPad,

        //

        // 摘要:

        //     Constrains the resized image to fit the bounds of its container maintaining the

        //     original aspect ratio.

        Max,

        //

        // 摘要:

        //     Resizes the image until the shortest side reaches the set given dimension. Upscaling

        //     is disabled in this mode and the original image will be returned if attempted.

        Min,

        //

        // 摘要:

        //     Stretches the resized image to fit the bounds of its container.

        Stretch,

        //

        // 摘要:

        //     The target location and size of the resized image has been manually set.

        Manual

    }

case EScaleMode.WidthBase:

// 基于宽度，计算新的高度

int newHeight = (int)(data.Width / (image.Width / (float)image.Height));

image.Mutate(x => x.Resize(data.Width, data.Height, data.ResamplerAlgorithm, new Rectangle(0, 0, image.Width, image.Height), new Rectangle(0, (data.Height - newHeight) / 2, data.Width, newHeight), false));

break;

case EScaleMode.HeightBase:

// 基于高度，计算新的宽度

int newWidth = (int)(data.Height * (image.Width / (float)image.Height));

image.Mutate(x => x.Resize(data.Width, data.Height, data.ResamplerAlgorithm, new Rectangle(0, 0, image.Width, image.Height), new Rectangle((data.Width - newWidth) / 2, 0, newWidth, data.Height), false));

int n = 1;

int x=1080;

do { x /= 2; n++; } while (x > 2);

Print(Math.Pow(2,n));

int n = 1;

int x = 1080;

while (n < x) { n *= 2; }

// 若取比 X 更小的 2N 数值

//n-=1

Print(n);

int Calc(int x)

{

     x |= x >> 1;

     x |= x >> 2;

     x |= x >> 4;

     x |= x >> 8;

	 x |= x >> 16;

     x += 1;

	 // 比 X 小的 2N 数值

     return x >> 1;

	 // 比 X 大的 2N 数值

	 return x;

 }

int x=100;

Convert.ToString(x, 2)//		1100100

Convert.ToString(x >> 1, 2)//	 110010

Convert.ToString(x >> 2, 2)//	  11001

Convert.ToString(x >> 4, 2)//	    110

Convert.ToString(x >> 8, 2)//	      0

Convert.ToString(x >> 1|x >> 2, 2)//					111011

Convert.ToString(x >> 1|x >> 2 | x >> 4, 2)//			111111

Convert.ToString(x >> 1 | x >> 2 | x >> 4|x >> 8, 2)//	111111

int x=128;

Convert.ToString(x >> 1 | x >> 2 | x >> 4|x >> 8, 2)

"1101000"

128=      "10000000"

"10000000"|"1000000"(128>>1)="11000000"

"11000000"|" 110000"(11000000>>2)="11110000"

"11110000"|"  1111"(11110000>>4)="11111111"

"11111111"|"     0"(11111111>>8)="11111111"

> int Calc(int x)

. {

.     Print(Convert.ToString(x, 2));

.     x |= x >> 1;

.     Print(Convert.ToString(x, 2));

.     x |= x >> 2;

.     Print(Convert.ToString(x, 2));

.     x |= x >> 4;

.     Print(Convert.ToString(x, 2));

.     x |= x >> 8;

.     Print(Convert.ToString(x, 2));

.     x += 1;

.     Print(Convert.ToString(x, 2));

.     // 比 X 大的 2N 数值

.     return x;

. }

> Calc(65536)

"10000000000000000"

"11000000000000000"

"11110000000000000"

"11111111000000000"

"11111111111111110"

"11111111111111111"

131071

/// <summary>

/// 计算给定数值的 POT（根据缩放模式返回给定数值接近的 2N 数值）

/// 最大支持 65535

/// </summary>

/// <returns></returns>

private static int CalcPot(int x, EPotMode mode)

{

    int oldX = x;

    x |= x >> 1;

    x |= x >> 2;

    x |= x >> 4;

    x |= x >> 8;

    x += 1;

    int minPot = x >> 1;

    switch (mode)

    {

        case EPotMode.ToNearest:

            // 判断哪个更接近 X

            return x - oldX > oldX - minPot ? minPot : x;

        case EPotMode.ToLarger:

            // 比 X 大的 2N 数值

            return x;

        case EPotMode.ToSmaller:

            // 比 X 小的 2N 数值

            return minPot;

    }

    // 出问题了？

    return oldX;

}

> sizeof(bool)

1

> private struct CacheData

. {

.     public bool IsAddFirstName;

. }

> Marshal.SizeOf(typeof(CacheData))

4

> System.Runtime.InteropServices.Marshal.SizeOf(typeof(bool))

4

public static T? IndexToEnumNullable<T>(this int index, bool isAddFirstName = false, string? addFirstName = null) where T : struct, Enum

{

    Type type = typeof(T);

    CacheData data = GetCacheNames(type, isAddFirstName, addFirstName);

    object value;

    if (Enum.TryParse(type, data.Names[index], out value))

        return (T)value;

    return new Nullable<T>();

}