private bool IsYamlAsset(PackageLoadingAssetFile assetFile) { // Determine if asset was Yaml or not var assetFileExtension = Path.GetExtension(assetFile.FilePath); assetFileExtension = assetFileExtension?.ToLowerInvariant(); var serializer = AssetFileSerializer.FindSerializer(assetFileExtension); return(serializer is YamlAssetSerializer); }
public void TestSimpleDeserialization() { var asset = AssetFileSerializer.Load <Types.MyAssetHierarchy>(AssetTestContainer.ToStream(SimpleHierarchyYaml), $"MyAsset{Types.FileExtension}"); Assert.Equal(2, asset.Asset.Hierarchy.RootParts.Count); Assert.Equal(GuidGenerator.Get(2), asset.Asset.Hierarchy.RootParts[0].Id); Assert.Equal(GuidGenerator.Get(1), asset.Asset.Hierarchy.RootParts[1].Id); Assert.Equal(2, asset.Asset.Hierarchy.Parts.Count); Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(1))); Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(2))); }
public static void GenerateAndCompare(string title, string outputFilePath, string referenceFilePath, Asset asset) { Console.WriteLine(title + @"- from file " + outputFilePath); Console.WriteLine(@"---------------------------------------"); AssetFileSerializer.Save(outputFilePath, asset); var left = File.ReadAllText(outputFilePath).Trim(); Console.WriteLine(left); var right = File.ReadAllText(referenceFilePath).Trim(); Assert.That(left, Is.EqualTo(right)); }
public void TestBasicPackageCreateSaveLoad() { PackageSessionPublicHelper.FindAndSetMSBuildVersion(); var dirPath = DirectoryTestBase + @"TestBasicPackageCreateSaveLoad"; string testGenerated1 = Path.Combine(dirPath, "TestPackage_TestBasicPackageCreateSaveLoad_Generated1.sdpkg"); // 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 { FullPath = testGenerated1 }; project.AssetFolders.Clear(); project.AssetFolders.Add(new AssetFolder(".")); 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 = new LoggerResult(); session.Save(result); Assert.False(result.HasErrors); // Reload the raw package and if UFile and UDirectory were saved relative var rawPackage = AssetFileSerializer.Load <Package>(testGenerated1).Asset; var rawSourceFolder = rawPackage.AssetFolders.FirstOrDefault(); Assert.NotNull(rawSourceFolder); Assert.Equal(".", (string)rawSourceFolder.Path); // Reload the package directly from the sdpkg var project2Result = PackageSession.Load(testGenerated1); AssertResult(project2Result); var project2 = project2Result.Session.LocalPackages.FirstOrDefault(); Assert.NotNull(project2); Assert.True(project2.AssetFolders.Count > 0); var sourceFolder = project.AssetFolders.First().Path; Assert.Equal(sourceFolder, project2.AssetFolders.First().Path); }
public static DeriveAssetTest <T> LoadFromYaml(string baseYaml, string derivedYaml) { var baseAsset = AssetFileSerializer.Load <T>(ToStream(baseYaml), $"MyAsset{Types.FileExtension}"); var derivedAsset = AssetFileSerializer.Load <T>(ToStream(derivedYaml), $"MyDerivedAsset{Types.FileExtension}"); var result = new DeriveAssetTest <T>(baseAsset.Asset, derivedAsset.Asset) { BaseAssetItem = { Overrides = baseAsset.Overrides }, DerivedAssetItem = { Overrides = derivedAsset.Overrides } }; result.BuildGraph(); return(result); }
public void TestMissortedPartsDeserialization() { var asset = AssetFileSerializer.Load <Types.MyAssetHierarchy>(AssetTestContainer.ToStream(MissortedHierarchyYaml), $"MyAsset{Types.FileExtension}"); Assert.Equal(2, asset.Asset.Hierarchy.RootParts.Count); Assert.Equal(GuidGenerator.Get(2), asset.Asset.Hierarchy.RootParts[0].Id); Assert.Equal(GuidGenerator.Get(1), asset.Asset.Hierarchy.RootParts[1].Id); Assert.Equal(4, asset.Asset.Hierarchy.Parts.Count); Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(1))); Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(2))); Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(3))); Assert.True(asset.Asset.Hierarchy.Parts.ContainsKey(GuidGenerator.Get(4))); Assert.Single(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(3)].Part.Children); Assert.Equal(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(2)].Part, asset.Asset.Hierarchy.Parts[GuidGenerator.Get(3)].Part.Children[0]); Assert.Single(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(4)].Part.Children); Assert.Equal(asset.Asset.Hierarchy.Parts[GuidGenerator.Get(1)].Part, asset.Asset.Hierarchy.Parts[GuidGenerator.Get(4)].Part.Children[0]); }
public static void SerializeAndCompare(AssetItem assetItem, AssetPropertyGraph graph, string expectedYaml, bool isDerived) { assetItem.Asset.Id = isDerived ? DerivedId : BaseId; Assert.Equal(isDerived, assetItem.Asset.Archetype != null); if (isDerived) { assetItem.Asset.Archetype = new AssetReference(BaseId, assetItem.Asset.Archetype?.Location); } graph.PrepareForSave(null, assetItem); var stream = new MemoryStream(); AssetFileSerializer.Save(stream, assetItem.Asset, assetItem.YamlMetadata, null); stream.Position = 0; var streamReader = new StreamReader(stream); var yaml = streamReader.ReadToEnd(); Assert.Equal(expectedYaml, yaml); }
public void TestSerialization() { var originAsset = CreateOriginAsset(); using (var stream = new MemoryStream()) { AssetFileSerializer.Save(stream, originAsset); stream.Position = 0; var serializedVersion = Encoding.UTF8.GetString(stream.ToArray()); Console.WriteLine(serializedVersion); stream.Position = 0; var newAsset = AssetFileSerializer.Load <PrefabAsset>(stream, "Prefab.xkprefab").Asset; CheckAsset(originAsset, newAsset); } }
public static DeriveAssetTest <TAsset, TAssetPropertyGraph> LoadFromYaml(string baseYaml, string derivedYaml) { var container = new AssetPropertyGraphContainer(new AssetNodeContainer { NodeBuilder = { NodeFactory = new AssetNodeFactory() } }); var baseAsset = AssetFileSerializer.Load <TAsset>(AssetTestContainer.ToStream(baseYaml), $"MyAsset{Types.FileExtension}"); var derivedAsset = AssetFileSerializer.Load <TAsset>(AssetTestContainer.ToStream(derivedYaml), $"MyDerivedAsset{Types.FileExtension}"); var baseContainer = new AssetTestContainer <TAsset, TAssetPropertyGraph>(container, baseAsset.Asset); var derivedContainer = new AssetTestContainer <TAsset, TAssetPropertyGraph>(container, derivedAsset.Asset); baseAsset.YamlMetadata.CopyInto(baseContainer.AssetItem.YamlMetadata); derivedAsset.YamlMetadata.CopyInto(derivedContainer.AssetItem.YamlMetadata); baseContainer.BuildGraph(); derivedContainer.BuildGraph(); var result = new DeriveAssetTest <TAsset, TAssetPropertyGraph>(baseContainer, derivedContainer, null); derivedContainer.Graph.RefreshBase(); return(result); }
public void TestUpgrade(MyUpgradedAsset asset, bool needMigration) { var loadingFilePath = new PackageLoadingAssetFile(Path.Combine(DirectoryTestBase, "TestUpgrade\\Asset1.xkobj"), DirectoryTestBase); var outputFilePath = loadingFilePath.FilePath.FullPath; AssetFileSerializer.Save(outputFilePath, asset, null); var logger = new LoggerResult(); var context = new AssetMigrationContext(null, loadingFilePath.ToReference(), loadingFilePath.FilePath.ToWindowsPath(), logger); Assert.AreEqual(AssetMigration.MigrateAssetIfNeeded(context, loadingFilePath, "TestPackage"), 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 = AssetFileSerializer.Load <MyUpgradedAsset>(outputFilePath).Asset; AssertUpgrade(upgradedAsset); }
public void TestMyAssetObject() { var assetObject = new MyAsset(); assetObject.Id = AssetId.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(AssetId.Empty, "/this/is/an/url/to/MyCustomReference2"); assetObject.CustomReferences.Add(new AssetReference(AssetId.Empty, "/this/is/an/url/to/MyCustomReferenceItem1")); var ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.CustomReferences); ids[0] = IdentifierGenerator.Get(99); assetObject.SeqItems1.Add("value1"); assetObject.SeqItems1.Add("value2"); ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.SeqItems1); ids[0] = IdentifierGenerator.Get(1); ids[1] = IdentifierGenerator.Get(2); // TODO: Re-enable non-pure collections here once we support them for serialization! //assetObject.SeqItems2.Add("value1"); //assetObject.SeqItems2.Add("value2"); //assetObject.SeqItems2.Add("value3"); //ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.SeqItems2); //ids[0] = IdentifierGenerator.Get(3); //ids[1] = IdentifierGenerator.Get(4); //ids[2] = IdentifierGenerator.Get(5); assetObject.SeqItems3.Add("value1"); assetObject.SeqItems3.Add("value2"); assetObject.SeqItems3.Add("value3"); assetObject.SeqItems3.Add("value4"); ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.SeqItems3); ids[0] = IdentifierGenerator.Get(6); ids[1] = IdentifierGenerator.Get(7); ids[2] = IdentifierGenerator.Get(8); ids[3] = IdentifierGenerator.Get(9); assetObject.SeqItems4.Add("value0"); ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.SeqItems4); ids[0] = IdentifierGenerator.Get(10); // TODO: Re-enable non-pure collections here once we support them for serialization! //assetObject.SeqItems5.Add("value0"); //ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.SeqItems5); //ids[0] = IdentifierGenerator.Get(11); assetObject.MapItems1.Add("key1", 1); assetObject.MapItems1.Add("key2", 2); ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.MapItems1); ids["key1"] = IdentifierGenerator.Get(12); ids["key2"] = IdentifierGenerator.Get(13); // TODO: Re-enable non-pure collections here once we support them for serialization! //assetObject.MapItems2.Add("key1", 1); //assetObject.MapItems2.Add("key2", 2); //assetObject.MapItems2.Add("key3", 3); //ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.MapItems2); //ids["key1"] = IdentifierGenerator.Get(13); //ids["key2"] = IdentifierGenerator.Get(14); //ids["key3"] = IdentifierGenerator.Get(15); assetObject.MapItems3.Add("key1", 1); assetObject.MapItems3.Add("key2", 2); assetObject.MapItems3.Add("key3", 3); assetObject.MapItems3.Add("key4", 3); ids = CollectionItemIdHelper.GetCollectionItemIds(assetObject.MapItems3); ids["key1"] = IdentifierGenerator.Get(16); ids["key2"] = IdentifierGenerator.Get(17); ids["key3"] = IdentifierGenerator.Get(18); ids["key4"] = IdentifierGenerator.Get(19); string testGenerated1 = DirectoryTestBase + @"TestSerializing\TestSerializing_TestMyAssetObject_Generated1.sdobj"; string testGenerated2 = DirectoryTestBase + @"TestSerializing\TestSerializing_TestMyAssetObject_Generated2.sdobj"; string referenceFilePath = DirectoryTestBase + @"TestSerializing\TestSerializing_TestMyAssetObject_Reference.sdobj"; // First store the file on the disk and compare it to the reference GenerateAndCompare("Test Serialization 1", testGenerated1, referenceFilePath, assetObject); // Deserialize it var newAssetObject = AssetFileSerializer.Load <MyAsset>(testGenerated1).Asset; // Restore the deserialize version and compare it with the reference GenerateAndCompare("Test Serialization 2 - double check", testGenerated2, referenceFilePath, newAssetObject); }
static void ImportFile(string path, string relativePath, string output) { string[] arr = relativePath.Split('.'); string name = Path.GetFileNameWithoutExtension(relativePath); switch (arr[arr.Length - 1]) { case "jpg": case "jpeg": case "dds": case "tiff": case "tif": case "psd": case "tga": case "bmp": case "gif": case "png": break; if ((name.ToLower().EndsWith("bump") && !name.ToLower().StartsWith("bump")) || (name.ToLower().EndsWith("normal") && !name.ToLower().StartsWith("normal"))) { TextureAsset tex = NormalMapTextureFactory.Create(); tex.Source = new UFile(relativePath); if (!overwrite && File.Exists($"{output}/{name}{TextureAsset.FileExtension}")) { Console.WriteLine($"{output}/{name}{TextureAsset.FileExtension} exists - not writing."); break; } else { AssetFileSerializer.Save($"{output}/{name}{TextureAsset.FileExtension}", tex, null); } } else { TextureAsset tex = ColorTextureFactory.Create(); tex.Source = new UFile(relativePath); if (!overwrite && File.Exists($"{output}/{name}{TextureAsset.FileExtension}")) { Console.WriteLine($"{output}/{name}{TextureAsset.FileExtension} exists - not writing."); break; } AssetFileSerializer.Save($"{output}/{name}{TextureAsset.FileExtension}", tex, null); MaterialAsset mat = DiffuseMaterialFactory.Create(); ((ComputeTextureColor)((MaterialDiffuseMapFeature)mat.Attributes.Diffuse).DiffuseMap).Texture = GetTexture(tex); AssetFileSerializer.Save($"{output}/{name}{MaterialAsset.FileExtension}", mat, null); } break; case "dae": case "3ds": case "obj": case "blend": case "x": case "md2": case "md3": case "dxf": case "fbx": if (!overwrite && File.Exists($"{output}/{name}{ModelAsset.FileExtension.Split(';')[0]}")) { Console.WriteLine($"{output}/{name}{ModelAsset.FileExtension.Split(';')[0]} exists - not writing."); break; } ModelAsset model = DefaultAssetFactory <ModelAsset> .Create(); model.Source = new UFile(relativePath); Scene scene = ctx.ImportFile(path, PostProcessSteps.None); Dictionary <string, Stride.Rendering.Material> materials = new Dictionary <string, Stride.Rendering.Material>(); for (int i = 0; i < scene.MaterialCount; i++) { if (materials.ContainsKey(scene.Materials[i].Name)) { model.Materials.Add(new ModelMaterial() { Name = scene.Materials[i].Name, MaterialInstance = new MaterialInstance(materials[scene.Materials[i].Name]) }); continue; } if (!overwrite && File.Exists($"{output}/{scene.Materials[i].Name}{MaterialAsset.FileExtension}")) { Console.WriteLine($"{output}/{scene.Materials[i].Name}{MaterialAsset.FileExtension} exists - not writing parent mesh."); break; } MaterialAsset materialAsset = DiffuseMaterialFactory.Create(); // set diffuse (if possible) if (scene.Materials[i].HasTextureDiffuse) { string diffPath = Path.GetRelativePath(output, Path.Combine(Path.GetDirectoryName(path), scene.Materials[i].TextureDiffuse.FilePath)); TextureAsset asset = ImportTexture(diffPath, TextureType.Diffuse); if (!overwrite && File.Exists($"{output}/{asset.Source.GetFileNameWithoutExtension()}{TextureAsset.FileExtension}")) { Console.WriteLine($"{output}/{asset.Source.GetFileNameWithoutExtension()}{TextureAsset.FileExtension} exists - not writing parent mesh."); break; } AssetFileSerializer.Save($"{output}/{asset.Source.GetFileNameWithoutExtension()}{TextureAsset.FileExtension}", asset, null); Texture tex = GetTexture(asset); SetTexture(materialAsset, tex, TextureType.Diffuse); } // normals if (scene.Materials[i].HasTextureNormal) { string normPath = Path.GetRelativePath(output, Path.Combine(Path.GetDirectoryName(path), scene.Materials[i].TextureNormal.FilePath)); TextureAsset asset = ImportTexture(normPath, TextureType.Normals); if (!overwrite && File.Exists($"{output}/{asset.Source.GetFileNameWithoutExtension()}{TextureAsset.FileExtension}")) { Console.WriteLine($"{output}/{asset.Source.GetFileNameWithoutExtension()}{TextureAsset.FileExtension} exists - not writing parent mesh."); break; } AssetFileSerializer.Save($"{output}/{asset.Source.GetFileNameWithoutExtension()}{TextureAsset.FileExtension}", asset, null); Texture tex = GetTexture(asset); SetTexture(materialAsset, tex, TextureType.Normals); } AssetFileSerializer.Save($"{output}/{scene.Materials[i].Name}{MaterialAsset.FileExtension}", materialAsset, null); Stride.Rendering.Material material = GetMaterial(materialAsset, scene.Materials[i].Name); model.Materials.Add(new ModelMaterial() { Name = scene.Materials[i].Name, MaterialInstance = new MaterialInstance(material) }); materials.Add(scene.Materials[i].Name, material); } AssetFileSerializer.Save($"{output}/{name}{ModelAsset.FileExtension.Split(';')[0]}", model, null); break; default: Console.WriteLine($"The file extension \".{arr[arr.Length - 1]}\" is not supported. ({path})"); break; } }
public void TestBasicPackageCreateSaveLoad() { PackageSessionPublicHelper.FindAndSetMSBuildVersion(); 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 = new LoggerResult(); session.Save(result); Assert.False(result.HasErrors); // Reload the raw package and if UFile and UDirectory were saved relative var rawPackage = AssetFileSerializer.Load <Package>(testGenerated1).Asset; var rawPackageSharedProfile = rawPackage.Profiles.FirstOrDefault(); Assert.NotNull(rawPackageSharedProfile); var rawSourceFolder = rawPackage.Profiles.First().AssetFolders.FirstOrDefault(); Assert.NotNull(rawSourceFolder); Assert.Equal(".", (string)rawSourceFolder.Path); Assert.Equal("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.NotNull(project2); Assert.Equal(project.Id, project2.Id); Assert.True(project2.Profiles.Count > 0); Assert.True(project2.Profiles.First().AssetFolders.Count > 0); Assert.Equal(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.Equal(sourceFolder, project2.Profiles.First().AssetFolders.First().Path); // Reload the package from the sln var sessionResult = PackageSession.Load(session.SolutionPath); Assert.False(sessionResult.HasErrors); var sessionReload = sessionResult.Session; Assert.Equal(1, sessionReload.LocalPackages.Count()); Assert.Equal(project.Id, sessionReload.LocalPackages.First().Id); Assert.Equal(1, sessionReload.LocalPackages.First().Profiles.Count); var sharedProfileReload = sessionReload.LocalPackages.First().Profiles.First(); Assert.Equal(1, sharedProfileReload.ProjectReferences.Count); Assert.Equal(projectReference, sharedProfileReload.ProjectReferences[0]); }