public void ByteIsNotValid()
{
var model = new ByteModel()
{
Value = default(byte)
};
Assert.Throws <AggregateValidationException>(() => ExtendedValidator.EnsureIsValid(model));
}
public void ByteIsValid()
{
var model = new ByteModel()
{
Value = byte.MaxValue
};
ExtendedValidator.EnsureIsValid(model);
}
/// <summary>
/// Stores a serializible model into the datacache
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="model"></param>
internal void StoreOne(ModelBase model, bool isByteModel = false, ByteModel byteModel = null)
{
CheckDatacache();
// If its a normal ModelBase storing.
if (!isByteModel)
{
var ds = new DataContractSerializer(model.GetType());
var settings = new XmlWriterSettings {
Indent = true
};
var currentSaveLocation = Path.Combine(_databasePath, TermHelper.GetDatabaseTerm(), model.GetType().Name);
// Always check if a directory exists. If not, create it.
IOPathHelper.CreateDirectory(currentSaveLocation);
using (var sww = new StringWriter())
{
using (var w = XmlWriter.Create(Path.Combine(currentSaveLocation, $"{model.Id}.xml"), settings))
{
ds.WriteObject(w, model);
}
}
}
else if (isByteModel) // If it's a byteModel
{
var currentSaveLocation = Path.Combine(_databasePath, TermHelper.GetDatabaseTerm(), byteModel.GetType().Name);
// It's important to write the bytes decrypted since MemProtection works with the localUser. So the data would be bound to this pc and user.
var decryptedValue = CryptMemoryProtection.DecryptInMemoryData(byteModel.EncryptedValue);
// Always check if a directory exists. If not, create it.
IOPathHelper.CreateDirectory(currentSaveLocation);
// Write the Value of byteModels into a file with the foreignKey as the name.
File.WriteAllBytes($"{currentSaveLocation}\\{byteModel.ForeignKey}", decryptedValue);
decryptedValue = null;
}
}
/// <summary>
/// Creates a new <see cref="Fortress"/> with a <see cref="MasterKey"/> and saves it encrypted.
/// </summary>
internal void WriteFortress(Fortress fortress, bool overwrite = false)
{
try
{
Logger.log.Info("Starting to write a fortress...");
var databasePath = Path.Combine(fortress.FullPath, TermHelper.GetDatabaseTerm());
// =========================================================== Create the root directory
IOPathHelper.CreateDirectory(fortress.FullPath);
Logger.log.Debug($"Created outer walls {fortress.FullPath}.");
// =========================================================== Create the sub directories for the database
IOPathHelper.CreateDirectory(databasePath);
Logger.log.Debug($"Created the {TermHelper.GetDatabaseTerm()}");
// =========================================================== Create the file which holds the salt to unlock the database
StoreSalt(fortress.FullPath, fortress.Salt);
Logger.log.Debug("Stored salt");
// =========================================================== Store the user Input and initial data in the database
foreach (var modelList in _unsecureDatacache.Values) // UnsecureDatacache
{
foreach (var model in modelList)
{
StoreOne(model);
}
}
foreach (var pair in _secureDatacache)
{
// We filter: Only if the sensible data has a parent we want to save it. Otherwise the parent has been deleted,
// which makes the sensible counterpart useless.
if (_unsecureDatacache.Values.Any(l => l.Any(m => m.Id == pair.Key)))
{
var byteModel = new ByteModel(pair.Key, pair.Value);
StoreOne(null, true, byteModel);
}
}
Logger.log.Debug("Stored fortress information.");
// =========================================================== Zip only the database
ZipHelper.ZipSavedArchives(databasePath, $"{databasePath}{TermHelper.GetZippedFileEnding()}");
Directory.Delete(databasePath, true);
Logger.log.Debug($"{TermHelper.GetDatabaseTerm()} has been zipped.");
// =========================================================== Encrypt the database
var aesAlg = new AesAlgorithm();
// Read all bytes from the database directory
var data = File.ReadAllBytes($"{databasePath}{TermHelper.GetZippedFileEnding()}");
// Encrypt it
var encryptedData = aesAlg.Encrypt(data, fortress.MasterKey.Value, fortress.Salt);
// Write the encrypted file
File.WriteAllBytes($"{databasePath}{TermHelper.GetDatabaseEnding()}", encryptedData);
// Delete the zip
File.Delete($"{databasePath}{TermHelper.GetZippedFileEnding()}");
Logger.log.Debug($"Encrypted {TermHelper.GetDatabaseTerm()}");
// =========================================================== Zip the whole fortress
if (overwrite)
{
File.Delete($"{fortress.FullPath}{TermHelper.GetZippedFileEnding()}");
}
ZipHelper.ZipSavedArchives(fortress.FullPath, $"{fortress.FullPath}{TermHelper.GetZippedFileEnding()}");
Directory.Delete(fortress.FullPath, true);
Logger.log.Debug("Fortress has been zipped.");
Logger.log.Info("Fortress has been sucessfully written!");
}
catch (Exception ex)
{
// Delete all changes that have been made to this point. We do not want half-built fortresses.
if (Directory.Exists(fortress.FullPath))
{
Directory.Delete(fortress.FullPath, true);
}
if (File.Exists(Path.Combine(fortress.FullPath, TermHelper.GetZippedFileEnding())))
{
File.Delete(fortress.FullPath + TermHelper.GetZippedFileEnding());
}
ex.SetUserMessage(WellKnownExceptionMessages.DataExceptionMessage());
throw ex;
}
}
public void ByteIsValid()
{
var model = new ByteModel() { Value = byte.MaxValue };
ExtendedValidator.EnsureIsValid(model);
}
public void ByteIsNotValid()
{
var model = new ByteModel() { Value = default(byte) };
Assert.Throws<AggregateValidationException>(() => ExtendedValidator.EnsureIsValid(model));
}
public void LoadScene(string path)
{
Console.WriteLine("Loading Scene");
var root = Path.GetDirectoryName(path);
var json = (JObject)JsonConvert.DeserializeObject(File.ReadAllText(path));
//Camera
var camera_data = (JObject)JsonConvert.DeserializeObject(json["Camera"].ToString());
camera = new Camera(
Vector3.FromList(JsonConvert.DeserializeObject <List <float> >(camera_data["lookFrom"].ToString())),
Vector3.FromList(JsonConvert.DeserializeObject <List <float> >(camera_data["lookAt"].ToString())),
new Vector3(0, 1, 0),
JsonToF(float.Parse(camera_data["FOV"].ToString())),
width / (float)height,
JsonToF(float.Parse(camera_data["radius"].ToString())),
JsonToF(float.Parse(camera_data["focus"].ToString())),
JsonToF(float.Parse(camera_data["shutter"].ToString())));
//Sky
Skybox = json.ContainsKey("Sky");
if (Skybox)
{
var skydata = (JObject)JsonConvert.DeserializeObject(File.ReadAllText(root + "/" + json["Sky"]));
var datas = JsonConvert.DeserializeObject <List <string> >(skydata["data"].ToString());
var r = Path.GetDirectoryName(root + "/" + json["Sky"]) + "/";
sky = new CubeMap(r + datas[0], r + datas[1], r + datas[2], r + datas[3], r + datas[4], r + datas[5]);
}
//Material
var shaders = new Dictionary <string, Shader>();
var material_datas = (JObject)JsonConvert.DeserializeObject(json["Materials"].ToString());
foreach (var pair in material_datas)
{
Shader shader = null;
var materjson = (JObject)JsonConvert.DeserializeObject(File.ReadAllText(root + "/" + pair.Value));
var datas = JsonConvert.DeserializeObject <List <string> >(materjson["data"].ToString());
var material_root = Path.GetDirectoryName(root + "/" + pair.Value);
switch (materjson["type"].ToString())
{
case "standard":
Texture reflect = null;
if (float.TryParse(datas[2], out var r))
{
reflect = new GrayTexture(r);
}
else
{
reflect = new ImageTexture(material_root + "/" + datas[2]);
}
shader = new StardardShader(
new ImageTexture(material_root + "/" + datas[0]),
new ImageTexture(material_root + "/" + datas[1]),
reflect, datas[3].ToString() == ""?null:new ImageTexture(material_root + "/" + datas[3])
);
break;
case "metal":
shader = new Metal(
new ImageTexture(material_root + "/" + datas[0]),
float.Parse(datas[1]));
break;
case "dielectirc":
shader = datas.Count == 1
? new Dielectirc(float.Parse(datas[0]))
: new Dielectirc(float.Parse(datas[0]), new Color32(int.Parse(datas[1]) / 255f, int.Parse(datas[2]) / 255f, int.Parse(datas[3]) / 255f));
break;
case "Lambertian":
shader = new Lambertian(new ImageTexture(material_root + "/" + datas[0]));
break;
case "light":
shader = datas.Count == 2
? new DiffuseLight(new ImageTexture(material_root + "/" + datas[1]), float.Parse(datas[0]))
:new DiffuseLight(new ConstantTexture(new Color32(int.Parse(datas[1]) / 255f, int.Parse(datas[2]) / 255f, int.Parse(datas[3]) / 255f)), float.Parse(datas[0]));
break;
}
shaders.Add(pair.Key.ToString(), shader);
}
Shader[] GetModelShaderList(List <string> name)
{
var result = new Shader[name.Count];
for (var i = 0; i < name.Count; i++)
{
result[i] = shaders[name[i]];
}
return(result);
}
//Objects
var obj_datas = (JObject)JsonConvert.DeserializeObject(json["Objects"].ToString());
var objlist = new List <Hitable>();
foreach (var pair in obj_datas)
{
var obj = (JObject)JsonConvert.DeserializeObject(pair.Value.ToString());
Hitable a = null;
switch (obj["type"].ToString())
{
case "model":
var scale = JsonToV3(obj["scale"]);
var pos = JsonToV3(obj["position"]);
var rot = JsonToV3(obj["rotation"]);
var m = new Translate(new RotateY(ByteModel.Load(root + "/" + obj["file"],
GetModelShaderList(JsonConvert.DeserializeObject <List <string> >(obj["material"].ToString())),
new Vector3(scale.x, scale.y, scale.z)), rot.y), pos);
objlist.Add(m);
if (bool.Parse(obj["important"].ToString()))
{
Important.list.Add(a);
}
break;
case "Oldmodel":
var scale_0 = JsonToV3(obj["scale"]);
var pos_0 = JsonToV3(obj["position"]);
var rot_0 = JsonToV3(obj["rotation"]);
var _m = new Translate(new RotateY(ByteModel.LoadOld(root + "/" + obj["file"],
GetModelShaderList(JsonConvert.DeserializeObject <List <string> >(obj["material"].ToString()))[0],
new Vector3(scale_0.x, scale_0.y, scale_0.z)), rot_0.y), pos_0);
objlist.Add(_m);
if (bool.Parse(obj["important"].ToString()))
{
Important.list.Add(a);
}
break;
case "cube":
a = new Translate(
new Mesh(Instances.Model.Cube,
shaders[
JsonConvert.DeserializeObject <List <string> >(obj["material"].ToString())[0]
]).Create(),
JsonToV3(obj["position"]));
objlist.Add(a);
if (bool.Parse(obj["important"].ToString()))
{
Important.list.Add(a);
}
break;
case "sphere":
a = new Sphere(JsonToV3(obj["position"]), float.Parse(obj["radius"].ToString()),
shaders[
JsonConvert.DeserializeObject <List <string> >(obj["material"].ToString())[0]
]);
objlist.Add(a);
if (bool.Parse(obj["important"].ToString()))
{
Important.list.Add(a);
}
break;
}
}
world.list.Add(new RotateY(new BVHNode(objlist.ToArray(), objlist.Count, 0, 1), 0));
PreviewWindow.main.Loading.Visible = false;
}
