private NoteManager(string storagePath, StorageMethod method)
{
StoragePath = storagePath;
StorageMethod = method;
Load();
}
public static NoteManager GetManager(string storagePath = "notes.json", StorageMethod method = StorageMethod.Json)
{
if (!Managers.ContainsKey(storagePath))
{
Managers.Add(storagePath, new NoteManager(storagePath, method));
}
return(Managers[storagePath]);
}
public (DataType t, object data) ReadData(StorageMethod storageSlot)
{
DataType t = DataType.None;
object data = null;
using (MemoryStream stream = new MemoryStream())
{
pngOriginal.WriteToStream(stream, true, true);
stream.Seek(0, SeekOrigin.Begin);
}
bool hasEOF = false;
int IDATs = 0;
foreach (PNGChunk chunk in pngOriginal.Chunks)
{
if (chunk.Name == "_EOF")
{
hasEOF = true;
}
if (chunk.Name == "IDAT")
{
IDATs++;
}
}
StegoProvider pr = Providers.XOREOF;
if (storageSlot == StorageMethod.IDAT)
{
pr = Providers.XORIDAT;
}
if (!hasEOF && storageSlot == StorageMethod.EOF)
{
provider = null; Logger.Log($"There is no data in {storageSlot.ToString()}", Logger.LOG_LEVEL.ERR);
}
else if (IDATs <= 1)
{
provider = null; Logger.Log($"There is no data in {storageSlot.ToString()}", Logger.LOG_LEVEL.ERR);
}
else
{
try
{
provider = (SteganographyProvider)Activator.CreateInstance(pr.ProviderType, pngOriginal, true);
provider.SetPassword(password);
t = provider.Extract(out data);
return(t, data);
}
catch (InvalidPasswordException)
{
Logger.Log("The password was incorrect.", Logger.LOG_LEVEL.ERR);
}
}
return(DataType.None, null);
}
/// <summary>
/// Initializes the Selected queried Persistent Storage Method
/// </summary>
/// <returns>A boolean of whether the operation completed successfully or failed</returns>
public bool Initialize()
{
if (StorageMethod == null)
{
return(false);
}
StorageMethod.Initialize();
return(true);
}
/// <summary>
/// Initializs the Selected Cached Persistent Storage Method
/// </summary>
/// <returns>A boolean of whether the operation completed successfully or failed</returns>
public bool Initialize()
{
if (StorageMethod == null)
{
return(false);
}
StorageMethod.Initialize();
((ICachedStorageMethod <T>)StorageMethod).UpdateCache();
CurrentCache = ((ICachedStorageMethod <T>)StorageMethod).GetCache();
return(true);
}
public ShaderSource GetShaderFloat4(List <IVoxelModifierEmissionOpacity> modifiers)
{
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(writer);
StorageMethod.Apply(mixin);
foreach (var attr in modifiers)
{
ShaderSource applier = attr.GetApplier("Isotropic");
if (applier != null)
{
mixin.AddCompositionToArray("Modifiers", applier);
}
}
return(mixin);
}
/// <summary>
/// Generic method used for reading save data
/// </summary>
/// <returns>Read data</returns>
/// <param name="method">Storing method</param>
/// <typeparam name="T">Typeof data to store</typeparam>
public static T LoadFromFIle <T>(StorageMethod method, string name)
{
T storedData = default(T);
string fileName = SavingLocation + name + "." + method.ToString().ToLower();
Debug.Log("File: " + fileName);
try
{
switch (method)
{
case StorageMethod.Binary:
using (Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
BinaryFormatter formatter = new BinaryFormatter();
storedData = (T)formatter.Deserialize(stream);
stream.Close();
stream.Dispose();
}
break;
case StorageMethod.XML:
using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
XmlSerializer serializer = new XmlSerializer(typeof(T));
storedData = (T)serializer.Deserialize(stream);
stream.Close();
stream.Dispose();
}
break;
case StorageMethod.JSON:
string serializedData = File.ReadAllText(fileName);
storedData = JsonUtility.FromJson <T>(serializedData);
break;
}
}
catch (System.Exception ex)
{
Debug.LogWarning("File reading error: " + ex.Message);
}
return(storedData);
}
/// <summary>
/// Saves the json.
/// </summary>
public static void SaveJson <T>(T data, string key, StorageMethod method = StorageMethod.JSON)
{
string json = JsonUtility.ToJson(data);
string[] pathArray = key.Split('/');
string path = GetFolderPath();
if (pathArray.Length > 1)
{
for (int i = 0; i < pathArray.Length - 1; i++)
{
path += "/" + pathArray[i];
}
SafeCreateDirectory(path);
}
string filePath = GetFilePath(key);
Debug.Log(filePath);
try
{
switch (method)
{
case StorageMethod.Binary:
BinaryFormatter bf = new BinaryFormatter();
FileStream file = File.Create(filePath);
bf.Serialize(file, json);
file.Close();
break;
case StorageMethod.JSON:
File.WriteAllText(filePath, json);
break;
}
}
catch (Exception ex)
{
Debug.LogWarning("エラー: " + ex.Message);
}
#if UNITY_EDITOR
AssetDatabase.Refresh();
#endif
}
/// <summary>
/// Generic method used for saving data
/// </summary>
/// <param name="dataToStore">Data to store</param>
/// <param name="method">Storing method</param>
/// <typeparam name="T">Typeof data to store</typeparam>
public static void SaveToFile <T>(T dataToStore, StorageMethod method, string name)
{
string fileName = SavingLocation + name + "." + method.ToString().ToLower();
Debug.Log("File: " + fileName);
try
{
switch (method)
{
case StorageMethod.Binary:
BinaryFormatter formatter = new BinaryFormatter();
using (FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write))
{
formatter.Serialize(stream, dataToStore);
stream.Close();
stream.Dispose();
}
break;
case StorageMethod.XML:
XmlSerializer serializer = new XmlSerializer(typeof(T));
using (FileStream stream = new FileStream(fileName, FileMode.Create, FileAccess.Write))
{
serializer.Serialize(stream, dataToStore);
stream.Close();
}
break;
case StorageMethod.JSON:
string serializedData = JsonUtility.ToJson(dataToStore, true);
Debug.Log(serializedData);
File.WriteAllText(fileName, serializedData);
break;
}
}
catch (System.Exception ex)
{
Debug.LogWarning("File writing error: " + ex.Message);
}
}
virtual public ShaderSource GetVoxelizationShader(List <VoxelModifierEmissionOpacity> modifiers)
{
var mixin = new ShaderMixinSource();
mixin.Mixins.Add(Writer);
StorageMethod.Apply(mixin);
foreach (var modifier in modifiers)
{
if (!modifier.Enabled)
{
continue;
}
ShaderSource applier = modifier.GetApplier(ApplierKey);
if (applier != null)
{
mixin.AddCompositionToArray("Modifiers", applier);
}
}
return(mixin);
}
public void PrepareLocalStorage(VoxelStorageContext context, IVoxelStorage storage)
{
StorageMethod.PrepareLocalStorage(context, storage, 4, 1);
Graphics.PixelFormat format = Graphics.PixelFormat.R16G16B16A16_Float;
switch (StorageFormat)
{
case StorageFormats.RGBA8:
format = Graphics.PixelFormat.R8G8B8A8_UNorm;
break;
case StorageFormats.R10G10B10A2:
format = Graphics.PixelFormat.R10G10B10A2_UNorm;
break;
case StorageFormats.RGBA16F:
format = Graphics.PixelFormat.R16G16B16A16_Float;
break;
}
storage.UpdateTexture(context, ref IsotropicTex, format, 1);
}
/// <summary>
/// Reads the json.
/// </summary>
static string ReadJson(string fileName, StorageMethod method)
{
string json = string.Empty;
string filePath = GetFilePath(fileName);
if (!Application.isEditor)
{
CreateDir();
}
// if (Application.platform == RuntimePlatform.IPhonePlayer) {
// // ファイルをコピー
// CopyFile(fileName);
// }
try
{
switch (method)
{
case StorageMethod.Binary:
BinaryFormatter bf = new BinaryFormatter();
using (FileStream file = File.Open(filePath, FileMode.Open))
{
json = (string)bf.Deserialize(file);
file.Close();
}
break;
case StorageMethod.JSON:
json = File.ReadAllText(filePath);
break;
}
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
}
return(json);
}
/// <summary>Gets a specified storage path</summary>
/// <param name="storageMethod">Method of storage</param>
/// <returns>Directory path based on storage method</returns>
public static string GetStorageFolder(StorageMethod storageMethod)
{
string path = string.Empty;
//// -- Sample --
//// Linux / Mac:
//// C:\Users\USERNAME\Documents\
//// path = Environment.GetFolderPath(System.Environment.SpecialFolder.Personal);
switch (storageMethod)
{
case StorageMethod.PortableApp:
path = System.IO.Directory.GetCurrentDirectory();
break;
case StorageMethod.AllUsers:
path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData);
path = System.IO.Path.Combine(path, "XI", "ToolsHub");
break;
case StorageMethod.SingleUser:
// We're using local over roaming because we don't want settings uploaded to server if user is on a domain.
path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.LocalApplicationData);
path = System.IO.Path.Combine(path, "XI", "ToolsHub");
break;
case StorageMethod.Unknown:
case StorageMethod.UnitTest:
default:
//// pth = System.IO.Path.GetDirectoryName(Application.ExecutablePath);
path = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "ToolsHubTests");
break;
}
return(path);
}
public bool HideFileSystem(string imagePath, string fileSystemData, string password = "", StorageMethod storageMethod = StorageMethod.EOF)
{
StegoProvider prov;
if (storageMethod == StorageMethod.EOF)
{
prov = Providers.XOREOF;
}
else
{
prov = Providers.XORIDAT;
}
provider = (SteganographyProvider)Activator.CreateInstance(prov.ProviderType, imagePath, false);
provider.SetPassword(password, false);
if (Imprint(DataType.FileSystem, fileSystemData))
{
using (FileStream fs = File.Open(imagePath, FileMode.Create, FileAccess.Write, FileShare.Read))
provider.WriteToStream(fs);
return(true);
}
return(false);
}
/// <summary>
/// Loads the data.
/// </summary>
/// <returns>The data.</returns>
/// <param name="fileName">File name.</param>
/// <typeparam name="T">The 1st type parameter.</typeparam>
private static T LoadData <T>(string fileName, StorageMethod method)
{
T data = JsonUtility.FromJson <T>(ReadJson(fileName, method));
return(data);
}
virtual public int PrepareLocalStorage(VoxelStorageContext context, IVoxelStorage storage)
{
return(StorageMethod.PrepareLocalStorage(context, storage, 4, LayoutCount));
}
public SaveManager(StorageMethod method)
{
_savingLocation = Application.persistentDataPath;
_method = method;
}
public SettingsManager(StorageMethod storageMethod)
{
StorageMethod = storageMethod;
}
public static T Load <T>(StorageMethod method = StorageMethod.JSON)
{
return(LoadData <T>(typeof(T).Name, method));
}
