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 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 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 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 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 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 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 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); } }
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 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); }