Unity 使用C#翻转图片并缩放

翻墙看来的代码，其实自己写也不会很麻烦，就是花点时间而已（我只是代码的搬运工。。。）

水平翻转图片

  Texture2D FlipTexture(Texture2D orig) {
    Texture2D flip = new Texture2D(orig.width,orig.height);
    int xN = orig.width;
    int yN = orig.height;

    for(int i=0; i < xN; i++) {
    for(int j=0; j < yN; j++) {
    flip.SetPixel(xN-i-1, j, orig.GetPixel(i,j));
    }
    }

    flip.Apply();
    return flip;
    }

垂直翻转图片

 

 

  Texture2D FlipTexture(Texture2D orig) {
    Texture2D flip = new Texture2D(orig.width,orig.height);
    int xN = orig.width;
    int yN = orig.height;

    for(int i=0; i < xN; i++) {
    for(int j=0; j < yN; j++) {
    flip.SetPixel(i, yN - j - 1, orig.GetPixel(i,j));
    }
    }

    flip.Apply();
    return flip;
    }

缩放TextureScale.cs

 

 

using UnityEngine;

using UnityEngine.UI;
using System.Collections;
using System.Threading;


public class TextureScale : MonoBehaviour {

    public class ThreadData
    {
        public int start;
        public int end;
        public ThreadData(int s, int e)
        {
            start = s;
            end = e;
        }
    }

    private static Color[] texColors;
    private static Color[] newColors;
    private static int w;
    private static float ratioX;
    private static float ratioY;
    private static int w2;
    private static int finishCount;
    private static Mutex mutex;

    public static Texture2D Point(Texture2D tex, int newWidth, int newHeight,bool flipH,bool flipV)
    {
       return ThreadedScale(tex, newWidth, newHeight, false,flipH,flipV);
    }

    public static Texture2D Bilinear(Texture2D tex, int newWidth, int newHeight,bool flipH,bool flipV)
    {
        return ThreadedScale(tex, newWidth, newHeight, true,flipH, flipV);
    }

    private static Texture2D ThreadedScale(Texture2D tex, int newWidth, int newHeight, bool useBilinear,bool flipH,bool flipV)
    {
        texColors = tex.GetPixels();
        newColors = new Color[newWidth * newHeight];
        if (useBilinear)
        {
            ratioX = 1.0f / ((float)newWidth / (tex.width - 1));
            ratioY = 1.0f / ((float)newHeight / (tex.height - 1));
        }
        else
        {
            ratioX = ((float)tex.width) / newWidth;
            ratioY = ((float)tex.height) / newHeight;
        }
        w = tex.width;
        w2 = newWidth;
        var cores = Mathf.Min(SystemInfo.processorCount, newHeight);
        var slice = newHeight / cores;

        finishCount = 0;
        if (mutex == null)
        {
            mutex = new Mutex(false);
        }
        if (cores > 1)
        {
            int i = 0;
            ThreadData threadData;
            for (i = 0; i < cores - 1; i++)
            {
                threadData = new ThreadData(slice * i, slice * (i + 1));
                ParameterizedThreadStart ts = useBilinear ? new ParameterizedThreadStart(BilinearScale) : new ParameterizedThreadStart(PointScale);
                Thread thread = new Thread(ts);
                thread.Start(threadData);
            }
            threadData = new ThreadData(slice * i, newHeight);
            if (useBilinear)
            {
                BilinearScale(threadData);
            }
            else
            {
                PointScale(threadData);
            }
            while (finishCount < cores)
            {
                Thread.Sleep(1);
            }
        }
        else
        {
            ThreadData threadData = new ThreadData(0, newHeight);
            if (useBilinear)
            {
                BilinearScale(threadData);
            }
            else
            {
                PointScale(threadData);
            }
        }

     

      
        tex.Resize(newWidth, newHeight);
        tex.SetPixels(newColors);
        tex.Apply();
        Texture2D orig = new Texture2D(tex.width, tex.height);
        if (flipV)
        {
            int xN = tex.width;
            int yN = tex.width;

            for (int i = 0; i < xN; i++)
            {
                for (int j = 0; j < yN; j++)
                {
                    // tex.SetPixel(xN - i - 1, j, orig.GetPixel(i, j));
                    orig.SetPixel(i, yN - j - 1, tex.GetPixel(i, j));
                }
            }
            orig.Apply();
        
        }else if (flipH)
        {
            int xN = tex.width;
            int yN = tex.width;

            for (int i = 0; i < xN; i++)
            {
                for (int j = 0; j < yN; j++)
                {
                    // tex.SetPixel(xN - i - 1, j, orig.GetPixel(i, j));
                    orig.SetPixel(xN - i - 1, j, tex.GetPixel(i, j));
                }
            }
            orig.Apply();
           
        }
        else
        {
            orig = tex;
        }
        return orig;
    }

    public static void BilinearScale(System.Object obj)
    {
        ThreadData threadData = (ThreadData)obj;
        for (var y = threadData.start; y < threadData.end; y++)
        {
            int yFloor = (int)Mathf.Floor(y * ratioY);
            var y1 = yFloor * w;
            var y2 = (yFloor + 1) * w;
            var yw = y * w2;

            for (var x = 0; x < w2; x++)
            {
                int xFloor = (int)Mathf.Floor(x * ratioX);
                var xLerp = x * ratioX - xFloor;
                newColors[yw + x] = ColorLerpUnclamped(ColorLerpUnclamped(texColors[y1 + xFloor], texColors[y1 + xFloor + 1], xLerp),
                                                       ColorLerpUnclamped(texColors[y2 + xFloor], texColors[y2 + xFloor + 1], xLerp),
                                                       y * ratioY - yFloor);
            }
        }

        mutex.WaitOne();
        finishCount++;
        mutex.ReleaseMutex();
    }

    public static void PointScale(System.Object obj)
    {
        ThreadData threadData = (ThreadData)obj;
        for (var y = threadData.start; y < threadData.end; y++)
        {
            var thisY = (int)(ratioY * y) * w;
            var yw = y * w2;
            for (var x = 0; x < w2; x++)
            {
                newColors[yw + x] = texColors[(int)(thisY + ratioX * x)];
            }
        }

        mutex.WaitOne();
        finishCount++;
        mutex.ReleaseMutex();
    }

    private static Color ColorLerpUnclamped(Color c1, Color c2, float value)
    {
        return new Color(c1.r + (c2.r - c1.r) * value,
                          c1.g + (c2.g - c1.g) * value,
                          c1.b + (c2.b - c1.b) * value,
                          c1.a + (c2.a - c1.a) * value);
    }

    }

原来只有缩放，我把翻转也给加进去了，静态方法，很容易调用

 

恩，大概就是这些了