/// <summary>
/// Loads an image asset.
/// </summary>
/// <param name="path">Image path.</param>
/// <param name="filter">Image filtering mode.</param>
/// <param name="useCache">Should we use cache for this asset to make future loadings faster?</param>
/// <param name="useAssetsRoot">If true, path will be relative to 'AssetsRoot'. If false, will be relative to working directory.</param>
/// <returns>Loaded image asset.</returns>
public ImageAsset LoadImage(string path, ImageFilterMode filter = ImageFilterMode.Nearest, bool useCache = true, bool useAssetsRoot = true)
{
var ret = new ImageAsset(_BonEngineBind.BON_Assets_LoadImage(ToAssetsPath(path, true, useAssetsRoot), (int)filter, useCache));
ret.Path = path;
return(ret);
}
// Token: 0x060158C2 RID: 88258 RVA: 0x0057CC78 File Offset: 0x0057AE78
public static Texture2D ResizeTexture(Texture2D pSource, ImageFilterMode pFilterMode, float pScale)
{
Color[] pixels = pSource.GetPixels(0);
Vector2 vector = new Vector2((float)pSource.width, (float)pSource.height);
float num = (float)Mathf.RoundToInt((float)pSource.width * pScale);
float num2 = (float)Mathf.RoundToInt((float)pSource.height * pScale);
Texture2D texture2D = new Texture2D((int)num, (int)num2, TextureFormat.RGBA32, false);
int num3 = (int)num * (int)num2;
Color[] array = new Color[num3];
Vector2 vector2 = new Vector2(vector.x / num, vector.y / num2);
Vector2 vector3 = default(Vector2);
for (int i = 0; i < num3; i++)
{
float num4 = (float)i % num;
float num5 = Mathf.Floor((float)i / num);
vector3.x = num4 / num * vector.x;
vector3.y = num5 / num2 * vector.y;
if (pFilterMode == ImageFilterMode.Nearest)
{
vector3.x = Mathf.Round(vector3.x);
vector3.y = Mathf.Round(vector3.y);
int num6 = (int)(vector3.y * vector.x + vector3.x);
array[i] = pixels[num6];
}
else if (pFilterMode == ImageFilterMode.Biliner)
{
float t = vector3.x - Mathf.Floor(vector3.x);
float t2 = vector3.y - Mathf.Floor(vector3.y);
int num7 = (int)(Mathf.Floor(vector3.y) * vector.x + Mathf.Floor(vector3.x));
int num8 = (int)(Mathf.Floor(vector3.y) * vector.x + Mathf.Ceil(vector3.x));
int num9 = (int)(Mathf.Ceil(vector3.y) * vector.x + Mathf.Floor(vector3.x));
int num10 = (int)(Mathf.Ceil(vector3.y) * vector.x + Mathf.Ceil(vector3.x));
array[i] = Color.Lerp(Color.Lerp(pixels[num7], pixels[num8], t), Color.Lerp(pixels[num9], pixels[num10], t), t2);
}
else if (pFilterMode == ImageFilterMode.Average)
{
int num11 = (int)Mathf.Max(Mathf.Floor(vector3.x - vector2.x * 0.5f), 0f);
int num12 = (int)Mathf.Min(Mathf.Ceil(vector3.x + vector2.x * 0.5f), vector.x);
int num13 = (int)Mathf.Max(Mathf.Floor(vector3.y - vector2.y * 0.5f), 0f);
int num14 = (int)Mathf.Min(Mathf.Ceil(vector3.y + vector2.y * 0.5f), vector.y);
Color a = default(Color);
float num15 = 0f;
for (int j = num13; j < num14; j++)
{
for (int k = num11; k < num12; k++)
{
a += pixels[(int)((float)j * vector.x + (float)k)];
num15 += 1f;
}
}
array[i] = a / num15;
}
}
texture2D.SetPixels(array);
texture2D.Apply();
return(texture2D);
}
// http://blog.collectivemass.com/2014/03/resizing-textures-in-unity/
public static Texture2D ResizeTexture(Texture2D pSource, ImageFilterMode pFilterMode, float pScale)
{
//*** Variables
int i;
//*** Get All the source pixels
Color[] aSourceColor = pSource.GetPixels(0);
Vector2 vSourceSize = new Vector2(pSource.width, pSource.height);
//*** Calculate New Size
float xWidth = Mathf.RoundToInt((float)pSource.width * pScale);
float xHeight = Mathf.RoundToInt((float)pSource.height * pScale);
//*** Make New
Texture2D oNewTex = new Texture2D((int)xWidth, (int)xHeight, TextureFormat.RGBA32, false);
//*** Make destination array
int xLength = (int)xWidth * (int)xHeight;
Color[] aColor = new Color[xLength];
Vector2 vPixelSize = new Vector2(vSourceSize.x / xWidth, vSourceSize.y / xHeight);
//*** Loop through destination pixels and process
Vector2 vCenter = new Vector2();
for (i = 0; i < xLength; i++)
{
//*** Figure out x&y
float xX = (float)i % xWidth;
float xY = Mathf.Floor((float)i / xWidth);
//*** Calculate Center
vCenter.x = (xX / xWidth) * vSourceSize.x;
vCenter.y = (xY / xHeight) * vSourceSize.y;
//*** Do Based on mode
//*** Nearest neighbour (testing)
if (pFilterMode == ImageFilterMode.Nearest)
{
//*** Nearest neighbour (testing)
vCenter.x = Mathf.Round(vCenter.x);
vCenter.y = Mathf.Round(vCenter.y);
//*** Calculate source index
int xSourceIndex = (int)((vCenter.y * vSourceSize.x) + vCenter.x);
//*** Copy Pixel
aColor[i] = aSourceColor[xSourceIndex];
}
//*** Bilinear
else if (pFilterMode == ImageFilterMode.Biliner)
{
//*** Get Ratios
float xRatioX = vCenter.x - Mathf.Floor(vCenter.x);
float xRatioY = vCenter.y - Mathf.Floor(vCenter.y);
//*** Get Pixel index's
int xIndexTL = (int)((Mathf.Floor(vCenter.y) * vSourceSize.x) + Mathf.Floor(vCenter.x));
int xIndexTR = (int)((Mathf.Floor(vCenter.y) * vSourceSize.x) + Mathf.Ceil(vCenter.x));
int xIndexBL = (int)((Mathf.Ceil(vCenter.y) * vSourceSize.x) + Mathf.Floor(vCenter.x));
int xIndexBR = (int)((Mathf.Ceil(vCenter.y) * vSourceSize.x) + Mathf.Ceil(vCenter.x));
//*** Calculate Color
aColor[i] = Color.Lerp(
Color.Lerp(aSourceColor[xIndexTL], aSourceColor[xIndexTR], xRatioX),
Color.Lerp(aSourceColor[xIndexBL], aSourceColor[xIndexBR], xRatioX),
xRatioY
);
}
//*** Average
else if (pFilterMode == ImageFilterMode.Average)
{
//*** Calculate grid around point
int xXFrom = (int)Mathf.Max(Mathf.Floor(vCenter.x - (vPixelSize.x * 0.5f)), 0);
int xXTo = (int)Mathf.Min(Mathf.Ceil(vCenter.x + (vPixelSize.x * 0.5f)), vSourceSize.x);
int xYFrom = (int)Mathf.Max(Mathf.Floor(vCenter.y - (vPixelSize.y * 0.5f)), 0);
int xYTo = (int)Mathf.Min(Mathf.Ceil(vCenter.y + (vPixelSize.y * 0.5f)), vSourceSize.y);
//*** Loop and accumulate
Vector4 oColorTotal = new Vector4();
Color oColorTemp = new Color();
float xGridCount = 0;
for (int iy = xYFrom; iy < xYTo; iy++)
{
for (int ix = xXFrom; ix < xXTo; ix++)
{
//*** Get Color
oColorTemp += aSourceColor[(int)(((float)iy * vSourceSize.x) + ix)];
//*** Sum
xGridCount++;
}
}
//*** Average Color
aColor[i] = oColorTemp / (float)xGridCount;
}
}
//*** Set Pixels
oNewTex.SetPixels(aColor);
oNewTex.Apply();
//*** Return
return(oNewTex);
}
public static Texture2D ResizeTexture(Texture2D src, ImageFilterMode mode, int nw, int nh)
{
Color[] srcColors = src.GetPixels();
int srcWidth = src.width;
int srcHeight = src.height;
Texture2D newTex = new Texture2D(nw, nh, TextureFormat.RGBA32, false);
int length = nw * nh;
Color[] tgColors = new Color[length];
Vector2 pixelSize = new Vector2((float)srcWidth / nw, (float)srcHeight / nh);
Vector2 center = new Vector2();
for (int i = 0; i < length; i++)
{
float x = (float)i % nw;
float y = Mathf.Floor((float)i / nw);
center.x = (x / nw) * srcWidth;
center.y = (y / nh) * srcHeight;
// Nearest neighbour
if (mode == ImageFilterMode.Nearest)
{
center.x = Mathf.Round(center.x);
center.y = Mathf.Round(center.y);
int index = (int)((center.y * srcWidth) + center.x);
tgColors[i] = srcColors[index];
}
// Bilinear
else if (mode == ImageFilterMode.Bilinear)
{
// Get Ratios
float rx = center.x - Mathf.Floor(center.x);
float ry = center.y - Mathf.Floor(center.y);
// Get Pixel Index
int indexTL = (int)((Mathf.Floor(center.y) * srcWidth) + Mathf.Floor(center.x));
int indexTR = (int)((Mathf.Floor(center.y) * srcWidth) + Mathf.Ceil(center.x));
int indexBL = (int)((Mathf.Ceil(center.y) * srcWidth) + Mathf.Floor(center.x));
int indexBR = (int)((Mathf.Ceil(center.y) * srcWidth) + Mathf.Ceil(center.x));
tgColors[i] = Color.Lerp(
Color.Lerp(srcColors[indexTL], srcColors[indexTR], rx),
Color.Lerp(srcColors[indexBL], srcColors[indexBR], rx),
ry
);
}
else if (mode == ImageFilterMode.Average)
{
// Calculate grid around point
int xFrom = (int)Mathf.Max(Mathf.Floor(center.x - (pixelSize.x * 0.5f)), 0);
int xTo = (int)Mathf.Max(Mathf.Ceil(center.x - (pixelSize.x * 0.5f)), srcWidth);
int yFrom = (int)Mathf.Max(Mathf.Floor(center.y - (pixelSize.y * 0.5f)), 0);
int yTo = (int)Mathf.Max(Mathf.Ceil(center.y + (pixelSize.y * 0.5f)), srcHeight);
// Loop and Accumulate
Color cTemp = new Color();
float xGridCount = 0;
for (int iy = yFrom; iy < yTo; iy++)
{
for (int ix = xFrom; ix < xTo; ix++)
{
cTemp += srcColors[(int)(((float)iy * srcWidth) + ix)];
xGridCount++;
}
}
// Average Color
tgColors[i] = cTemp / (float)xGridCount;
}
}
newTex.SetPixels(tgColors);
newTex.Apply();
return(newTex);
}
private void Resize(Object[] aTextures, FolderConvention pFolderConvention)
{
//*** Variables
Texture2D oTexture;
string xAssetFolder = "Assets";
string xSpriteFolder = "Sprites";
string xFinalPath = "";
int i;
string[] aTK2D = new string[] { "@4x", "@2x", "@1x" };
string[] aFolders = new string[] { "Full", "Half", "Quater" };
float[] aSizes = new float[] { 1, 0.5f, 0.25f };
ImageFilterMode oMode = ImageFilterMode.Average;
//*** Get Base Path
string xBasePath = Application.dataPath;
xBasePath = xBasePath.Substring(0, xBasePath.Length - xAssetFolder.Length);
//*** Loop through selected textures
foreach (Object oObject in aTextures)
{
//*** Cast
oTexture = oObject as Texture2D;
//*** IF it is a valid texture
if (oTexture != null)
{
//*** Get Asset Path
string xAssetPath = AssetDatabase.GetAssetPath(oTexture);
string xPath = Path.GetDirectoryName(xAssetPath);
string xNewPath = xPath + Path.DirectorySeparatorChar + xSpriteFolder + Path.DirectorySeparatorChar;
//*** If TK2d
if (pFolderConvention == FolderConvention.TK2D)
{
//*** If Folder Does not exist
if (!System.IO.Directory.Exists(xBasePath + xNewPath))
{
//*** Make it
AssetDatabase.CreateFolder(xPath, xSpriteFolder);
//*** Refresh
AssetDatabase.Refresh();
}
}
//*** If Set Folders
else if (pFolderConvention == FolderConvention.FoldersPerSize)
{
//*** Loop through sizes
for (i = 0; i < aFolders.Length; i++)
{
//*** If Folder Does not exist
if (!System.IO.Directory.Exists(xBasePath + xPath + Path.DirectorySeparatorChar + aFolders[i] + Path.DirectorySeparatorChar))
{
//*** Make it
AssetDatabase.CreateFolder(xPath, aFolders[i]);
//*** Refresh
AssetDatabase.Refresh();
}
}
}
//*** Get Importer data
TextureImporter oTI = TextureImporter.GetAtPath(xAssetPath) as TextureImporter;
//*** If Not Readable, set
if (!oTI.isReadable)
{
oTI.isReadable = true;
//*** Apply Settings & Reload
AssetDatabase.ImportAsset(xAssetPath, ImportAssetOptions.ForceUpdate);
}
//*** Get All the source pixels
Color[] aSourceColor = oTexture.GetPixels(0);
Vector2 vSourceSize = new Vector2(oTexture.width, oTexture.height);
//*** Loop through sizes
for (i = 0; i < aFolders.Length; i++)
{
//*** Make New Paths
string xNewAssetPath = xNewPath + Path.GetFileName(xAssetPath);
//*** Strip Extra File Extention Data
if (stripExtraFileExtentions)
{
List <string> aNewAssetPath = new List <string>(xNewAssetPath.Split(new char[] { '.' }, System.StringSplitOptions.RemoveEmptyEntries));
//*** If Has an extention, remove last
if (aNewAssetPath.Count > 1)
{
aNewAssetPath.RemoveAt(aNewAssetPath.Count - 1);
}
//*** Make join back together
//xNewAssetPath = xNewPath + string.Join(".", aNewAssetPath.ToArray());
xNewAssetPath = string.Join(".", aNewAssetPath.ToArray());
}
//*** Calculate New Size
float xWidth = (int)Mathf.Round((float)oTexture.width * aSizes[i]);
float xHeight = (int)Mathf.Round((float)oTexture.height * aSizes[i]);
//*** Make New
Texture2D oNewTex = new Texture2D((int)xWidth, (int)xHeight, TextureFormat.RGBA32, false);
//*** Make destination array
int xLength = (int)xWidth * (int)xHeight;
Color[] aColor = new Color[xLength];
Vector2 vPixelSize = new Vector2(vSourceSize.x / xWidth, vSourceSize.y / xHeight);
//*** If Not a resize but a copy
if (aSizes[i] == 1)
{
//*** Just get pixels
aColor = aSourceColor;
}
//*** If Needs resizing
else
{
//*** Loop through destination pixels and process
int ii;
Vector2 vCenter = new Vector2();
for (ii = 0; ii < xLength; ii++)
{
//*** Figure out x&y
float xX = (float)ii % xWidth;
float xY = Mathf.Floor((float)ii / xWidth);
//*** Calculate Center
vCenter.x = (xX / xWidth) * vSourceSize.x;
vCenter.y = (xY / xHeight) * vSourceSize.y;
//*** Do Based on mode
//*** Nearest neighbour (testing)
if (oMode == ImageFilterMode.Nearest)
{
//*** Nearest neighbour (testing)
vCenter.x = Mathf.Round(vCenter.x);
vCenter.y = Mathf.Round(vCenter.y);
//*** Calculate source index
int xSourceIndex = (int)((vCenter.y * vSourceSize.x) + vCenter.x);
//*** Copy Pixel
aColor[ii] = aSourceColor[xSourceIndex];
}
//*** Bilinear
else if (oMode == ImageFilterMode.Biliner)
{
//*** Get Ratios
float xRatioX = vCenter.x - Mathf.Floor(vCenter.x);
float xRatioY = vCenter.y - Mathf.Floor(vCenter.y);
//*** Get Pixel index's
int xIndexTL = (int)((Mathf.Floor(vCenter.y) * vSourceSize.x) + Mathf.Floor(vCenter.x));
int xIndexTR = (int)((Mathf.Floor(vCenter.y) * vSourceSize.x) + Mathf.Ceil(vCenter.x));
int xIndexBL = (int)((Mathf.Ceil(vCenter.y) * vSourceSize.x) + Mathf.Floor(vCenter.x));
int xIndexBR = (int)((Mathf.Ceil(vCenter.y) * vSourceSize.x) + Mathf.Ceil(vCenter.x));
//*** Calculate Color
aColor[ii] = Color.Lerp(
Color.Lerp(aSourceColor[xIndexTL], aSourceColor[xIndexTR], xRatioX),
Color.Lerp(aSourceColor[xIndexBL], aSourceColor[xIndexBR], xRatioX),
xRatioY
);
}
//*** Average
else if (oMode == ImageFilterMode.Average)
{
//*** Calculate grid
int xXFrom = (int)Mathf.Max(Mathf.Floor(vCenter.x - (vPixelSize.x * 0.5f)), 0);
int xXTo = (int)Mathf.Min(Mathf.Ceil(vCenter.x + (vPixelSize.x * 0.5f)), vSourceSize.x);
int xYFrom = (int)Mathf.Max(Mathf.Floor(vCenter.y - (vPixelSize.y * 0.5f)), 0);
int xYTo = (int)Mathf.Min(Mathf.Ceil(vCenter.y + (vPixelSize.y * 0.5f)), vSourceSize.y);
//*** Loop and accumulate
Vector4 oColorTotal = new Vector4();
Color oColorTemp = new Color();
float xGridCount = 0;
for (int iy = xYFrom; iy < xYTo; iy++)
{
for (int ix = xXFrom; ix < xXTo; ix++)
{
//*** Get Color
oColorTemp += aSourceColor[(int)(((float)iy * vSourceSize.x) + ix)];
//*** Sum
xGridCount++;
}
}
//*** Average Color
aColor[ii] = oColorTemp / (float)xGridCount;
}
}
}
//*** Set Pixels
oNewTex.SetPixels(aColor);
oNewTex.Apply();
//*** if TK2D
if (pFolderConvention == FolderConvention.TK2D)
{
if (stripExtraFileExtentions)
{
xFinalPath = xBasePath + xNewAssetPath + aTK2D[i] + ".png";
}
else
{
xFinalPath = xBasePath + xNewAssetPath + "." + aTK2D[i] + ".png";
}
}
//*** If Sepearte Folders
else if (pFolderConvention == FolderConvention.FoldersPerSize)
{
xFinalPath = xBasePath + xPath + Path.DirectorySeparatorChar + aFolders[i] + Path.DirectorySeparatorChar + oTexture.name + ".png";
}
//*** Encode and save
byte[] aData = oNewTex.EncodeToPNG();
File.WriteAllBytes(xFinalPath, aData);
//*** Open New Asset
//*** Set Texture
}
}
}
//*** Refresh
AssetDatabase.Refresh();
}
/// <summary>
/// Creates an empty image.
/// </summary>
/// <param name="size">Image size.</param>
/// <param name="filter">Image filtering mode.</param>
/// <returns>Loaded image asset.</returns>
public ImageAsset CreateEmptyImage(PointI size, ImageFilterMode filter = ImageFilterMode.Nearest)
{
var ret = new ImageAsset(_BonEngineBind.BON_Assets_CreateEmptyImage(size.X, size.Y, (int)filter));
return(ret);
}
/// <summary>
/// Loads an image asset.
/// </summary>
/// <param name="filename">Image path.</param>
/// <param name="filter">Image filtering mode.</param>
/// <param name="useCache">Should we use cache for this asset to make future loadings faster?</param>
/// <returns>Loaded image asset.</returns>
public ImageAsset LoadImage(string filename, ImageFilterMode filter = ImageFilterMode.Nearest, bool useCache = true)
{
var ret = new ImageAsset(_BonEngineBind.BON_Assets_LoadImage(ToAssetsPath(filename, true), (int)filter, useCache));
return(ret);
}
//压缩图片
public static Texture2D ResizeTexture(Texture2D pSource, ImageFilterMode pFilterMode, Vector2 newSize)
{
int i;
Color[] aSourceColor = pSource.GetPixels(0);
Vector2 vSourceSize = new Vector2(pSource.width, pSource.height);
float xWidth = Mathf.RoundToInt(newSize.x);
float xHeight = Mathf.RoundToInt(newSize.y);
Texture2D oNewTex = new Texture2D((int)xWidth, (int)xHeight, TextureFormat.RGBA32, false);
int xLength = (int)xWidth * (int)xHeight;
Color[] aColor = new Color[xLength];
Vector2 vPixelSize = new Vector2(vSourceSize.x / xWidth, vSourceSize.y / xHeight);
Vector2 vCenter = new Vector2();
for (i = 0; i < xLength; i++)
{
float xX = (float)i % xWidth;
float xY = Mathf.Floor((float)i / xWidth);
vCenter.x = (xX / xWidth) * vSourceSize.x;
vCenter.y = (xY / xHeight) * vSourceSize.y;
if (pFilterMode == ImageFilterMode.Nearest)
{
vCenter.x = Mathf.Round(vCenter.x);
vCenter.y = Mathf.Round(vCenter.y);
int xSourceIndex = (int)((vCenter.y * vSourceSize.x) + vCenter.x);
aColor[i] = aSourceColor[xSourceIndex];
}
else if (pFilterMode == ImageFilterMode.Biliner)
{
float xRatioX = vCenter.x - Mathf.Floor(vCenter.x);
float xRatioY = vCenter.y - Mathf.Floor(vCenter.y);
int xIndexTL = (int)((Mathf.Floor(vCenter.y) * vSourceSize.x) + Mathf.Floor(vCenter.x));
int xIndexTR = (int)((Mathf.Floor(vCenter.y) * vSourceSize.x) + Mathf.Ceil(vCenter.x));
int xIndexBL = (int)((Mathf.Ceil(vCenter.y) * vSourceSize.x) + Mathf.Floor(vCenter.x));
int xIndexBR = (int)((Mathf.Ceil(vCenter.y) * vSourceSize.x) + Mathf.Ceil(vCenter.x));
aColor[i] = Color.Lerp(
Color.Lerp(aSourceColor[xIndexTL], aSourceColor[xIndexTR], xRatioX),
Color.Lerp(aSourceColor[xIndexBL], aSourceColor[xIndexBR], xRatioX),
xRatioY
);
}
else if (pFilterMode == ImageFilterMode.Average)
{
int xXFrom = (int)Mathf.Max(Mathf.Floor(vCenter.x - (vPixelSize.x * 0.5f)), 0);
int xXTo = (int)Mathf.Min(Mathf.Ceil(vCenter.x + (vPixelSize.x * 0.5f)), vSourceSize.x);
int xYFrom = (int)Mathf.Max(Mathf.Floor(vCenter.y - (vPixelSize.y * 0.5f)), 0);
int xYTo = (int)Mathf.Min(Mathf.Ceil(vCenter.y + (vPixelSize.y * 0.5f)), vSourceSize.y);
Vector4 oColorTotal = new Vector4();
Color oColorTemp = new Color();
float xGridCount = 0;
for (int iy = xYFrom; iy < xYTo; iy++)
{
for (int ix = xXFrom; ix < xXTo; ix++)
{
oColorTemp += aSourceColor[(int)(((float)iy * vSourceSize.x) + ix)];
xGridCount++;
}
}
aColor[i] = oColorTemp / (float)xGridCount;
}
}
oNewTex.SetPixels(aColor);
oNewTex.Apply();
return(oNewTex);
}
public Texture2D ResizeTexture(Texture2D originalTexture, ImageFilterMode filterMode, int newWidth, int newHeight)
{
//*** Get All the source pixels
Color[] sourceColor = originalTexture.GetPixels(0);
Vector2 sourceSize = new Vector2(originalTexture.width, originalTexture.height);
//*** Calculate New Size
float textureWidth = newWidth;
float textureHeight = newHeight;
//*** Make New
Texture2D newTexture = new Texture2D((int)textureWidth, (int)textureHeight, TextureFormat.RGBA32, false);
//*** Make destination array
Color[] aColor = new Color[(int)textureWidth * (int)textureHeight];
Vector2 pixelSize = new Vector2(sourceSize.x / textureWidth, sourceSize.y / textureHeight);
//*** Loop through destination pixels and process
Vector2 center = new Vector2();
for (int i = 0; i < aColor.Length; i++)
{
//*** Figure out x&y
float x = (float)i % textureWidth;
float y = Mathf.Floor((float)i / textureWidth);
//*** Calculate Center
center.x = (x / textureWidth) * sourceSize.x;
center.y = (y / textureHeight) * sourceSize.y;
//*** Do Based on mode
//*** Nearest neighbour (testing)
if (filterMode == ImageFilterMode.Nearest)
{
//*** Nearest neighbour (testing)
center.x = Mathf.Round(center.x);
center.y = Mathf.Round(center.y);
//*** Calculate source index
int sourceIndex = (int)((center.y * sourceSize.x) + center.x);
//*** Copy Pixel
aColor[i] = sourceColor[sourceIndex];
}
//*** Bilinear
else if (filterMode == ImageFilterMode.Bilinear)
{
//*** Get Ratios
float ratioX = center.x - Mathf.Floor(center.x);
float ratioY = center.y - Mathf.Floor(center.y);
//*** Get Pixel index's
int indexTL = (int)((Mathf.Floor(center.y) * sourceSize.x) + Mathf.Floor(center.x));
int indexTR = (int)((Mathf.Floor(center.y) * sourceSize.x) + Mathf.Ceil(center.x));
int indexBL = (int)((Mathf.Ceil(center.y) * sourceSize.x) + Mathf.Floor(center.x));
int indexBR = (int)((Mathf.Ceil(center.y) * sourceSize.x) + Mathf.Ceil(center.x));
//*** Calculate Color
aColor[i] = Color.Lerp(
Color.Lerp(sourceColor[indexTL], sourceColor[indexTR], ratioX),
Color.Lerp(sourceColor[indexBL], sourceColor[indexBR], ratioX),
ratioY
);
}
//*** Average
else if (filterMode == ImageFilterMode.Average)
{
//*** Calculate grid around point
int xFrom = (int)Mathf.Max(Mathf.Floor(center.x - (pixelSize.x * 0.5f)), 0);
int xTo = (int)Mathf.Min(Mathf.Ceil(center.x + (pixelSize.x * 0.5f)), sourceSize.x);
int yFrom = (int)Mathf.Max(Mathf.Floor(center.y - (pixelSize.y * 0.5f)), 0);
int yTo = (int)Mathf.Min(Mathf.Ceil(center.y + (pixelSize.y * 0.5f)), sourceSize.y);
//*** Loop and accumulate
Color tempColor = new Color();
float xGridCount = 0;
for (int iy = yFrom; iy < yTo; iy++)
{
for (int ix = xFrom; ix < xTo; ix++)
{
//*** Get Color
tempColor += sourceColor[(int)(((float)iy * sourceSize.x) + ix)];
//*** Sum
xGridCount++;
}
}
//*** Average Color
aColor[i] = tempColor / (float)xGridCount;
}
}
//*** Set Pixels
newTexture.SetPixels(aColor);
newTexture.Apply();
//*** Return
return(newTexture);
}
public static Texture2D ResizeTexture(Texture2D pSource, ImageFilterMode pFilterMode, float pScale)
{
//*** Variables
int i;
//*** Get All the source pixels
Color[] aSourceColor = pSource.GetPixels(0);
Vector2 vSourceSize = new Vector2(pSource.width, pSource.height);
//*** Calculate New Size
float xWidth = Mathf.RoundToInt((float)pSource.width * pScale);
float xHeight = Mathf.RoundToInt((float)pSource.height * pScale);
//*** Make New
Texture2D oNewTex = new Texture2D((int)xWidth, (int)xHeight, TextureFormat.RGBA32, false);
//*** Make destination array
int xLength = (int)xWidth * (int)xHeight;
Color[] aColor = new Color[xLength];
Vector2 vPixelSize = new Vector2(vSourceSize.x / xWidth, vSourceSize.y / xHeight);
//*** Loop through destination pixels and process
Vector2 vCenter = new Vector2();
for(i=0; i<xLength; i++){
//*** Figure out x&y
float xX = (float)i % xWidth;
float xY = Mathf.Floor((float)i / xWidth);
//*** Calculate Center
vCenter.x = (xX / xWidth) * vSourceSize.x;
vCenter.y = (xY / xHeight) * vSourceSize.y;
//*** Do Based on mode
//*** Nearest neighbour (testing)
if(pFilterMode == ImageFilterMode.Nearest){
//*** Nearest neighbour (testing)
vCenter.x = Mathf.Round(vCenter.x);
vCenter.y = Mathf.Round(vCenter.y);
//*** Calculate source index
int xSourceIndex = (int)((vCenter.y * vSourceSize.x) + vCenter.x);
//*** Copy Pixel
if(xSourceIndex<aSourceColor.Length)aColor[i] = aSourceColor[xSourceIndex];
}
//*** Bilinear
else if(pFilterMode == ImageFilterMode.Biliner){
//*** Get Ratios
float xRatioX = vCenter.x - Mathf.Floor(vCenter.x);
float xRatioY = vCenter.y - Mathf.Floor(vCenter.y);
//*** Get Pixel index's
int xIndexTL = (int)((Mathf.Floor(vCenter.y) * vSourceSize.x) + Mathf.Floor(vCenter.x));
int xIndexTR = (int)((Mathf.Floor(vCenter.y) * vSourceSize.x) + Mathf.Ceil(vCenter.x));
int xIndexBL = (int)((Mathf.Ceil(vCenter.y) * vSourceSize.x) + Mathf.Floor(vCenter.x));
int xIndexBR = (int)((Mathf.Ceil(vCenter.y) * vSourceSize.x) + Mathf.Ceil(vCenter.x));
//*** Calculate Color
aColor[i] = Color.Lerp(
Color.Lerp(aSourceColor[xIndexTL], aSourceColor[xIndexTR], xRatioX),
Color.Lerp(aSourceColor[xIndexBL], aSourceColor[xIndexBR], xRatioX),
xRatioY
);
}
//*** Average
else if(pFilterMode == ImageFilterMode.Average){
//*** Calculate grid around point
int xXFrom = (int)Mathf.Max(Mathf.Floor(vCenter.x - (vPixelSize.x * 0.5f)), 0);
int xXTo = (int)Mathf.Min(Mathf.Ceil(vCenter.x + (vPixelSize.x * 0.5f)), vSourceSize.x);
int xYFrom = (int)Mathf.Max(Mathf.Floor(vCenter.y - (vPixelSize.y * 0.5f)), 0);
int xYTo = (int)Mathf.Min(Mathf.Ceil(vCenter.y + (vPixelSize.y * 0.5f)), vSourceSize.y);
//*** Loop and accumulate
Vector4 oColorTotal = new Vector4();
Color oColorTemp = new Color();
float xGridCount = 0;
for(int iy = xYFrom; iy < xYTo; iy++){
for(int ix = xXFrom; ix < xXTo; ix++){
//*** Get Color
oColorTemp += aSourceColor[(int)(((float)iy * vSourceSize.x) + ix)];
//*** Sum
xGridCount++;
}
}
//*** Average Color
aColor[i] = oColorTemp / (float)xGridCount;
}
}
//*** Set Pixels
oNewTex.SetPixels(aColor);
oNewTex.Apply();
//*** Return
return oNewTex;
}
