720 lines
26 KiB
C#
720 lines
26 KiB
C#
// Created by SwanDEV 2017
|
|
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
#if UNITY_2017_3_OR_NEWER
|
|
using UnityEngine.Networking;
|
|
#endif
|
|
|
|
/// <summary> Files, Paths, Names and IO common methods. (Last update: 2021-03-19)..
|
|
/// *** Reminder! File IO methods do not work with streamingAssetsPath on Android.
|
|
/// </summary>
|
|
public class FilePathName
|
|
{
|
|
private static string _lastGeneratedFileNameWithoutExt_fff = "";
|
|
private static int _lastSameFileNameCounter_fff = 1;
|
|
|
|
private static string _lastGeneratedFileNameWithoutExt = "";
|
|
private static int _lastSameFileNameCounter = 1;
|
|
|
|
public enum SaveFormat
|
|
{
|
|
NONE = -1,
|
|
GIF = 0,
|
|
JPG = 1,
|
|
PNG = 2,
|
|
}
|
|
|
|
#region ----- Instance -----
|
|
private static FilePathName fpn = null;
|
|
public static FilePathName Instance
|
|
{
|
|
get
|
|
{
|
|
if (fpn == null) fpn = new FilePathName();
|
|
return fpn;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region ----- Path & FileName -----
|
|
public enum AppPath
|
|
{
|
|
/// <summary> The directory path where you can store data that you want to be kept between runs. </summary>
|
|
PersistentDataPath = 0,
|
|
|
|
/// <summary> The directory path where temporary data can be stored. </summary>
|
|
TemporaryCachePath,
|
|
|
|
/// <summary> The folder located at /Assets/StreamingAssets in the project. (Not work with System.IO methods when running on Android/WebGL) </summary>
|
|
StreamingAssetsPath,
|
|
|
|
/// <summary> The folder located at /Assets in the project. (Work on the Unity editor only) </summary>
|
|
DataPath
|
|
}
|
|
public string GetAppPath(AppPath appPath)
|
|
{
|
|
string directory = "";
|
|
switch (appPath)
|
|
{
|
|
case AppPath.PersistentDataPath:
|
|
directory = Application.persistentDataPath;
|
|
break;
|
|
case AppPath.TemporaryCachePath:
|
|
directory = Application.temporaryCachePath;
|
|
break;
|
|
case AppPath.StreamingAssetsPath:
|
|
directory = Application.streamingAssetsPath;
|
|
break;
|
|
case AppPath.DataPath:
|
|
directory = Application.dataPath;
|
|
break;
|
|
}
|
|
return directory;
|
|
}
|
|
public string GetSaveDirectory(bool isTemporaryPath = false, string subFolder = "", bool createDirectoryIfNotExist = false)
|
|
{
|
|
string result = "";
|
|
if (isTemporaryPath)
|
|
{
|
|
result = Application.temporaryCachePath;
|
|
}
|
|
else
|
|
{
|
|
//Available path: Application.persistentDataPath, Application.temporaryCachePath, Application.dataPath.
|
|
//Do not allow sub-folder when a GIF is being created, but you can move it to any accessible sub-folder after the GIF is completely saved.
|
|
//And/Or, you can filter the file names to include .gif only.
|
|
#if UNITY_EDITOR
|
|
result = Application.dataPath;
|
|
//result = Application.persistentDataPath;
|
|
#else
|
|
result = Application.persistentDataPath;
|
|
#endif
|
|
}
|
|
|
|
result = string.IsNullOrEmpty(subFolder) ? result : Path.Combine(result, subFolder);
|
|
|
|
if (createDirectoryIfNotExist && !Directory.Exists(result))
|
|
{
|
|
Directory.CreateDirectory(result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public string GetFileNameWithoutExt(bool millisecond = false)
|
|
{
|
|
if (millisecond)
|
|
{
|
|
return _GetComparedFileName(DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss-fff"),
|
|
_lastGeneratedFileNameWithoutExt_fff, _lastSameFileNameCounter_fff,
|
|
out _lastGeneratedFileNameWithoutExt_fff, out _lastSameFileNameCounter_fff);
|
|
}
|
|
return _GetComparedFileName(DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss"),
|
|
_lastGeneratedFileNameWithoutExt, _lastSameFileNameCounter,
|
|
out _lastGeneratedFileNameWithoutExt, out _lastSameFileNameCounter);
|
|
}
|
|
|
|
private string _GetComparedFileName(string newFileName, string lastGeneratedFileName, int sameFileNameCounter,
|
|
out string outLastGeneratedFileName, out int outSameFileNameCounter)
|
|
{
|
|
if (lastGeneratedFileName == newFileName)
|
|
{
|
|
sameFileNameCounter++;
|
|
}
|
|
else
|
|
{
|
|
sameFileNameCounter = 1;
|
|
}
|
|
|
|
outLastGeneratedFileName = newFileName;
|
|
outSameFileNameCounter = sameFileNameCounter;
|
|
|
|
if (sameFileNameCounter > 1)
|
|
{
|
|
newFileName += " " + sameFileNameCounter;
|
|
}
|
|
|
|
return newFileName;
|
|
}
|
|
|
|
public string GenerateFileNameWithDateTimeParameters(int YYYY, int MM, int DD, int hh = 0, int mm = 0, int ss = 0, int fff = -1)
|
|
{
|
|
DateTime dateTime = new DateTime(Mathf.Clamp(YYYY, 1, 9999), Mathf.Clamp(MM, 1, 12), Mathf.Clamp(DD, 1, 31), Mathf.Clamp(hh, 0, 23), Mathf.Clamp(mm, 0, 59), Mathf.Clamp(ss, 0, 59), Mathf.Clamp(fff, 0, 999));
|
|
return dateTime.ToString("yyyy-MM-dd-HH-mm-ss" + (fff < 0 ? "" : "-fff"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare the filename (generated by FilePathName class) with the provided DateTime. Return -1, 0, 1. (-1: fileName time is earlier; 0: equals; 1 fileName time is later)
|
|
/// </summary>
|
|
/// <param name="fileName_FPN"> FileName generated by FilePathName class (e.g: Photo_2019-08-31-00-00-00-000.jpg/.png) </param>
|
|
/// <param name="dateTime"> The DateTime to be compared with the time formated file name string. </param>
|
|
public int CompareFileNameWithTime(string fileName_FPN, DateTime dateTime)
|
|
{
|
|
string[] texts1 = fileName_FPN.Split('_');
|
|
string[] texts2 = texts1[1].Split('-');
|
|
|
|
int YYYY = 0;
|
|
int.TryParse(texts2[0], out YYYY);
|
|
int MM = 0;
|
|
int.TryParse(texts2[1], out MM);
|
|
int DD = 0;
|
|
int.TryParse(texts2[2], out DD);
|
|
int hh = 0;
|
|
int.TryParse(texts2[3], out hh);
|
|
int mm = 0;
|
|
int.TryParse(texts2[4], out mm);
|
|
int ss = 0;
|
|
int.TryParse(texts2[5], out ss);
|
|
int fff = -1;
|
|
if (texts2.Length > 6) int.TryParse(texts2[6].Substring(0, 3), out fff);
|
|
|
|
DateTime dt = fff == -1 ? new DateTime(YYYY, MM, DD, hh, mm, ss) : new DateTime(YYYY, MM, DD, hh, mm, ss, fff);
|
|
if (dt == dateTime) return 0;
|
|
else if (dt > dateTime) return 1;
|
|
else return -1;
|
|
}
|
|
/// <summary>
|
|
/// Check if the filename (generated by FilePathName class) within the Start and End DateTime interval.
|
|
/// </summary>
|
|
/// <param name="fileName_FPN"> FileName generated by FilePathName class (e.g: Photo_2019-08-31-00-00-00-000.jpg/.png) </param>
|
|
/// <param name="startDateTime">Start date time.</param>
|
|
/// <param name="endDateTime">End date time.</param>
|
|
public bool CheckFileNameWithinDateTimeInterval(string fileName_FPN, DateTime startDateTime, DateTime endDateTime)
|
|
{
|
|
return CompareFileNameWithTime(fileName_FPN, startDateTime) >= 0 && CompareFileNameWithTime(fileName_FPN, endDateTime) <= 0;
|
|
}
|
|
|
|
public string EnsureValidPath(string pathOrUrl)
|
|
{
|
|
string path = pathOrUrl;
|
|
if (path.StartsWith("http", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
// WEB
|
|
}
|
|
else if (path.StartsWith("/idbfs/", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
// WebGL index DB
|
|
}
|
|
else
|
|
{
|
|
// Local path
|
|
path = EnsureLocalPath(path);
|
|
}
|
|
return path;
|
|
}
|
|
|
|
public string EnsureLocalPath(string path)
|
|
{
|
|
if (path.StartsWith("jar:", StringComparison.OrdinalIgnoreCase)) // Android streamingAssetsPath
|
|
{ }
|
|
else if (!path.StartsWith("file:///", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
while (path.StartsWith("/", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
path = path.Remove(0, 1);
|
|
}
|
|
path = "file:///" + path;
|
|
}
|
|
return path;
|
|
}
|
|
|
|
public string EnsureValidFileName(string fileName)
|
|
{
|
|
string replaceChars = "[:\\\\/*\"?|<>']";
|
|
for (int i = 0; i < replaceChars.Length; i++)
|
|
{
|
|
if (fileName.Contains(replaceChars[i].ToString()))
|
|
{
|
|
fileName = fileName.Replace(replaceChars[i], '_');
|
|
}
|
|
}
|
|
return fileName;
|
|
}
|
|
|
|
public string GetGifFileName()
|
|
{
|
|
string timestamp = GetFileNameWithoutExt();
|
|
return "GIF_" + timestamp;
|
|
}
|
|
public string GetGifFullPath(string subFolder = "", bool createDirectoryIfNotExist = false)
|
|
{
|
|
return GetSaveDirectory(false, subFolder, createDirectoryIfNotExist) + "/" + GetGifFileName() + ".gif";
|
|
}
|
|
public string GetDownloadedGifSaveFullPath(string subFolder = "", bool createDirectoryIfNotExist = false)
|
|
{
|
|
return GetSaveDirectory(false, subFolder, createDirectoryIfNotExist) + "/" + GetGifFileName() + ".gif";
|
|
}
|
|
|
|
public string GetJpgFileName()
|
|
{
|
|
string timestamp = GetFileNameWithoutExt(true);
|
|
return "Photo_" + timestamp;
|
|
}
|
|
public string GetJpgFullPath(string subFolder = "", bool createDirectoryIfNotExist = false)
|
|
{
|
|
return GetSaveDirectory(false, subFolder, createDirectoryIfNotExist) + "/" + GetJpgFileName() + ".jpg";
|
|
}
|
|
|
|
public string GetPngFileName()
|
|
{
|
|
string timestamp = GetFileNameWithoutExt(true);
|
|
return "Photo_" + timestamp;
|
|
}
|
|
public string GetPngFullPath(string subFolder = "", bool createDirectoryIfNotExist = false)
|
|
{
|
|
return GetSaveDirectory(false, subFolder, createDirectoryIfNotExist) + "/" + GetPngFileName() + ".png";
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ----- IO -----
|
|
public byte[] ReadFileToBytes(string fromFullPath)
|
|
{
|
|
if (!File.Exists(fromFullPath))
|
|
{
|
|
#if UNITY_EDITOR
|
|
Debug.LogWarning("File Not Found: " + fromFullPath);
|
|
#endif
|
|
return null;
|
|
}
|
|
return File.ReadAllBytes(fromFullPath);
|
|
}
|
|
|
|
public void WriteBytesToFile(string toFullPath, byte[] byteArray)
|
|
{
|
|
CheckToCreateDirectory(Path.GetDirectoryName(toFullPath));
|
|
File.WriteAllBytes(toFullPath, byteArray);
|
|
}
|
|
|
|
public void CopyFile(string fromFullPath, string toFullPath, bool overwrite = false)
|
|
{
|
|
if (!File.Exists(fromFullPath))
|
|
{
|
|
#if UNITY_EDITOR
|
|
Debug.LogWarning("File Not Found: " + fromFullPath);
|
|
#endif
|
|
return;
|
|
}
|
|
CheckToCreateDirectory(Path.GetDirectoryName(toFullPath));
|
|
File.Copy(fromFullPath, toFullPath, overwrite);
|
|
}
|
|
|
|
public void MoveFile(string fromFullPath, string toFullPath, bool replaceIfExist = false)
|
|
{
|
|
if (!File.Exists(fromFullPath))
|
|
{
|
|
#if UNITY_EDITOR
|
|
Debug.LogWarning("File Not Found: " + fromFullPath);
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
if (replaceIfExist && File.Exists(toFullPath)) File.Delete(toFullPath);
|
|
CheckToCreateDirectory(Path.GetDirectoryName(toFullPath));
|
|
File.Move(fromFullPath, toFullPath);
|
|
}
|
|
|
|
public void DeleteFile(string fileFullPath)
|
|
{
|
|
if (!File.Exists(fileFullPath))
|
|
{
|
|
#if UNITY_EDITOR
|
|
Debug.LogWarning("File Not Found: " + fileFullPath);
|
|
#endif
|
|
return;
|
|
}
|
|
File.Delete(fileFullPath);
|
|
}
|
|
|
|
public void CheckToCreateDirectory(string directory)
|
|
{
|
|
if (!Directory.Exists(directory))
|
|
Directory.CreateDirectory(directory);
|
|
}
|
|
|
|
/// <summary> Determine whether a given path is a directory. </summary>
|
|
public bool PathIsDirectory(string path)
|
|
{
|
|
FileAttributes attr = File.GetAttributes(path);
|
|
if ((attr & FileAttributes.Directory) == FileAttributes.Directory) return true; else return false;
|
|
}
|
|
|
|
public void RenameFile(string originFilePath, string newFileName)
|
|
{
|
|
string directory = Path.GetDirectoryName(originFilePath);
|
|
string newFilePath = Path.Combine(directory, newFileName);
|
|
CopyFile(originFilePath, newFilePath, true);
|
|
}
|
|
|
|
public bool FileStreamTo(string fileFullpath, byte[] byteArray)
|
|
{
|
|
try
|
|
{
|
|
CheckToCreateDirectory(Path.GetDirectoryName(fileFullpath));
|
|
using (FileStream fs = new FileStream(fileFullpath, FileMode.Create, FileAccess.Write))
|
|
{
|
|
fs.Write(byteArray, 0, byteArray.Length);
|
|
return true; // success
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine("Exception caught in process: {0}", e);
|
|
return false; // fail
|
|
}
|
|
}
|
|
|
|
public void WriteBytesToText(byte[] bytes, string toFileFullPath, string separator = "", bool toChar = true)
|
|
{
|
|
// int bkCount = 0;
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
if (string.IsNullOrEmpty(separator))
|
|
{
|
|
if (toChar)
|
|
{
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
{
|
|
sb.Append((char)bytes[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
{
|
|
sb.Append(bytes[i]);
|
|
|
|
//Test
|
|
// bkCount++;
|
|
// if(bkCount == 3)
|
|
// {
|
|
// bkCount = 0;
|
|
// sb.Append(" (" + (i+1)/3 + ")\n");
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (toChar)
|
|
{
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
{
|
|
sb.Append((char)bytes[i]);
|
|
sb.Append(separator);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
{
|
|
sb.Append(bytes[i]);
|
|
sb.Append(separator);
|
|
|
|
//Test
|
|
// bkCount++;
|
|
// if(bkCount == 3)
|
|
// {
|
|
// bkCount = 0;
|
|
// sb.Append(" (" + ((i+1)/3-1) + ")\n");
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
CheckToCreateDirectory(Path.GetDirectoryName(toFileFullPath));
|
|
File.WriteAllText(toFileFullPath, sb.ToString());
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Saves texture as JPG/PNG on Windows/Mac.
|
|
/// </summary>
|
|
public string SaveImage(Texture2D texture, string subFolder, string fileName, SaveFormat imageFormat, Environment.SpecialFolder specialFolder = Environment.SpecialFolder.MyPictures, int jpgQuality = 90)
|
|
{
|
|
string extensionName = "." + imageFormat.ToString().ToLower();
|
|
byte[] bytes = null;
|
|
string gifPath = "";
|
|
switch (imageFormat)
|
|
{
|
|
case SaveFormat.JPG:
|
|
bytes = texture.EncodeToJPG(jpgQuality);
|
|
break;
|
|
case SaveFormat.PNG:
|
|
bytes = texture.EncodeToPNG();
|
|
break;
|
|
case SaveFormat.GIF:
|
|
#if PRO_GIF
|
|
gifPath = SaveBytes(new byte[] { 0 }, subFolder, fileName + extensionName, specialFolder);
|
|
ProGifTexturesToGIF tex2Gif = ProGifTexturesToGIF.Instance;
|
|
tex2Gif.Save(new List<Texture2D> { texture }, texture.width, texture.height, 1, -1, 10, (id, path) =>
|
|
{
|
|
Debug.Log("Save GIF.." + path + "\n" + gifPath);
|
|
CopyFile(path, gifPath, true);
|
|
DeleteFile(path);
|
|
}, null, ProGifTexturesToGIF.ResolutionHandle.ResizeKeepRatio, false);
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
if(!string.IsNullOrEmpty(gifPath))
|
|
{
|
|
return gifPath;
|
|
}
|
|
return SaveBytes(bytes, subFolder, fileName + extensionName, specialFolder);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Saves file byte array on Windows/Mac.
|
|
/// </summary>
|
|
public string SaveBytes(byte[] bytes, string subFolder, string fileNameWithExtension, Environment.SpecialFolder specialFolder = Environment.SpecialFolder.MyPictures)
|
|
{
|
|
string directory = Path.Combine(Environment.GetFolderPath(specialFolder), subFolder);
|
|
string savePath = Path.Combine(directory, fileNameWithExtension);
|
|
WriteBytesToFile(savePath, bytes);
|
|
return savePath;
|
|
}
|
|
|
|
public string SaveTextureAs(Texture2D texture2D, SaveFormat format = SaveFormat.JPG)
|
|
{
|
|
string savePath = string.Empty;
|
|
switch (format)
|
|
{
|
|
case SaveFormat.JPG:
|
|
savePath = GetJpgFullPath();
|
|
WriteBytesToFile(savePath, texture2D.EncodeToJPG(90));
|
|
break;
|
|
case SaveFormat.PNG:
|
|
savePath = GetPngFullPath();
|
|
WriteBytesToFile(savePath, texture2D.EncodeToPNG());
|
|
break;
|
|
case SaveFormat.GIF:
|
|
#if PRO_GIF
|
|
savePath = ProGifTexturesToGIF.Instance.Save(new List<Texture2D> { texture2D }, texture2D.width, texture2D.height, 1, -1, 10, null, null, ProGifTexturesToGIF.ResolutionHandle.ResizeKeepRatio, false);
|
|
#endif
|
|
break;
|
|
}
|
|
return savePath;
|
|
}
|
|
|
|
public string SaveTextureAs(Texture2D texture2D, AppPath appPath, string subFolder, bool isJPG, string optionalFileName_WithoutExtension = "")
|
|
{
|
|
string savePath = GetAppPath(appPath);
|
|
if (!string.IsNullOrEmpty(subFolder)) savePath = Path.Combine(savePath, subFolder);
|
|
if (!Directory.Exists(savePath)) Directory.CreateDirectory(savePath);
|
|
savePath = Path.Combine(savePath, (string.IsNullOrEmpty(optionalFileName_WithoutExtension) ? GetFileNameWithoutExt(true) : optionalFileName_WithoutExtension) + (isJPG ? ".jpg" : ".png"));
|
|
WriteBytesToFile(savePath, (isJPG ? texture2D.EncodeToJPG(90) : texture2D.EncodeToPNG()));
|
|
return savePath;
|
|
}
|
|
|
|
#if PRO_GIF
|
|
public string SaveTexturesAsGIF(List<Texture2D> textureList, int width, int height, int fps, int loop, int quality,
|
|
Action<int, string> onFileSaved = null, Action<int, float> onFileSaveProgress = null,
|
|
ProGifTexturesToGIF.ResolutionHandle resolutionHandle = ProGifTexturesToGIF.ResolutionHandle.ResizeKeepRatio)
|
|
{
|
|
return ProGifTexturesToGIF.Instance.Save(textureList, width, height, fps, loop, quality, onFileSaved, onFileSaveProgress, resolutionHandle, false);
|
|
}
|
|
#endif
|
|
|
|
public Texture2D LoadImage(string fullFilePath)
|
|
{
|
|
if (!File.Exists(fullFilePath))
|
|
{
|
|
#if UNITY_EDITOR
|
|
Debug.LogWarning("File not exist! " + fullFilePath);
|
|
#endif
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
Texture2D tex2D = new Texture2D(1, 1); //, TextureFormat.ARGB32, false);
|
|
tex2D.LoadImage(ReadFileToBytes(fullFilePath));
|
|
return tex2D;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load images in the target directory, to a texture2D list.
|
|
/// </summary>
|
|
/// <returns>The images.</returns>
|
|
/// <param name="directory">Directory.</param>
|
|
/// <param name="fileExtensions">A list of file extension names, indicating the type of files to be loaded. Load jpg, png and gif if Null or Empty.</param>
|
|
public List<Texture2D> LoadImages(string directory, List<string> fileExtensions = null)
|
|
{
|
|
if (fileExtensions != null && fileExtensions.Count > 0) { }
|
|
else
|
|
{
|
|
fileExtensions = new List<string> { ".jpg", ".png", ".gif" };
|
|
}
|
|
|
|
List<Texture2D> textureList = new List<Texture2D>();
|
|
|
|
foreach (string f in GetFilePaths(directory, fileExtensions))
|
|
{
|
|
if (fileExtensions.Contains(Path.GetExtension(f).ToLower()))
|
|
{
|
|
textureList.Add(LoadImage(f));
|
|
}
|
|
}
|
|
return textureList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load files in the target directory, to a byte[] list.
|
|
/// </summary>
|
|
/// <returns>Files in byte[].</returns>
|
|
/// <param name="directory">Directory.</param>
|
|
/// <param name="fileExtensions">A list of file extension names, indicating the type of files to be loaded. Load all files if Null or Empty.</param>
|
|
public List<byte[]> LoadFiles(string directory, List<string> fileExtensions = null)
|
|
{
|
|
List<byte[]> fileByteList = new List<byte[]>();
|
|
|
|
foreach (string f in GetFilePaths(directory, fileExtensions))
|
|
{
|
|
fileByteList.Add(ReadFileToBytes(f));
|
|
}
|
|
return fileByteList;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get file paths in the target directory.
|
|
/// </summary>
|
|
/// <returns>File paths list.</returns>
|
|
/// <param name="directory">Directory.</param>
|
|
/// <param name="fileExtensions">A list of file extension names, indicating the type of file paths to get. Get all file paths if Null or Empty.</param>
|
|
public List<string> GetFilePaths(string directory, List<string> fileExtensions = null)
|
|
{
|
|
if (!Directory.Exists(directory))
|
|
{
|
|
#if UNITY_EDITOR
|
|
Debug.Log("Directory Not Found: " + directory);
|
|
#endif
|
|
return null;
|
|
}
|
|
|
|
string[] allFiles_src = Directory.GetFiles(directory);
|
|
|
|
bool loadAllFile = (fileExtensions == null) ? true : ((fileExtensions.Count <= 0) ? true : false);
|
|
if (loadAllFile)
|
|
{
|
|
#if UNITY_EDITOR
|
|
Debug.Log("Load ALL");
|
|
#endif
|
|
List<string> fileList = new List<string>();
|
|
int len = allFiles_src.Length;
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
fileList.Add(allFiles_src[i]);
|
|
}
|
|
return fileList;
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
Debug.Log("Load Filtered");
|
|
#endif
|
|
|
|
if (fileExtensions == null)
|
|
{
|
|
fileExtensions = new List<string>();
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < fileExtensions.Count; i++)
|
|
{
|
|
fileExtensions[i] = fileExtensions[i].ToLower();
|
|
}
|
|
}
|
|
|
|
List<string> filteredFilePathList = new List<string>();
|
|
foreach (string f in allFiles_src)
|
|
{
|
|
if (fileExtensions.Contains(Path.GetExtension(f).ToLower()))
|
|
{
|
|
filteredFilePathList.Add(f);
|
|
}
|
|
}
|
|
return filteredFilePathList;
|
|
}
|
|
|
|
#if UNITY_2017_3_OR_NEWER
|
|
/// <summary>
|
|
/// Loads file using UnityWebRequest. Return the byte array of the file in onLoadCompleted callback.
|
|
/// ( IEnumerator: Remember to call this method in StartCoroutine )
|
|
/// </summary>
|
|
/// <returns>The file byte array.</returns>
|
|
/// <param name="url">Local file path or http/https link.</param>
|
|
/// <param name="onLoadCompleted">On load completed callback. Return the byte array of the downloaded file.</param>
|
|
/// <param name="onLoadCompletedUWR">On load completed callback. Return the UnityWebRequest object.</param>
|
|
public IEnumerator LoadFileUWR(string url, Action<byte[]> onLoadCompleted = null, Action<UnityWebRequest> onLoadCompletedUWR = null)
|
|
{
|
|
string path = EnsureValidPath(url);
|
|
using (UnityWebRequest uwr = UnityWebRequest.Get(path))
|
|
{
|
|
uwr.SendWebRequest();
|
|
while (!uwr.isDone)
|
|
{
|
|
yield return null;
|
|
}
|
|
|
|
#if UNITY_2020_1_OR_NEWER
|
|
if (uwr.result == UnityWebRequest.Result.ConnectionError || uwr.result == UnityWebRequest.Result.ProtocolError || uwr.result == UnityWebRequest.Result.DataProcessingError)
|
|
#else
|
|
if (uwr.isNetworkError || uwr.isHttpError)
|
|
#endif
|
|
{
|
|
if (onLoadCompleted != null) onLoadCompleted(null);
|
|
if (onLoadCompletedUWR != null) onLoadCompletedUWR(null);
|
|
Debug.LogError("File load error.\n" + uwr.error);
|
|
}
|
|
else
|
|
{
|
|
if (onLoadCompleted != null) onLoadCompleted(uwr.downloadHandler.data);
|
|
if (onLoadCompletedUWR != null) onLoadCompletedUWR(uwr);
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
/// <summary>
|
|
/// Loads file using WWW. Return the byte array of the file in onLoadCompleted callback.
|
|
/// ( IEnumerator: Remember to call this method in StartCoroutine )
|
|
/// </summary>
|
|
/// <returns>The file byte array.</returns>
|
|
/// <param name="url">Local file path or http/https link.</param>
|
|
/// <param name="onLoadCompleted">On load completed callback. Return the byte array of the downloaded file.</param>
|
|
/// <param name="onLoadCompletedWWW">On load completed callback. Return the WWW object.</param>
|
|
public IEnumerator LoadFileWWW(string url, Action<byte[]> onLoadCompleted = null, Action<WWW> onLoadCompletedWWW = null)
|
|
{
|
|
string path = EnsureValidPath(url);
|
|
using (WWW www = new WWW(path))
|
|
{
|
|
yield return www;
|
|
if (string.IsNullOrEmpty(www.error) == false)
|
|
{
|
|
if (onLoadCompleted != null) onLoadCompleted(null);
|
|
if (onLoadCompletedWWW != null) onLoadCompletedWWW(null);
|
|
Debug.LogError("File load error.\n" + www.error);
|
|
yield break;
|
|
}
|
|
if (onLoadCompleted != null) onLoadCompleted(www.bytes);
|
|
if (onLoadCompletedWWW != null) onLoadCompletedWWW(www);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#endregion
|
|
|
|
public Sprite Texture2DToSprite(Texture2D texture2D)
|
|
{
|
|
if (texture2D == null) return null;
|
|
|
|
Vector2 pivot = new Vector2(0.5f, 0.5f);
|
|
float pixelPerUnit = 100;
|
|
return Sprite.Create(texture2D, new Rect(0, 0, texture2D.width, texture2D.height), pivot, pixelPerUnit);
|
|
}
|
|
|
|
}
|