public void TestEntitySerialization()
{
var entityAsset = new EntityAsset();
var entity1 = new Entity {
Id = Guid.NewGuid()
};
var entity2 = new Entity {
Id = Guid.NewGuid()
};
entity1.Transform.Children.Add(entity2.Transform);
entityAsset.Hierarchy.Entities.Add(entity1);
entityAsset.Hierarchy.Entities.Add(entity2);
using (var stream = new MemoryStream())
{
AssetSerializer.Save(stream, entityAsset);
stream.Position = 0;
var serializedVersion = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(serializedVersion);
stream.Position = 0;
var entityAsset2 = AssetSerializer.Load(stream, "xkentity");
}
}
public void TestParameters()
{
var materialAsset = AssetSerializer.Load <MaterialAsset>("materials/testMaterial.pdxmat");
var material = materialAsset.Material;
var parameterCreator = new MaterialParametersCreator(material, "testMaterial.pdxmat");
parameterCreator.CreateParameterCollectionData();
var parameters = parameterCreator.Parameters;
Assert.IsTrue(parameters.ContainsKey((MaterialParameters.AlbedoDiffuse)));
Assert.IsTrue(parameters.ContainsKey((MaterialParameters.AlbedoSpecular)));
Assert.IsTrue(parameters.ContainsKey((MaterialParameters.NormalMap)));
Assert.IsTrue(parameters.ContainsKey((MaterialParameters.DisplacementMap)));
Assert.AreEqual(MaterialDiffuseModel.Lambert, parameters[MaterialParameters.DiffuseModel]);
Assert.AreEqual(MaterialSpecularModel.BlinnPhong, parameters[MaterialParameters.SpecularModel]);
Assert.AreEqual(MaterialShadingModel.Phong, parameters[MaterialParameters.ShadingModel]);
Assert.AreEqual(new Color4(0.4f, 0.1f, 1, 1), parameters[MaterialKeys.SpecularColorValue]);
Assert.AreEqual(new Color4(1, 1, 0.5f, 0.5f), parameters[MaterialKeys.DiffuseColorValue]);
Assert.AreEqual(0, parameters[MaterialKeys.SpecularIntensity]);
Assert.AreEqual(0, parameters[MaterialKeys.SpecularPower]);
Assert.IsTrue(parameters.ContainsKey((TexturingKeys.Sampler0)));
Assert.IsTrue(parameters.ContainsKey((TexturingKeys.Texture0)));
Assert.IsTrue(parameters.ContainsKey((TexturingKeys.Texture1)));
Assert.IsTrue(parameters.ContainsKey((TexturingKeys.Texture2)));
Assert.IsTrue(parameters.ContainsKey((TexturingKeys.Texture3)));
Assert.AreEqual(16, parameters.Count);
}
public virtual void SetSourceAsset(T asset)
{
AssetSerializer serializer = new AssetSerializer();
serializer.AddItem(asset);
source = serializer.WriteToString();
typeName = asset.GetType().AssemblyQualifiedName;
}
public static bool Upgrade(PackageSession session, ILogger log, Package dependentPackage, PackageDependency dependency, Package dependencyPackage, IList <PackageLoadingAssetFile> assetFiles)
{
var packageSharedProfile = dependentPackage.Profiles.FindSharedProfile();
// Only do something if there is a default scene defined
if (packageSharedProfile != null && packageSharedProfile.Properties.ContainsKey(DefaultScene))
{
var defaultScene = Get(packageSharedProfile.Properties, DefaultScene);
var defaultGraphicsProfile = Get(packageSharedProfile.Properties, DefaultGraphicsProfile);
// If available, use graphics profile from Windows platform
foreach (var profile in dependentPackage.Profiles)
{
if (profile.Platform == PlatformType.Windows && profile.Properties.ContainsKey(DefaultGraphicsProfile))
{
defaultGraphicsProfile = Get(profile.Properties, DefaultGraphicsProfile);
}
}
// Create asset
var gameSettingsAsset = new GameSettingsAsset
{
DefaultScene = AttachedReferenceManager.CreateSerializableVersion <Scene>(defaultScene.Id, defaultScene.Location)
};
var renderingSettings = gameSettingsAsset.Get <RenderingSettings>();
renderingSettings.DisplayOrientation = (RequiredDisplayOrientation)Get(packageSharedProfile.Properties, DisplayOrientation);
renderingSettings.ColorSpace = ColorSpace.Linear;
renderingSettings.DefaultBackBufferWidth = Get(packageSharedProfile.Properties, BackBufferWidth);
renderingSettings.DefaultBackBufferHeight = Get(packageSharedProfile.Properties, BackBufferHeight);
renderingSettings.DefaultGraphicsProfile = defaultGraphicsProfile;
// Add asset
using (var memoryStream = new MemoryStream())
{
AssetSerializer.Save(memoryStream, gameSettingsAsset, log);
assetFiles.Add(new PackageLoadingAssetFile(dependentPackage, GameSettingsLocation + FileExtension, null)
{
AssetContent = memoryStream.ToArray()
});
}
// Clean properties
foreach (var profile in dependentPackage.Profiles)
{
profile.Properties.Remove(DefaultScene.Name);
profile.Properties.Remove(BackBufferWidth.Name);
profile.Properties.Remove(BackBufferHeight.Name);
profile.Properties.Remove(DefaultGraphicsProfile.Name);
profile.Properties.Remove(DisplayOrientation.Name);
}
}
return(true);
}
public void TestConstantKeyCreation()
{
var materialAsset = AssetSerializer.Load <MaterialAsset>("materials/testConstantValueKey.pdxmat");
var materialShaderCreator = new MaterialTreeShaderCreator(materialAsset.Material);
var allParameters = materialShaderCreator.GenerateModelShaders();
Assert.IsTrue(allParameters.Keys.Any(x => x == DummyFloatKey));
Assert.IsTrue(allParameters.Keys.Any(x => x == DummyVector4Key));
}
public static void GenerateAndCompare(string title, string outputFilePath, string referenceFilePath, Asset asset)
{
Console.WriteLine(title + @"- from file " + outputFilePath);
Console.WriteLine(@"---------------------------------------");
AssetSerializer.Save(outputFilePath, asset, null);
var left = File.ReadAllText(outputFilePath).Trim();
Console.WriteLine(left);
var right = File.ReadAllText(referenceFilePath).Trim();
Assert.That(left, Is.EqualTo(right));
}
public void TestReduction()
{
var materialAsset = AssetSerializer.Load <MaterialAsset>("materials/testReduction.pdxmat");
var materialReducer = new MaterialTreeReducer(materialAsset.Material);
materialReducer.ReduceTrees();
var reducedTrees = materialReducer.ReducedTrees;
Assert.IsTrue(reducedTrees["diffuse"] is MaterialFloat4Node);
}
public void TestSerializationWithBaseAndParts()
{
// Create an entity as in TestSerialization
// Then create a derivedAsset from it
// Then create a partAsset and add this partAsset as a composition to derivedAsset
// Serialize and deserialize derivedAsset
// Check that deserialized derivedAsset has all base/baseParts correctly serialized
var originAsset = CreateOriginAsset();
var derivedAsset = (EntityGroupAsset)originAsset.CreateChildAsset("base");
var basePartAsset = new EntityGroupAsset();
var entityPart1 = new Entity()
{
Name = "EPart1"
};
var entityPart2 = new Entity()
{
Name = "EPart2"
};
basePartAsset.Hierarchy.Entities.Add(entityPart1);
basePartAsset.Hierarchy.Entities.Add(entityPart2);
basePartAsset.Hierarchy.RootEntities.Add(entityPart1.Id);
basePartAsset.Hierarchy.RootEntities.Add(entityPart2.Id);
var partAsset = (EntityGroupAsset)basePartAsset.CreateChildAsset("part");
derivedAsset.AddPart(partAsset);
using (var stream = new MemoryStream())
{
AssetSerializer.Save(stream, derivedAsset);
stream.Position = 0;
var serializedVersion = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(serializedVersion);
stream.Position = 0;
var newAsset = (EntityGroupAsset)AssetSerializer.Load(stream, "xkentity");
Assert.NotNull(newAsset.Base);
Assert.NotNull(newAsset.BaseParts);
Assert.AreEqual(1, newAsset.BaseParts.Count);
CheckAsset(derivedAsset, newAsset);
CheckAsset(originAsset, (EntityGroupAsset)newAsset.Base.Asset);
CheckGenericAsset(basePartAsset, (EntityGroupAsset)newAsset.BaseParts[0].Asset);
}
}
public void TestMakeShader()
{
var materialAsset = AssetSerializer.Load <MaterialAsset>("materials/testMaterial.pdxmat");
var materialShaderCreator = new MaterialTreeShaderCreator(materialAsset.Material);
var allShaders = materialShaderCreator.GenerateModelShaders();
Assert.AreEqual(6, materialShaderCreator.ModelShaderSources.Count);
Assert.AreEqual(4, allShaders.Count);
// TODO: more tests
}
public void TestCopy()
{
var materialAsset = AssetSerializer.Load <MaterialAsset>("materials/testMaterial.pdxmat");
var material = materialAsset.Material;
var matCopy = materialAsset.Material.Clone();
Assert.AreEqual(material.Nodes.Count, matCopy.Nodes.Count);
foreach (var matRef in material.Nodes)
{
Assert.True(matCopy.Nodes.ContainsKey(matRef.Key));
//Assert.True(matRef.Value.Equals(matCopy.Nodes[matRef.Key]));
}
}
public void TestSave()
{
var materialAsset = AssetSerializer.Load <MaterialAsset>("materials/testMaterial.pdxmat");
var materialReducer = new MaterialTreeReducer(materialAsset.Material);
materialReducer.ReduceTrees();
var reducedTrees = materialReducer.ReducedTrees;
foreach (var reducedTree in reducedTrees)
{
materialAsset.Material.AddNode(reducedTree.Key + "_reduced", reducedTree.Value);
}
var model = new MaterialDescription();
model.SetParameter(MaterialParameters.UseTransparent, true);
model.SetParameter(MaterialParameters.ShadingModel, MaterialShadingModel.Phong);
model.SetParameter(MaterialParameters.DiffuseModel, MaterialDiffuseModel.Lambert);
model.SetParameter(MaterialParameters.SpecularModel, MaterialSpecularModel.BlinnPhong);
model.SetParameter(MaterialKeys.DiffuseColorValue, new Color4(1.0f, 1.0f, 0.5f, 0.5f));
model.SetParameter(MaterialKeys.SpecularColorValue, new Color4(0.4f, 0.1f, 1.0f, 1.0f));
model.SetParameter(MaterialKeys.SpecularIntensity, 1.1f);
model.SetParameter(MaterialKeys.SpecularPower, 10.1f);
var defaultModel = materialAsset.Material;
foreach (var treeName in defaultModel.ColorNodes)
{
model.ColorNodes.Add(treeName.Key, treeName.Value + "_reduced");
}
var matAsset2 = new MaterialAsset {
Material = model
};
AssetSerializer.Save("testMaterial2.pdxmat", matAsset2);
var savedAsset = AssetSerializer.Load <MaterialAsset>("testMaterial2.pdxmat");
var loadedMaterial = savedAsset.Material;
Assert.AreEqual(true, loadedMaterial.GetParameter(MaterialParameters.UseTransparent));
Assert.AreEqual(MaterialShadingModel.Phong, loadedMaterial.GetParameter(MaterialParameters.ShadingModel));
Assert.AreEqual(MaterialDiffuseModel.Lambert, loadedMaterial.GetParameter(MaterialParameters.DiffuseModel));
Assert.AreEqual(MaterialSpecularModel.BlinnPhong, loadedMaterial.GetParameter(MaterialParameters.SpecularModel));
Assert.AreEqual(new Color4(1.0f, 1.0f, 0.5f, 0.5f), loadedMaterial.GetParameter(MaterialKeys.DiffuseColorValue));
Assert.AreEqual(new Color4(0.4f, 0.1f, 1.0f, 1.0f), loadedMaterial.GetParameter(MaterialKeys.SpecularColorValue));
Assert.AreEqual(1.1f, loadedMaterial.GetParameter(MaterialKeys.SpecularIntensity));
Assert.AreEqual(10.1f, loadedMaterial.GetParameter(MaterialKeys.SpecularPower));
}
public static AbilityCreator CreateScriptableObject() {
AbilityCreator asset = ScriptableObject.CreateInstance<AbilityCreator>();
string assetpath = "Assets/Abilities/Ability.asset";
string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(assetpath);
Ability ability = new Ability();
ability.Id = Path.GetFileNameWithoutExtension(assetPathAndName);
AssetSerializer serializer = new AssetSerializer();
serializer.AddItem(ability);
asset.source = serializer.WriteToString();
AssetDatabase.CreateAsset(asset, assetPathAndName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
return asset;
}
public void TestLoad()
{
var materialAsset = AssetSerializer.Load <MaterialAsset>("materials/testMaterial.pdxmat");
var material = materialAsset.Material;
Assert.AreEqual(MaterialShadingModel.Phong, material.GetParameter(MaterialParameters.ShadingModel));
Assert.AreEqual(MaterialDiffuseModel.Lambert, material.GetParameter(MaterialParameters.DiffuseModel));
Assert.AreEqual(MaterialSpecularModel.BlinnPhong, material.GetParameter(MaterialParameters.SpecularModel));
Assert.AreEqual(new Color4(1, 1, 0.5f, 0.5f), material.GetParameter(MaterialKeys.DiffuseColorValue));
Assert.AreEqual(new Color4(0.4f, 0.1f, 1, 1), material.GetParameter(MaterialKeys.SpecularColorValue));
Assert.AreEqual(0, (float)material.GetParameter(MaterialKeys.SpecularIntensity));
Assert.AreEqual(0, (float)material.GetParameter(MaterialKeys.SpecularPower));
}
public static StatusEffectCreator CreateScriptableObject() {
StatusEffectCreator asset = ScriptableObject.CreateInstance<StatusEffectCreator>();
string assetpath = "Assets/Status Effects/Status Effect.asset";
string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(assetpath);
var effect = new StatusEffect();
effect.Id = Path.GetFileNameWithoutExtension(assetPathAndName);
AssetSerializer serializer = new AssetSerializer();
serializer.AddItem(effect);
asset.source = serializer.WriteToString();
AssetDatabase.CreateAsset(asset, assetPathAndName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
return asset;
}
public void TestUpgrade(MyUpgradedAsset asset, bool needMigration)
{
var outputFilePath = Path.Combine(DirectoryTestBase, @"TestUpgrade\Asset1.pdxobj");
AssetSerializer.Save(outputFilePath, asset);
var logger = new LoggerResult();
Assert.AreEqual(AssetMigration.MigrateAssetIfNeeded(logger, outputFilePath), needMigration);
Console.WriteLine(File.ReadAllText(outputFilePath).Trim());
var upgradedAsset = AssetSerializer.Load <MyUpgradedAsset>(outputFilePath);
AssertUpgrade(upgradedAsset);
}
public static AbilityCreator CreateScriptableObject()
{
AbilityCreator asset = ScriptableObject.CreateInstance <AbilityCreator>();
string assetpath = "Assets/Abilities/Ability.asset";
string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(assetpath);
Ability ability = new Ability();
ability.Id = Path.GetFileNameWithoutExtension(assetPathAndName);
AssetSerializer serializer = new AssetSerializer();
serializer.AddItem(ability);
asset.source = serializer.WriteToString();
AssetDatabase.CreateAsset(asset, assetPathAndName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
return(asset);
}
public static CharacterCreator CreateScriptableObject()
{
CharacterCreator asset = ScriptableObject.CreateInstance <CharacterCreator>();
string assetpath = "Assets/Characters/char.asset";
string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(assetpath);
Character character = new Character();
character.Id = Path.GetFileNameWithoutExtension(assetPathAndName);
AssetSerializer serializer = new AssetSerializer();
serializer.AddItem(character);
asset.source = serializer.WriteToString();
AssetDatabase.CreateAsset(asset, assetPathAndName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
return(asset);
}
public static StatusEffectCreator CreateScriptableObject()
{
StatusEffectCreator asset = ScriptableObject.CreateInstance <StatusEffectCreator>();
string assetpath = "Assets/Status Effects/Status Effect.asset";
string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(assetpath);
var effect = new StatusEffect();
effect.Id = Path.GetFileNameWithoutExtension(assetPathAndName);
AssetSerializer serializer = new AssetSerializer();
serializer.AddItem(effect);
asset.source = serializer.WriteToString();
AssetDatabase.CreateAsset(asset, assetPathAndName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
return(asset);
}
public static InventoryItemCreator CreateScriptableObject()
{
InventoryItemCreator asset = ScriptableObject.CreateInstance <InventoryItemCreator>();
string assetpath = "Assets/InventoryItems/InventoryItem.asset";
string assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(assetpath);
InventoryItem item = new InventoryItem();
item.Id = Path.GetFileNameWithoutExtension(assetPathAndName);
AssetSerializer serializer = new AssetSerializer();
serializer.AddItem(item);
asset.source = serializer.WriteToString();
AssetDatabase.CreateAsset(asset, assetPathAndName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
return(asset);
}
public void TestSerialization()
{
var originAsset = CreateOriginAsset();
using (var stream = new MemoryStream())
{
AssetSerializer.Save(stream, originAsset);
stream.Position = 0;
var serializedVersion = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(serializedVersion);
stream.Position = 0;
var newAsset = (PrefabAsset)AssetSerializer.Load(stream, "xkentity");
CheckAsset(originAsset, newAsset);
}
}
private void handle(string res)
{
if (string.IsNullOrEmpty(res))
{
if (callback != null)
{
callback(null);
}
return;
}
List <Asset> list = AssetSerializer.ToObjects(res);
if (list != null && list.Count != 0)
{
LogicController.ReplaceAssets(list);
}
if (callback != null)
{
callback(null);
}
}
public void RunTest()
{
// TODO: extend test with possible/impossible reduction cases
var materialUrl = "materials/testEffect.pdxmat";
var materialAsset = AssetSerializer.Load <MaterialAsset>(materialUrl);
var material = materialAsset.Material;
var graphicsDevice = GraphicsDevice.New(DeviceCreationFlags.None, GraphicsProfile.Level_11_0);
var solver = new MaterialTextureLayerFlattener(material, graphicsDevice);
solver.PrepareForFlattening();
var compiler = new EffectCompiler();
compiler.SourceDirectories.Add("shaders");
solver.Run(compiler);
// diffuse was reduced
Assert.AreEqual("diffuse", solver.Material.ColorNodes[MaterialParameters.AlbedoDiffuse]);
var node = solver.Material.Nodes["diffuse"];
Assert.NotNull(node);
var textureNode = solver.Material.Nodes["diffuse"] as MaterialTextureNode;
Assert.NotNull(textureNode);
Assert.IsTrue(textureNode.TextureName.StartsWith("__reduced_textures__"));
// specular was reduced
Assert.AreEqual("specular", solver.Material.ColorNodes[MaterialParameters.AlbedoSpecular]);
node = solver.Material.Nodes["specular"];
Assert.NotNull(node);
textureNode = solver.Material.Nodes["specular"] as MaterialTextureNode;
Assert.NotNull(textureNode);
Assert.IsTrue(textureNode.TextureName.StartsWith("__reduced_textures__"));
// normalMap wasn't reduced
Assert.AreEqual("normalMap", solver.Material.ColorNodes[MaterialParameters.NormalMap]);
node = solver.Material.Nodes["normalMap"];
Assert.IsFalse(solver.Material.Nodes["normalMap"] is MaterialTextureNode);
graphicsDevice.Dispose();
}
public void TestTextureGeneric()
{
var materialAsset = AssetSerializer.Load <MaterialAsset>("materials/testTextureGeneric.pdxmat");
var parameterCreator = new MaterialParametersCreator(materialAsset.Material, "testTextureGeneric.pdxmat");
parameterCreator.CreateParameterCollectionData();
var allParameters = parameterCreator.Parameters;
// TODO: remove Sampler0 (extra sampler)
Assert.IsTrue(allParameters.ContainsKey(TexturingKeys.Sampler0));
Assert.IsTrue(allParameters.ContainsKey(TexturingKeys.Sampler1));
Assert.IsTrue(allParameters.ContainsKey(TexturingKeys.Texture0));
Assert.IsFalse(allParameters.ContainsKey(TexturingKeys.Texture1));
var sampler = allParameters[TexturingKeys.Sampler1] as ContentReference <SamplerState>;
Assert.NotNull(sampler);
Assert.AreEqual(TextureAddressMode.Mirror, sampler.Value.Description.AddressU);
Assert.AreEqual(TextureAddressMode.Clamp, sampler.Value.Description.AddressV);
Assert.AreEqual(TextureFilter.Anisotropic, sampler.Value.Description.Filter);
}
public void Simple()
{
var asset = new MyUpgradedAsset {
Test = 32, Test2 = new List <int> {
32, 64
}
};
var outputFilePath = Path.Combine(DirectoryTestBase, @"TestUpgrade\Asset1.pdxobj");
AssetSerializer.Save(outputFilePath, asset);
var logger = new LoggerResult();
Assert.That(AssetMigration.MigrateAssetIfNeeded(logger, outputFilePath));
Console.WriteLine(File.ReadAllText(outputFilePath).Trim());
var upgradedAsset = AssetSerializer.Load <MyUpgradedAsset>(outputFilePath);
Assert.That(upgradedAsset.SerializedVersion, Is.EqualTo(2));
Assert.That(upgradedAsset.Test2, Is.Null);
Assert.That(upgradedAsset.Test3, Is.Not.Null);
}
public override void OnInspectorGUI()
{
PlayerSkillBook skillBook = target as PlayerSkillBook;
if (root == null)
{
if (!string.IsNullOrEmpty(skillBook.source))
{
new AssetDeserializer(skillBook.source, false).DeserializeInto("__default__", skillBook);
}
root = new SerializedObjectX(target);
}
EditorGUILayoutX.DrawProperties(root);
bool didChange = root.Root.ApplyModifiedProperties();
if (didChange)
{
AssetSerializer serializer = new AssetSerializer();
serializer.AddItem(target);
serializedObject.FindProperty("source").stringValue = serializer.WriteToString();
serializedObject.ApplyModifiedProperties();
}
}
public void TestUpgrade(MyUpgradedAsset asset, bool needMigration)
{
var loadingFilePath = new PackageLoadingAssetFile(Path.Combine(DirectoryTestBase, "TestUpgrade\\Asset1.pdxobj"), "");
var outputFilePath = loadingFilePath.FilePath.FullPath;
AssetSerializer.Save(outputFilePath, asset);
var logger = new LoggerResult();
Assert.AreEqual(AssetMigration.MigrateAssetIfNeeded(logger, loadingFilePath), needMigration);
if (needMigration)
{
using (var fileStream = new FileStream(outputFilePath, FileMode.Truncate))
fileStream.Write(loadingFilePath.AssetContent, 0, loadingFilePath.AssetContent.Length);
}
Console.WriteLine(File.ReadAllText(outputFilePath).Trim());
var upgradedAsset = AssetSerializer.Load <MyUpgradedAsset>(outputFilePath);
AssertUpgrade(upgradedAsset);
}
/// <summary>
/// 3-way merge assets using an external diff tool.
/// </summary>
/// <param name="assetBase0">The asset base0.</param>
/// <param name="assetFrom1">The asset from1.</param>
/// <param name="assetFrom2">The asset from2.</param>
/// <returns>The result of the merge.</returns>
public static MergeResult MergeWithExternalTool(Asset assetBase0, Asset assetFrom1, Asset assetFrom2)
{
var result = new MergeResult();
// If they are all null, nothing to do
if (assetBase0 == null && assetFrom1 == null && assetFrom2 == null)
{
return(result);
}
if (!File.Exists(DefaultMergeTool))
{
result.Error("Unable to use external diff3 merge tool [{0}]. File not found", DefaultMergeTool);
return(result);
}
var assetBase = (Asset)AssetCloner.Clone(assetBase0);
var asset1 = (Asset)AssetCloner.Clone(assetFrom1);
var asset2 = (Asset)AssetCloner.Clone(assetFrom2);
// Clears base as we are not expecting to work with them directly
// The real base must be passed by the assetBase0 parameter
if (assetBase != null)
{
assetBase.Base = null;
}
if (asset1 != null)
{
asset1.Base = null;
}
if (asset2 != null)
{
asset2.Base = null;
}
var assetBasePath = Path.GetTempFileName();
var asset1Path = Path.GetTempFileName();
var asset2Path = Path.GetTempFileName();
try
{
AssetSerializer.Save(assetBasePath, assetBase);
AssetSerializer.Save(asset1Path, asset1);
AssetSerializer.Save(asset2Path, asset2);
}
catch (Exception exception)
{
result.Error("Unexpected error while serializing assets on disk before using diff tool", exception);
return(result);
}
var outputPath = Path.GetTempFileName();
try
{
// TODO We need to access different diff tools command line
// kdiff3.exe file1 file2 file3 -o outputfile
var process = Process.Start(DefaultMergeTool, string.Format("{0} {1} {2} -o {3}", assetBasePath, asset1Path, asset2Path, outputPath));
if (process == null)
{
result.Error("Unable to launch diff3 tool exe from [{0}]", DefaultMergeTool);
}
else
{
process.WaitForExit();
if (process.ExitCode != 0)
{
result.Error("Error, failed to merge files");
}
}
}
catch (Exception ex)
{
result.Error("Unable to launch diff3 tool exe from [{0}]", ex, DefaultMergeTool);
}
if (!result.HasErrors)
{
try
{
var mergedAsset = (Asset)AssetSerializer.Load(outputPath);
if (mergedAsset != null)
{
if (assetFrom1 == null)
{
mergedAsset.Base = assetFrom2 == null ? assetBase0.Base : assetFrom2.Base;
}
else
{
mergedAsset.Base = assetFrom1.Base;
}
}
result.Asset = mergedAsset;
}
catch (Exception ex)
{
result.Error("Unexpected exception while loading merged assets from [{0}]", ex, outputPath);
}
}
return(result);
}
public void TestSerializationWithBaseAndParts()
{
// Create an entity as in TestSerialization
// Then create a derivedAsset from it
// Then create a partAsset and add this partAsset as a composition to derivedAsset
// Serialize and deserialize derivedAsset
// Check that deserialized derivedAsset has all base/baseParts correctly serialized
var originAsset = CreateOriginAsset();
var derivedAsset = (PrefabAsset)originAsset.CreateChildAsset("base");
var basePartAsset = new PrefabAsset();
var entityPart1 = new Entity()
{
Name = "EPart1"
};
var entityPart2 = new Entity()
{
Name = "EPart2"
};
basePartAsset.Hierarchy.Parts.Add(new EntityDesign(entityPart1));
basePartAsset.Hierarchy.Parts.Add(new EntityDesign(entityPart2));
basePartAsset.Hierarchy.RootPartIds.Add(entityPart1.Id);
basePartAsset.Hierarchy.RootPartIds.Add(entityPart2.Id);
// Add 2 asset parts from the same base
var instance = basePartAsset.CreatePrefabInstance(derivedAsset, "part");
derivedAsset.Hierarchy.Parts.AddRange(instance.Parts);
derivedAsset.Hierarchy.RootPartIds.AddRange(instance.RootPartIds);
var instance2 = basePartAsset.CreatePrefabInstance(derivedAsset, "part");
derivedAsset.Hierarchy.Parts.AddRange(instance2.Parts);
derivedAsset.Hierarchy.RootPartIds.AddRange(instance2.RootPartIds);
using (var stream = new MemoryStream())
{
AssetSerializer.Save(stream, derivedAsset);
stream.Position = 0;
var serializedVersion = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(serializedVersion);
stream.Position = 0;
var newAsset = (PrefabAsset)AssetSerializer.Load(stream, "xkentity");
Assert.NotNull(newAsset.Base);
Assert.NotNull(newAsset.BaseParts);
// We should have only 1 base part, as we created parts from the same base
Assert.AreEqual(1, newAsset.BaseParts.Count);
CheckAsset(derivedAsset, newAsset);
CheckAsset(originAsset, (PrefabAsset)newAsset.Base.Asset);
CheckGenericAsset(basePartAsset, (PrefabAsset)newAsset.BaseParts[0].Asset);
}
}
public void TestMyAssetObject()
{
var assetObject = new MyAsset();
assetObject.Id = Guid.Empty;
assetObject.Description = "This is a test";
assetObject.AssetDirectory = new UDirectory("/test/dynamic/path/to/file/in/object/property");
assetObject.AssetUrl = new UFile("/test/dynamic/path/to/file/in/object/property");
//assetObject.Base = new AssetBase("/this/is/an/url/to/MyObject", null);
assetObject.CustomReference2 = new AssetReference <Asset>(Guid.Empty, "/this/is/an/url/to/MyCustomReference2");
assetObject.CustomReferences.Add(new AssetReference <Asset>(Guid.Empty, "/this/is/an/url/to/MyCustomReferenceItem1"));
assetObject.SeqItems1.Add("value1");
assetObject.SeqItems1.Add("value2");
assetObject.SeqItems2.Add("value1");
assetObject.SeqItems2.Add("value2");
assetObject.SeqItems2.Add("value3");
assetObject.SeqItems3.Add("value1");
assetObject.SeqItems3.Add("value2");
assetObject.SeqItems3.Add("value3");
assetObject.SeqItems3.Add("value4");
assetObject.SeqItems4.Add("value0");
assetObject.SeqItems5.Add("value0");
assetObject.MapItems1.Add("key1", 1);
assetObject.MapItems1.Add("key2", 2);
assetObject.MapItems2.Add("key1", 1);
assetObject.MapItems2.Add("key2", 2);
assetObject.MapItems2.Add("key3", 3);
assetObject.MapItems3.Add("key1", 1);
assetObject.MapItems3.Add("key2", 2);
assetObject.MapItems3.Add("key3", 3);
assetObject.MapItems3.Add("key4", 3);
string testGenerated1 = DirectoryTestBase + @"TestSerializing\TestSerializing_TestMyAssetObject_Generated1.xkobj";
string testGenerated2 = DirectoryTestBase + @"TestSerializing\TestSerializing_TestMyAssetObject_Generated2.xkobj";
string referenceFilePath = DirectoryTestBase + @"TestSerializing\TestSerializing_TestMyAssetObject_Reference.xkobj";
var myAssetDescriptor = TypeDescriptorFactory.Default.Find(typeof(MyAsset));
// Put a New Sealed on the Description
//assetObject.SetDynamicProperty(myAssetDescriptor["Description"], Override.Key, OverrideType.New | OverrideType.Sealed);
assetObject.SetOverride(myAssetDescriptor["Description"], OverrideType.New | OverrideType.Sealed);
// First store the file on the disk and compare it to the reference
GenerateAndCompare("Test Serialization 1", testGenerated1, referenceFilePath, assetObject);
// Deserialize it
var newAssetObject = AssetSerializer.Load <MyAsset>(testGenerated1);
var overrideKey = newAssetObject.GetOverride(myAssetDescriptor["Description"]);
Assert.AreEqual(overrideKey, OverrideType.New | OverrideType.Sealed);
// Restore the deserialize version and compare it with the reference
GenerateAndCompare("Test Serialization 2 - double check", testGenerated2, referenceFilePath, newAssetObject);
}
public void TestBasicPackageCreateSaveLoad()
{
var dirPath = DirectoryTestBase + @"TestBasicPackageCreateSaveLoad";
string testGenerated1 = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.xkpkg");
string testGenerated2 = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated2.xkpkg");
string referenceFilePath = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Reference.xkpkg");
// Force the PackageId to be the same each time we run the test
// Usually the PackageId is unique and generated each time we create a new project
var project = new Package {
Id = Guid.Empty, FullPath = testGenerated1
};
var sharedProfile = new PackageProfile("Shared", new AssetFolder("."));
project.Profiles.Add(sharedProfile);
var projectReference = new ProjectReference(Guid.Empty, Path.Combine(dirPath, "test.csproj"), ProjectType.Executable);
sharedProfile.ProjectReferences.Add(projectReference);
var session = new PackageSession(project);
// Write the solution when saving
session.SolutionPath = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.sln");
// Delete the solution before saving it
if (File.Exists(session.SolutionPath))
{
File.Delete(session.SolutionPath);
}
var result = session.Save();
Assert.IsFalse(result.HasErrors);
// Reload the raw package and if UFile and UDirectory were saved relative
var rawPackage = (Package)AssetSerializer.Load(testGenerated1);
var rawPackageSharedProfile = rawPackage.Profiles.FirstOrDefault();
Assert.IsNotNull(rawPackageSharedProfile);
var rawSourceFolder = rawPackage.Profiles.First().AssetFolders.FirstOrDefault();
Assert.IsNotNull(rawSourceFolder);
Assert.AreEqual(".", (string)rawSourceFolder.Path);
Assert.AreEqual("test.csproj", (string)rawPackageSharedProfile.ProjectReferences[0].Location);
// Reload the package directly from the xkpkg
var project2Result = PackageSession.Load(testGenerated1);
AssertResult(project2Result);
var project2 = project2Result.Session.LocalPackages.FirstOrDefault();
Assert.IsNotNull(project2);
Assert.AreEqual(project.Id, project2.Id);
Assert.IsTrue(project2.Profiles.Count > 0);
Assert.IsTrue(project2.Profiles.First().AssetFolders.Count > 0);
Assert.AreEqual(project2, project2Result.Session.CurrentPackage); // Check that the current package is setup when loading a single package
var sourceFolder = project.Profiles.First().AssetFolders.First().Path;
Assert.AreEqual(sourceFolder, project2.Profiles.First().AssetFolders.First().Path);
// Reload the package from the sln
var sessionResult = PackageSession.Load(session.SolutionPath);
Assert.IsFalse(sessionResult.HasErrors);
var sessionReload = sessionResult.Session;
Assert.AreEqual(1, sessionReload.LocalPackages.Count());
Assert.AreEqual(project.Id, sessionReload.LocalPackages.First().Id);
Assert.AreEqual(1, sessionReload.LocalPackages.First().Profiles.Count);
var sharedProfileReload = sessionReload.LocalPackages.First().Profiles.First();
Assert.AreEqual(1, sharedProfileReload.ProjectReferences.Count);
Assert.AreEqual(projectReference, sharedProfileReload.ProjectReferences[0]);
}
public void Test()
{
var prefab = new PrefabAsset();
var modelComponent = new ModelComponent();
var entity = new Entity()
{
modelComponent
};
prefab.Hierarchy.Parts.Add(new EntityDesign(entity));
prefab.Hierarchy.RootPartIds.Add(entity.Id);
var material1 = new MaterialNull();
IdentifiableHelper.SetId(material1, new Guid("39E2B226-8752-4678-8E93-76FFBFBA337B"));
var material2 = new MaterialNull();
IdentifiableHelper.SetId(material2, new Guid("CC4F1B31-FBB7-4360-A3E7-060BDFDA0695"));
modelComponent.Materials.Add(material1);
modelComponent.Materials.Add(material2);
Action <PrefabAsset> checkPrefab = (newPrefab) =>
{
var previousEntityDesign = newPrefab.Hierarchy.Parts.FirstOrDefault();
Assert.NotNull(previousEntityDesign);
var previousEntity = previousEntityDesign.Entity;
var component = previousEntity.Get <ModelComponent>();
Assert.NotNull(component);
Assert.AreEqual(2, component.Materials.Count);
var newMaterial1 = component.Materials[0];
Assert.AreEqual(IdentifiableHelper.GetId(material1), IdentifiableHelper.GetId(newMaterial1));
var newMaterial2 = component.Materials[1];
Assert.AreEqual(IdentifiableHelper.GetId(material2), IdentifiableHelper.GetId(newMaterial2));
};
// Test yaml serialization
{
using (var stream = new MemoryStream())
{
AssetSerializer.Save(stream, prefab);
stream.Position = 0;
var serializedVersion = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(serializedVersion);
stream.Position = 0;
var newPrefab = (PrefabAsset)AssetSerializer.Load(stream, "myentity");
checkPrefab(newPrefab);
}
}
// Test cloning
var newPrefabClone = (PrefabAsset)AssetCloner.Clone(prefab);
checkPrefab(newPrefabClone);
// Test runtime serialization (runtime serialization is removing MaterialNull and replacing it by a null)
{
var stream = new MemoryStream();
var writer = new BinarySerializationWriter(stream)
{
Context = { SerializerSelector = SerializerSelector.AssetWithReuse }
};
writer.SerializeExtended(entity, ArchiveMode.Serialize);
writer.Flush();
stream.Position = 0;
var reader = new BinarySerializationReader(stream)
{
Context = { SerializerSelector = SerializerSelector.AssetWithReuse }
};
Entity newEntity = null;
reader.SerializeExtended(ref newEntity, ArchiveMode.Deserialize);
Assert.NotNull(newEntity);
var component = newEntity.Get <ModelComponent>();
Assert.NotNull(component);
Assert.AreEqual(2, component.Materials.Count);
Assert.Null(component.Materials[0]);
Assert.Null(component.Materials[1]);
}
}
public void TestShaderLoad()
{
var materialAsset = AssetSerializer.Load <MaterialAsset>("materials/testMaterial.pdxmat");
Assert.AreEqual(7, materialAsset.Material.Nodes.Count);
}
