static void ProcessTree(ObjectTreeNode parent, ArchiveFileInfo file, string[] paths, int index) { string currentPath = paths[index]; if (paths.Length - 1 == index) { var fileNode = new ObjectTreeNode(currentPath); string ext = Utils.GetExtension(currentPath); if (FileImageKeys.Lookup.ContainsKey(ext)) { fileNode.ImageKey = FileImageKeys.Lookup[ext]; } else { fileNode.ImageKey = "File"; } fileNode.Type = ext; fileNode.Size = STMath.GetFileSize(file.GetFileSize()); fileNode.Tag = file; parent.AddChild(fileNode); return; } var node = FindFolderNode(parent, currentPath); if (node == null) { node = new ObjectTreeNode(currentPath); node.ImageKey = "Folder"; parent.AddChild(node); } ProcessTree(node, file, paths, index + 1); }
static ObjectTreeNode LoadModelFormat(IModelFormat modelFormat) { IFileFormat fileFormat = (IFileFormat)modelFormat; var model = modelFormat.ToGeneric(); ObjectTreeNode root = new ObjectTreeNode(fileFormat.FileInfo.FileName) { Tag = modelFormat }; ObjectTreeNode meshFolder = new ObjectTreeNode("Meshes"); ObjectTreeNode textureFolder = new ObjectTreeNode("Textures"); ObjectTreeNode skeletonFolder = new ObjectTreeNode("Skeleton"); foreach (var mesh in model.Meshes) { meshFolder.AddChild(LoadMesh(mesh)); } foreach (var tex in model.Textures) { textureFolder.AddChild(LoadTextureFormat(tex)); } if (model.Skeleton != null) { skeletonFolder.Children.AddRange(model.Skeleton.CreateBoneTree()); } if (meshFolder.ChildCount > 0) { root.AddChild(meshFolder); } if (textureFolder.ChildCount > 0) { root.AddChild(textureFolder); } if (skeletonFolder.ChildCount > 0) { root.AddChild(skeletonFolder); } return(root); }
public ObjectTreeNode CreateTreeHiearchy() { ObjectTreeNode root = new ObjectTreeNode(Name) { Tag = this }; ObjectTreeNode meshFolder = new ObjectTreeNode("Meshes"); ObjectTreeNode textureFolder = new ObjectTreeNode("Textures"); ObjectTreeNode skeletonFolder = new ObjectTreeNode("Skeleton"); root.ImageKey = "Model"; foreach (var mesh in Meshes) { meshFolder.AddChild(LoadMesh(mesh)); } foreach (var tex in Textures) { textureFolder.AddChild(LoadTextureFormat(tex)); } if (Skeleton != null) { skeletonFolder.Children.AddRange(Skeleton.CreateBoneTree()); } if (meshFolder.ChildCount > 0) { root.AddChild(meshFolder); } if (textureFolder.ChildCount > 0) { root.AddChild(textureFolder); } if (skeletonFolder.ChildCount > 0) { root.AddChild(skeletonFolder); } return(root); }
private ObjectTreeNode ReadChunk(ChunkTable.ChunkDataEntry entry) { var subNode = new ObjectTreeNode(entry.ChunkType.ToString() + $"_{entry.ChunkType.ToString("X")}_Flags_{entry.Flags}_OFFSET_{entry.ChunkOffset}_SIZE_{entry.ChunkSize}"); subNode.Tag = entry.Data; foreach (var child in entry.SubData) { subNode.AddChild(ReadChunk(child)); } return(subNode); }
public static ObjectTreeNode OpenFormat(ImageList imageList, IFileFormat fileFormat) { ObjectTreeNode hiearchyNode = null; if (fileFormat is IArchiveFile) { hiearchyNode = LoadArchiveFormat((IArchiveFile)fileFormat); if (fileFormat is ObjectTreeNode) { hiearchyNode.OnBeforeExpand(); foreach (var child in ((ObjectTreeNode)fileFormat).Children) { hiearchyNode.AddChild(child); } } } else if (fileFormat is ObjectTreeNode) { hiearchyNode = (ObjectTreeNode)fileFormat; } else if (fileFormat is ITextureContainer) { hiearchyNode = LoadTextureContainerFormat(imageList, (ITextureContainer)fileFormat); } else if (fileFormat is STGenericTexture) { hiearchyNode = LoadTextureFormat((STGenericTexture)fileFormat); } else if (fileFormat is IModelFormat) { hiearchyNode = LoadModelFormat((IModelFormat)fileFormat); } else if (fileFormat is IModelSceneFormat) { hiearchyNode = LoadModelFormat((IModelSceneFormat)fileFormat); } else { hiearchyNode = new ObjectTreeNode(fileFormat.FileInfo.FileName) { Tag = fileFormat, } }; hiearchyNode.OnBeforeExpand(); if (fileFormat is IArchiveFile && fileFormat is ITextureContainer) { hiearchyNode.Children.AddRange(LoadTextureContainerFormat(imageList, (ITextureContainer)fileFormat).Children); } return(hiearchyNode); }
public static List <ObjectTreeNode> CreateMaterialChunkList(Stream materialStream, Stream lookupStream, List <ModelChunk.MeshInfo> meshes) { List <uint[]> materialPointers = GetLookupPointers(meshes, lookupStream); for (int i = 0; i < meshes.Count; i++) { materialPointers[i] = materialPointers[i].Where(x => x != 0 && x < materialStream.Length).ToArray(); for (int j = 0; j < materialPointers[i].Length; j++) { Console.WriteLine($"pointer_{i} { materialPointers[i][j]}"); } } materialPointers = materialPointers.OrderBy(x => x[0]).ToList(); List <ObjectTreeNode> meshNodes = new List <ObjectTreeNode>(); using (var reader = new FileReader(materialStream, true)) { for (int i = 0; i < meshes.Count; i++) { ObjectTreeNode meshNode = new ObjectTreeNode(); meshNodes.Add(meshNode); uint[] pointers = materialPointers[i]; for (int j = 0; j < pointers.Length; j++) { uint size = 0; if (j + 1 < pointers.Length) { size = pointers[j + 1] - pointers[j]; } else if (i + 1 < meshes.Count) { size = materialPointers[i + 1][0] - pointers[j]; } else { size = (uint)materialStream.Length - pointers[j]; } Console.WriteLine($"pointer {pointers[j]} size {size}"); ObjectTreeNode matNode = new ObjectTreeNode($"Mat_{j}"); matNode.Tag = new SubStream(materialStream, pointers[j], size); meshNode.AddChild(matNode); } } } return(meshNodes); }
static ObjectTreeNode LoadTextureContainerFormat(ImageList imageList, ITextureContainer textureContainer) { IFileFormat fileFormat = (IFileFormat)textureContainer; ObjectTreeNode root = new ObjectTreeNode(fileFormat.FileInfo.FileName); root.Tag = fileFormat; root.ImageKey = "TextureContainer"; foreach (var tex in textureContainer.TextureList) { root.AddChild(LoadTextureFormat(tex)); } return(root); }
private void LoadAnimations() { ObjectTreeNode animFolder = new ObjectTreeNode("Animations"); this.AddChild(animFolder); foreach (var anim in Header.MotionData.Animations) { anim.AnimationNextFrame += OnAnimationNextFrame; animFolder.AddChild(new ObjectTreeNode(anim.Name) { Tag = anim }); } }
public void Load(Stream stream) { _stream = stream; using (var reader = new FileReader(stream, true)) { reader.SetByteOrder(true); reader.SeekBegin(12); if (reader.ReadUInt32() == 0x78340300) { Version = GameVersion.LM3; } } Tag = this; //Parse dictionary if (Version == GameVersion.LM3) { DictFile = new LM3.DICT_Parser(stream); } else { DictFile = new LM2.DICT_Parser(stream); } this.Label = FileInfo.FileName; DictFile.FilePath = FileInfo.FilePath; //Parse seperate data file string dataPath = FileInfo.FilePath.Replace(".dict", ".data"); if (File.Exists(dataPath)) { _dataStream = File.OpenRead(dataPath); DataFile = new DATA_Parser(_dataStream, Version, DictFile); var root = LoadChunkTabe(); Children.AddRange(root.Children); int index = 0; var subNode = new ObjectTreeNode("Data Entries"); AddChild(subNode); foreach (var child in DataFile.Table.DataEntries) { subNode.AddChild(ReadChunk(child)); } } }
private ObjectTreeNode CreateModelNode(Model modelContainer, string fileName, int index, bool isRigged) { var model = modelContainer.Models[index]; var genericModel = model.ToGeneric(); genericModel.Name = $"{fileName}_SubModel{index}"; foreach (var texture in modelContainer.TextureContainer.Textures) { genericModel.Textures.Add(texture); } ObjectTreeNode modelNode = genericModel.CreateTreeHiearchy(); modelNode.Tag = model; if (isRigged) { ObjectTreeNode skeletonFolder = new ObjectTreeNode("Skeleton"); skeletonFolder.Tag = genericModel.Skeleton; modelNode.AddChild(skeletonFolder); } return(modelNode); }
private void LoadTextures() { var textureFolder = new ObjectTreeNode("Textures"); this.AddChild(textureFolder); GenericTextures = new List <STGenericTexture>(); for (int i = 0; i < Header.TextureCount; i++) { var data = Header.Textures[i].ImageData; var name = Header.Textures[i].Name; var info = Header.Textures[i].TextureInfo; var tex = new PartyStudio.HSFTexture(name, info, data); if (Header.Textures[i].HasPaletteData()) { var palette = Header.Textures[i].PaletteData; var format = Decode_Gamecube.PaletteFormats.IA8; if (info.Format == 0x09 || info.Format == 0x0B) { format = Decode_Gamecube.PaletteFormats.RGB565; } if (info.Format == 0x0A) { format = Decode_Gamecube.PaletteFormats.RGB5A3; } ((Toolbox.Core.Imaging.GamecubeSwizzle)tex.Platform).SetPalette(palette, format); // tex.SetPaletteData(palette, Decode_Gamecube.ToGenericPaletteFormat(format)); } textureFolder.AddChild(new ObjectTreeNode(tex.Name) { Tag = tex, ImageKey = "Texture" }); GenericTextures.Add(tex); } }
private void LoadMeshes() { ObjectTreeNode meshesFolder = new ObjectTreeNode("Meshes"); this.AddChild(meshesFolder); foreach (var mesh in Header.Meshes) { Dictionary <int, List <STVertex> > VertexMatMapper = new Dictionary <int, List <STVertex> >(); int index = 0; foreach (var primative in mesh.Primitives) { if (!VertexMatMapper.ContainsKey(primative.MaterialIndex)) { VertexMatMapper.Add(primative.MaterialIndex, new List <STVertex>()); } var vertices = VertexMatMapper[primative.MaterialIndex]; switch (primative.Type) { case PrimitiveType.Triangle: vertices.Add(ToGenericVertex(mesh, primative.Vertices[0], Skeleton)); vertices.Add(ToGenericVertex(mesh, primative.Vertices[1], Skeleton)); vertices.Add(ToGenericVertex(mesh, primative.Vertices[2], Skeleton)); break; case PrimitiveType.Quad: vertices.Add(ToGenericVertex(mesh, primative.Vertices[0], Skeleton)); vertices.Add(ToGenericVertex(mesh, primative.Vertices[1], Skeleton)); vertices.Add(ToGenericVertex(mesh, primative.Vertices[2], Skeleton)); vertices.Add(ToGenericVertex(mesh, primative.Vertices[1], Skeleton)); vertices.Add(ToGenericVertex(mesh, primative.Vertices[3], Skeleton)); vertices.Add(ToGenericVertex(mesh, primative.Vertices[2], Skeleton)); break; case PrimitiveType.TriangleStrip: var verts = new List <STVertex>(); foreach (var dv in primative.Vertices) { verts.Add(ToGenericVertex(mesh, dv, Skeleton)); } verts = ConvertTriStrips(verts); vertices.AddRange(verts); break; } } foreach (var poly in VertexMatMapper) { HSFMesh genericMesh = new HSFMesh(); genericMesh.Name = mesh.Name; GenericMeshes.Add(genericMesh); meshesFolder.AddChild(new ObjectTreeNode(mesh.Name) { Tag = genericMesh, ImageKey = "Mesh", }); int objectIndex = Header.ObjectData.Objects.IndexOf(mesh.ObjectData); if (objectIndex != -1) { var bone = Skeleton.Bones[objectIndex]; genericMesh.ObjectNode = bone; bone.Visible = false; } HSFMaterialWrapper genericMat = new HSFMaterialWrapper(this); STPolygonGroup group = new STPolygonGroup(); group.Material = genericMat; genericMesh.PolygonGroups.Add(group); var matData = Header.Materials[poly.Key].MaterialData; genericMat.Material = Header.Materials[poly.Key]; genericMat.Name = Header.Materials[poly.Key].Name; var pass_flags = matData.AltFlags & HSF_Renderer.PASS_BITS; if (pass_flags != 0 || (matData.TransparencyInverted != 0 && matData.VertexMode == 0)) { genericMesh.IsTransparent = true; group.IsTransparentPass = true; } genericMat.Mesh = mesh; var attributes = Header.Materials[poly.Key].Textures; for (int i = 0; i < attributes.Count; i++) { var attribute = attributes[i].Item2; var texIndex = attribute.TextureIndex; genericMat.Attributes.Add(attribute); group.Material.TextureMaps.Add(new HSFMatTexture(this) { Attribute = attribute, Name = Header.Textures[texIndex].Name, TextureIndex = texIndex, Type = i == 0 ? STTextureType.Diffuse : STTextureType.None, WrapU = ConvertWrapMode(attribute.WrapS), WrapV = ConvertWrapMode(attribute.WrapT), MagFilter = STTextureMagFilter.Linear, MinFilter = STTextureMinFilter.Linear, }); } genericMesh.Vertices.AddRange(poly.Value); genericMesh.Optmize(group); } } }
private ObjectTreeNode LoadChunkTabe() { ObjectTreeNode root = new ObjectTreeNode(); Dictionary <ChunkFileType, ObjectTreeNode> FileContainers = new Dictionary <ChunkFileType, ObjectTreeNode>(); Dictionary <uint, DATA_Parser.FileEntry> animationFiles = new Dictionary <uint, DATA_Parser.FileEntry>(); foreach (var file in DataFile.Files) { if (!animationFiles.ContainsKey(file.Hash)) { animationFiles.Add(file.Hash, file); } if (!GlobalFileList.ContainsKey(file.Hash)) { GlobalFileList.Add(file.Hash, file); } } Dictionary <string, ObjectTreeNode> fileGrouper = new Dictionary <string, ObjectTreeNode>(); foreach (var file in DataFile.Files) { ChunkFileType type = file.ChunkEntry.ChunkType; if (!FileContainers.ContainsKey(type)) { FileContainers.Add(type, new ObjectTreeNode(type.ToString() + $"_{type.ToString("X")}")); root.AddChild(FileContainers[type]); } var folder = FileContainers[file.ChunkEntry.ChunkType]; var fileNode = new ObjectTreeNode(file.Hash.ToString()); fileNode.Tag = file.ChunkEntry.Data; if (type == ChunkFileType.Model) { fileNode = new ModelWrapper(file, DataFile); } if (type == ChunkFileType.AnimationData) { fileNode = new AnimationWrapper(file, DataFile); } if (type == ChunkFileType.Texture) { fileNode = new TextureWrapper(file, DataFile); } if (type == ChunkFileType.Skeleton) { fileNode = new SkeletonWrapper(file, DataFile); } if (type == ChunkFileType.Script) { fileNode = new ScriptWrapper(file, DataFile); } if (type == ChunkFileType.AnimationBundles) { fileNode = new AnimationBundleWrapper(file, DataFile, animationFiles); } //Attempt to group common hashes if (type == ChunkFileType.Model) { fileGrouper.Add(fileNode.Label, fileNode); } if (type != ChunkFileType.Model && fileGrouper.ContainsKey(fileNode.Label)) { ObjectTreeNode tfolder = new ObjectTreeNode(type.ToString()); tfolder.AddChild(fileNode); fileGrouper[fileNode.Label].AddChild(tfolder); } else { folder.AddChild(fileNode); } if (type == ChunkFileType.Model) { ObjectTreeNode chunkList = new ObjectTreeNode("Chunks"); fileNode.AddChild(chunkList); foreach (var child in file.ChunkEntry.SubData) { chunkList.AddChild(ReadChunk(child)); } } else { foreach (var child in file.ChunkEntry.SubData) { fileNode.AddChild(ReadChunk(child)); } } fileNode.Label += $"_({folder.ChildCount})"; if (ExtensionList.ContainsKey(file.ChunkEntry.ChunkType)) { fileNode.Label += ExtensionList[file.ChunkEntry.ChunkType]; } if (Hashing.HashNames.ContainsKey(file.Hash)) { fileNode.Label = Hashing.HashNames[file.Hash]; } } return(root); }
public void Load(Stream stream) { Header = new RSC_Parser(FileInfo.FileName, stream); //Load all the resources foreach (var file in Header.Files) { if (file.Type == RSC_Parser.ResourceType.MapObjectParams) { Scenes.Add(new SceneData(file.FileData)); } if (file.Type == RSC_Parser.ResourceType.TextureContainer) { file.OpenFileFormatOnLoad = true; } } ObjectTreeNode mapFolder = new ObjectTreeNode("Maps"); ObjectTreeNode modelFolder = new ObjectTreeNode("Models"); ObjectTreeNode sceneFolder = new ObjectTreeNode("Scene"); ObjectTreeNode currentModel = null; foreach (var file in Header.Files) { Console.WriteLine($"Reading FILE {file.FileName} {file.Type}"); if (file.Type == RSC_Parser.ResourceType.StaticModel || file.Type == RSC_Parser.ResourceType.RiggedModel) { string fileName = Path.GetFileNameWithoutExtension(file.FileName); var modelContainer = new Model(file.FileData, file.FileName, (uint)file.Type); ObjectTreeNode modelContainerNode = new ObjectTreeNode($"{fileName}"); modelContainerNode.ImageKey = "Model"; modelFolder.AddChild(modelContainerNode); modelContainerNode.Tag = modelContainer; currentModel = modelContainerNode; if (file.Type == RSC_Parser.ResourceType.StaticModel) { currentModel.Tag = modelContainer.Models[0]; } var firstNode = CreateModelNode(modelContainer, fileName, 0, file.Type == RSC_Parser.ResourceType.RiggedModel); foreach (var child in firstNode.Children) { modelContainerNode.AddChild(child); } for (int i = 0; i < modelContainer.Models.Count; i++) { if (i == 0) { continue; } var modelNode = CreateModelNode(modelContainer, fileName, i, file.Type == RSC_Parser.ResourceType.RiggedModel); modelContainerNode.AddChild(modelNode); } if (file.Type == RSC_Parser.ResourceType.RiggedModel) { ObjectTreeNode modelAnimationsFolder = new ObjectTreeNode("Animations"); modelContainerNode.AddChild(modelAnimationsFolder); } } if (file.Type == RSC_Parser.ResourceType.MapModel) { string fileName = Path.GetFileNameWithoutExtension(file.FileName); var model = new MapModel(file.FileData, file.FileName, (uint)file.Type); var genericModel = model.ToGeneric(); genericModel.Name = $"{fileName}"; ObjectTreeNode modelNode = genericModel.CreateTreeHiearchy(); modelNode.Tag = model; modelFolder.AddChild(modelNode); currentModel = modelNode; MapModels.Add(model); } if (file.Type == RSC_Parser.ResourceType.SkeletonAnimation) { var anim = new SkeletalAnim(file.FileData, file.FileName); if (currentModel != null) { var model = ((Model)currentModel.Tag); if (model.SkeletalAnim != null) { continue; } model.SkeletalAnim = anim; model.UpdateSkeleton(); model.UpdateBoneIndices(); Runtime.BonePointSize = 6; /* foreach (var modelNode in currentModel.Children) { * var modelgroup = (ModelGroup)modelNode.Tag; * var nodes = modelgroup.ToGeneric().Skeleton.CreateBoneTree(); * foreach (var node in nodes) * modelNode.Children[1].AddChild(node); * }*/ var animations = anim.ToGeneric(); foreach (var animation in animations) { var animNode = new ObjectTreeNode(animation.Name); animNode.Tag = animation; currentModel.Children[model.Models.Count + 2].AddChild(animNode); } currentModel.Tag = model.Models[0]; currentModel = null; } } if (file.Type == RSC_Parser.ResourceType.LightingData) { string fileName = Path.GetFileName(file.FileName); var lightingData = new LightingData(file.FileData); var lightingNode = new ObjectTreeNode(fileName); lightingNode.Tag = lightingData; for (int i = 0; i < lightingData.Lights.Length; i++) { var light = lightingData.Lights[i]; lightingNode.AddChild(new ObjectTreeNode() { Label = $"Light{i}", Tag = light, }); } this.AddChild(lightingNode); } } if (modelFolder.Children.Count > 0) { this.AddChild(modelFolder); } }
private void LoadSkeleton() { ObjectTreeNode skeletonFolder = new ObjectTreeNode("Skeleton"); this.AddChild(skeletonFolder); for (int i = 0; i < Header.ObjectCount; i++) { var info = Header.ObjectData.Objects[i]; var name = Header.ObjectData.ObjectNames[i]; if (name == string.Empty) { name = $"Object_{i}"; } //Add a dummy bone. Some bone data is set at runtime and uses large random values if (info.ChildrenCount > Header.ObjectCount) { Skeleton.Bones.Add(new HSFBoneWrapper(info, Skeleton) { Name = name, ParentIndex = -1, Position = new Vector3(), Scale = Vector3.One, EulerRotation = new Vector3(), }); } else { Skeleton.Bones.Add(new HSFBoneWrapper(info, Skeleton) { Name = name, ParentIndex = -1, Position = new OpenTK.Vector3( info.BaseTransform.Translate.X, info.BaseTransform.Translate.Y, info.BaseTransform.Translate.Z) * HSF_Renderer.PreviewScale, EulerRotation = new OpenTK.Vector3( MathHelper.DegreesToRadians(info.BaseTransform.Rotate.X), MathHelper.DegreesToRadians(info.BaseTransform.Rotate.Y), MathHelper.DegreesToRadians(info.BaseTransform.Rotate.Z)), Scale = new OpenTK.Vector3( info.BaseTransform.Scale.X == 0 ? 1 : info.BaseTransform.Scale.X, info.BaseTransform.Scale.Y == 0 ? 1 : info.BaseTransform.Scale.Y, info.BaseTransform.Scale.Z == 0 ? 1 : info.BaseTransform.Scale.Z), }); } } for (int i = 0; i < Header.ObjectCount; i++) { if (Header.ObjectData.Objects[i].ChildrenCount > Header.ObjectCount) { Skeleton.Bones[i].ParentIndex = -1; } else { Skeleton.Bones[i].ParentIndex = Header.ObjectData.Objects[i].ParentIndex; } } var boneNodes = Skeleton.CreateBoneTree(); foreach (var bone in boneNodes) { skeletonFolder.AddChild(bone); } Skeleton.PreviewScale = 0.05f; Skeleton.Reset(); Skeleton.Update(); }
public void Serilazed_Details_Object_With_ObjectTreeNode_Exists() { // arrange var scenario = new Scenario { Name = ScenarioName, Description = "a scenario for testing trees in details", Status = "failed" }; // A tree containing most important item types that need to be supported // (same types are allowed for items in tree nodes as for values in Details --> reuse code from // SerializableDictionary!). // Root node with string as item var rootNode = new ObjectTreeNode <object> { Item = "Root" }; rootNode.AddDetail( "detailKey", "Tree nodes can have again details, use same serialization as already tested!"); // node one with object description as item var childWithObject = new ObjectTreeNode <object>(); var objDescription = new ObjectDescription("serviceCall", "AddressWebService.getAdress"); objDescription.AddDetail("justADetail", "just an example"); childWithObject.Item = objDescription; rootNode.AddChild(childWithObject); // node two with object reference as item var childWithObjectRef = new ObjectTreeNode <object>(); var objRef = new ObjectReference("serviceCall", "AddressWebService.getAdress"); childWithObjectRef.Item = objRef; rootNode.AddChild(childWithObjectRef); // node three with List of Strings as item var childWithList = new ObjectTreeNode <IObjectTreeNode <object> >(); var list = new ObjectList <object> { "item1", "item2", "item3" }; childWithList.Item = list; rootNode.AddChild(childWithList); // node four with details as item var childWithDetails = new ObjectTreeNode <object>(); var detailsMap = new Details(); detailsMap.AddDetail("key1", "value1"); detailsMap.AddDetail("key2", "value2"); detailsMap.AddDetail("anyGenericObjectReference", new ObjectReference("serviceCall", "MainDB.getUsers")); detailsMap.AddDetail( "anyGenericObject", new ObjectDescription("configuration", "my_dummy_mocks_configuration.properties")); childWithDetails.Item = detailsMap; rootNode.AddChild(childWithDetails); scenario.AddDetail("exampleTree", rootNode); // act writer.SaveScenario(SerializationUseCase, scenario); writer.Flush(); // assert Assert.IsTrue(File.Exists(docuFiles.GetScenarioFile(BranchName, BuildName, SerializationUseCase, ScenarioName))); scenario.Status = "success"; writer.SaveScenario(SerializationUseCase, scenario); }
public void Serilazed_Details_Object_With_ObjectTreeNode_Exists() { // arrange var scenario = new Scenario { Name = ScenarioName, Description = "a scenario for testing trees in details", Status = "failed" }; // A tree containing most important item types that need to be supported // (same types are allowed for items in tree nodes as for values in Details --> reuse code from // SerializableDictionary!). // Root node with string as item var rootNode = new ObjectTreeNode<object> { Item = "Root" }; rootNode.AddDetail( "detailKey", "Tree nodes can have again details, use same serialization as already tested!"); // node one with object description as item var childWithObject = new ObjectTreeNode<object>(); var objDescription = new ObjectDescription("serviceCall", "AddressWebService.getAdress"); objDescription.AddDetail("justADetail", "just an example"); childWithObject.Item = objDescription; rootNode.AddChild(childWithObject); // node two with object reference as item var childWithObjectRef = new ObjectTreeNode<object>(); var objRef = new ObjectReference("serviceCall", "AddressWebService.getAdress"); childWithObjectRef.Item = objRef; rootNode.AddChild(childWithObjectRef); // node three with List of Strings as item var childWithList = new ObjectTreeNode<IObjectTreeNode<object>>(); var list = new ObjectList<object> { "item1", "item2", "item3" }; childWithList.Item = list; rootNode.AddChild(childWithList); // node four with details as item var childWithDetails = new ObjectTreeNode<object>(); var detailsMap = new Details(); detailsMap.AddDetail("key1", "value1"); detailsMap.AddDetail("key2", "value2"); detailsMap.AddDetail("anyGenericObjectReference", new ObjectReference("serviceCall", "MainDB.getUsers")); detailsMap.AddDetail( "anyGenericObject", new ObjectDescription("configuration", "my_dummy_mocks_configuration.properties")); childWithDetails.Item = detailsMap; rootNode.AddChild(childWithDetails); scenario.AddDetail("exampleTree", rootNode); // act writer.SaveScenario(SerializationUseCase, scenario); writer.Flush(); // assert Assert.IsTrue(File.Exists(docuFiles.GetScenarioFile(BranchName, BuildName, SerializationUseCase, ScenarioName))); scenario.Status = "success"; writer.SaveScenario(SerializationUseCase, scenario); }
private void SelectionChanged(ObjectTreeNode obj) { obj.OnClick(); bool tryUpdateViewport = false; if (Runtime.SelectedBoneIndex != -1) { tryUpdateViewport = true; Runtime.SelectedBoneIndex = -1; } if (obj.Tag is ArchiveFileInfo) { var fileInfo = (ArchiveFileInfo)obj.Tag; if (fileInfo.OpenFileFormatOnLoad) { fileInfo.FileFormat = fileInfo.OpenFile(); } if (fileInfo.FileFormat != null) { var fileNode = ObjectListWrapperLoader.OpenFormat(imgList, fileInfo.FileFormat); obj.Tag = fileInfo.FileFormat; foreach (var child in fileNode.Children) { obj.AddChild(child); } SelectionChanged(obj); return; } ArchiveFilePanel hexEditor = GetActiveEditor <ArchiveFilePanel>(); hexEditor.LoadFile(this, fileInfo); } else if (obj.Tag is STGenericTexture) { var tex = (STGenericTexture)obj.Tag; ImageEditorBase editor = GetActiveEditor <ImageEditorBase>(); editor.LoadProperties(tex.DisplayProperties); editor.LoadImage(tex); } else if (obj.Tag is IPropertyDisplay) { var property = (IPropertyDisplay)obj.Tag; STPropertyGrid editor = GetActiveEditor <STPropertyGrid>(); editor.LoadProperty(property.PropertyDisplay); } else if (obj.Tag is IEditorDisplay) { var property = (IEditorDisplay)obj.Tag; Console.WriteLine($"IEditorDisplay {property}"); var gui = GUIGenerator.Generate(property); gui.Dock = DockStyle.Fill; STPanel editor = GetActiveEditor <STPanel>(); editor.Controls.Clear(); editor.Controls.Add(gui); } else if (obj.Tag is System.IO.Stream) { var stream = (System.IO.Stream)obj.Tag; HexEditor hexEditor = GetActiveEditor <HexEditor>(); hexEditor.LoadData(stream); } else if (obj.Tag is IVideoFormat) { VideoPlayer editor = GetActiveEditor <VideoPlayer>(); editor.LoadVideoFile((IVideoFormat)obj.Tag); } else if (obj.Tag is STGenericMesh) { var mesh = (STGenericMesh)obj.Tag; mesh.SelectMesh?.Invoke(mesh, EventArgs.Empty); if (WorkspacePanel == null) { WorkspacePanel = CreateWorkspacePanel(); } WorkspacePanel workspace = GetActiveEditor <WorkspacePanel>(WorkspacePanel); var meshEditor = workspace.GetActiveEditor <MeshEditor>(); meshEditor.LoadMesh(mesh); workspace.UpdateViewport(); ObjectHiearchy.Focus(); } else if (obj.Tag is STGenericMaterial) { var mat = (STGenericMaterial)obj.Tag; if (WorkspacePanel == null) { WorkspacePanel = CreateWorkspacePanel(); } WorkspacePanel workspace = GetActiveEditor <WorkspacePanel>(WorkspacePanel); var materialEditor = workspace.GetActiveEditor <MaterialEditor>(); materialEditor.LoadMaterial(mat); workspace.UpdateViewport(); } else if (obj.Tag is IModelFormat) { if (WorkspacePanel == null) { WorkspacePanel = CreateWorkspacePanel(); } WorkspacePanel workspace = GetActiveEditor <WorkspacePanel>(WorkspacePanel); workspace.LoadFileFormat((IModelFormat)(obj.Tag)); workspace.UpdateViewport(); } else if (obj.Tag is IModelSceneFormat) { if (WorkspacePanel == null) { WorkspacePanel = CreateWorkspacePanel(); } WorkspacePanel workspace = GetActiveEditor <WorkspacePanel>(WorkspacePanel); workspace.LoadFileFormat((IModelSceneFormat)(obj.Tag)); workspace.UpdateViewport(); } else if (obj.Tag is STAnimation) { if (WorkspacePanel == null) { WorkspacePanel = CreateWorkspacePanel(); } WorkspacePanel workspace = GetActiveEditor <WorkspacePanel>(WorkspacePanel); workspace.LoadFileFormat((STAnimation)(obj.Tag)); workspace.UpdateViewport(); } else if (obj.Tag is STBone) { var bone = (STBone)obj.Tag; Runtime.SelectedBoneIndex = bone.Index; WorkspacePanel.UpdateViewport(); } if (tryUpdateViewport && WorkspacePanel != null) { WorkspacePanel.UpdateViewport(); } // else // GetActiveEditor<STPanel>(); }