private void OnAddFolder(object e) { string absoluteFolderPath = ProjectDefinitions.GetAbsolutePath(Path); string newFolderName = "NewFolder"; string newFolderPath = System.IO.Path.Combine(absoluteFolderPath, newFolderName); if (Directory.Exists(newFolderPath)) { bool bFoundName = false; for (int i = 0; i < 1000; i++) { string folderName = newFolderName + i; newFolderPath = System.IO.Path.Combine(absoluteFolderPath, folderName); if (!Directory.Exists(newFolderPath)) { bFoundName = true; break; } } if (!bFoundName) { return; } } Directory.CreateDirectory(newFolderPath); SubDirectories.Add(new CDirectoryEntry(ProjectDefinitions.GetRelativePath(newFolderPath), m_viewModel, this)); }
public bool RenameAsset(CAsset assetToRename, string newName) { lock (m_registryMutex) { if (m_assetFileMap.TryGet(assetToRename.Guid, out string assetPath)) { string oldFullPath = ProjectDefinitions.GetAbsolutePath(assetPath); string newFullPath = Path.GetDirectoryName(oldFullPath) + "/" + newName + assetToRename.GetFileExtension(); if (File.Exists(newFullPath)) { return(false); } string newRelativePath = ProjectDefinitions.GetRelativePath(newFullPath); assetToRename.Name = newName; assetToRename.Path = newRelativePath; m_assetFileMap[assetToRename.Guid] = newRelativePath; if (File.Exists(oldFullPath)) { File.Delete(oldFullPath); SaveAsset(assetToRename); } SaveRegistry(); return(true); } } return(false); }
/// <summary> /// Tries to register the given asset, returns true and the asset if an asset with the same guid or the same path already exists in case AlwaysImport is false /// </summary> /// <typeparam name="T"></typeparam> /// <param name="baseAsset"></param> /// <param name="basePath"></param> /// <param name="existingAsset"></param> /// <param name="bAlwaysImport"></param> /// <returns></returns> public bool RequestRegisterAsset <T>(T baseAsset, string basePath, out T existingAsset, bool bAlwaysImport = false) where T : CAsset, new() { lock (m_registryMutex) { if (m_assetMap.TryGetValue(baseAsset.Guid, out CAsset foundAsset)) { existingAsset = (T)foundAsset; return(true); } basePath = SanitizeAssetPath(basePath); string assetFileName = basePath + baseAsset.Name + baseAsset.GetFileExtension(); if (m_assetFileMap.TryGet(assetFileName, out Guid foundGuid)) { if (!bAlwaysImport) { baseAsset.Guid = foundGuid; existingAsset = GetAsset <T>(foundGuid); return(true); } if (FileUtilities.GetNextAvailableAssetFile(assetFileName, m_assetFileMap.ValueToKey, out string foundFileName)) { assetFileName = foundFileName; baseAsset.Name = Path.GetFileNameWithoutExtension(foundFileName); } else { throw new Exception("Couldn't find a valid asset filename"); } } existingAsset = null; m_assetFileMap.Add(baseAsset.Guid, assetFileName); baseAsset.Path = assetFileName; m_assetMap.Add(baseAsset.Guid, baseAsset); // todo henning defer this until asset is loaded in case it is not loaded yet if (AutoSaveAssets > 0) { Task.Run(() => { string absoluteFilename = ProjectDefinitions.GetAbsolutePath(assetFileName); FileInfo fileInfo = new FileInfo(absoluteFilename); fileInfo.Directory?.Create(); baseAsset.SaveCustomResources(basePath); FileStream fileStream = new FileStream(absoluteFilename, FileMode.Create); CAssetSerializer.Instance.SerializeToStream(baseAsset, fileStream); SaveRegistry(); }); } else { m_unsavedAssets.Add(baseAsset); } } return(false); }
internal override void RemoveCustomResources() { base.RemoveCustomResources(); string imagePath = ProjectDefinitions.GetAbsolutePath(DDSImagePath); if (File.Exists(imagePath)) { File.Delete(imagePath); } }
public void SaveRegistry() { lock (m_registryMutex) { string json = CAssetSerializer.Instance.Serialize(m_assetFileMap.KeyToValue); string filename = ProjectDefinitions.GetAbsolutePath(REGISTRY_FILEPATH); FileInfo fileInfo = new FileInfo(filename); fileInfo.Directory?.Create(); File.WriteAllText(filename, json); } }
public void UpdateSubDirectories() { SubDirectories.Clear(); string absolutePath = ProjectDefinitions.GetAbsolutePath(Path); var subDirectories = Directory.GetDirectories(absolutePath); foreach (string subDirectory in subDirectories) { SubDirectories.Add(new CDirectoryEntry(ProjectDefinitions.GetRelativePath(subDirectory), m_viewModel, this)); } }
public override bool LoadCustomResources() { string absolutePath = ProjectDefinitions.GetAbsolutePath(DDSImagePath); if (File.Exists(absolutePath)) { ImageSurface = Surface.LoadFromFile(absolutePath); ImageSurface.FlipVertically(); return(true); } return(true); }
public override void SaveCustomResources(string directory) { DDSImagePath = directory + Name + ".dds"; using (Compressor compressor = new Compressor()) { compressor.Input.GenerateMipmaps = false; compressor.Input.SetData(ImageSurface); compressor.Compression.Format = CompressionFormat.DXT1a; compressor.Compression.SetBGRAPixelFormat(); compressor.Process(ProjectDefinitions.GetAbsolutePath(DDSImagePath)); compressor.Dispose(); } }
private CAsset DeserializeAsset(string filePath) { FileStream fileStream = new FileStream(ProjectDefinitions.GetAbsolutePath(filePath), FileMode.Open); CAsset loadedAsset = (CAsset)CAssetSerializer.Instance.DeserializeFromStream(fileStream); loadedAsset.Path = filePath; if (loadedAsset.LoadCustomResources()) { loadedAsset.LoadFinished(); } return(loadedAsset); }
internal override void MoveCustomResources(string newFolder) { base.MoveCustomResources(newFolder); newFolder = CAssetRegistry.SanitizeAssetPath(newFolder); string currentImagePath = ProjectDefinitions.GetAbsolutePath(DDSImagePath); string newAbsoluteImagePath = ProjectDefinitions.GetAbsolutePath(newFolder + Name + ".dds"); if (currentImagePath != newAbsoluteImagePath) { if (File.Exists(currentImagePath)) { File.Move(currentImagePath, newAbsoluteImagePath); } DDSImagePath = ProjectDefinitions.GetRelativePath(newAbsoluteImagePath); } }
private void DeserializeAsset <T>(string filePath, T outAsset) where T : CAsset { FileStream fileStream = new FileStream(ProjectDefinitions.GetAbsolutePath(filePath), FileMode.Open); T loadedAsset = CAssetSerializer.Instance.DeserializeFromStream <T>(fileStream); outAsset.Path = filePath; if (loadedAsset.LoadCustomResources()) { outAsset.CopyFrom(loadedAsset); outAsset.LoadFinished(); } else { outAsset.CopyFrom(loadedAsset); } }
public void RegisterAsset(CAsset asset, string basePath, bool bOverride) { lock (m_registryMutex) { if (!m_assetFileMap.ContainsKey(asset.Guid)) { basePath = SanitizeAssetPath(basePath); string assetFileName = basePath + asset.Name + asset.GetFileExtension(); if (!bOverride) { if (FileUtilities.GetNextAvailableAssetFile(assetFileName, m_assetFileMap.ValueToKey, out string foundFileName)) { assetFileName = foundFileName; asset.Name = Path.GetFileNameWithoutExtension(foundFileName); } else { throw new Exception("Couldn't find a valid asset filename"); } } asset.Path = assetFileName; m_assetFileMap.Add(asset.Guid, assetFileName); m_assetMap.Add(asset.Guid, asset); // todo henning defer this until asset is loaded in case it is not loaded yet if (AutoSaveAssets > 0) { Task.Run(() => { string absoluteFilename = ProjectDefinitions.GetAbsolutePath(assetFileName); FileInfo fileInfo = new FileInfo(absoluteFilename); fileInfo.Directory?.Create(); asset.SaveCustomResources(basePath); FileStream fileStream = new FileStream(absoluteFilename, FileMode.Create); CAssetSerializer.Instance.SerializeToStream(asset, fileStream); SaveRegistry(); }); } else { m_unsavedAssets.Add(asset); } } } }
public static void LoadInstance() { string registryFilename = ProjectDefinitions.GetAbsolutePath(REGISTRY_FILEPATH); if (File.Exists(registryFilename)) { Dictionary <Guid, string> loadedFileMap = CAssetSerializer.Instance.DeserializeObject <Dictionary <Guid, string> >(File.ReadAllText(registryFilename)); // Validate asset entries for their files to exist loadedFileMap = loadedFileMap.Where(pair => File.Exists(ProjectDefinitions.GetAbsolutePath(pair.Value))).ToDictionary(p => p.Key, p => p.Value); Instance.m_assetFileMap = new BiDictionary <Guid, string>(loadedFileMap); } else { Instance = new CAssetRegistry(); } EngineBaseContentLoader.LoadBaseContent(); }
/// <summary> /// Save modifications made to the given asset, only needed if an asset is modified after registration, does not work for non registered assets use RequestRegisterAsset instead /// </summary> /// <param name="assetToSave"></param> public void SaveAsset(CAsset assetToSave) { lock (m_registryMutex) { if (m_assetFileMap.TryGet(assetToSave.Guid, out string assetFilename)) { string absoluteFilename = ProjectDefinitions.GetAbsolutePath(assetFilename); FileInfo fileInfo = new FileInfo(absoluteFilename); string relativeDirectory = ProjectDefinitions.GetRelativePath(fileInfo.DirectoryName) + '/'; assetToSave.SaveCustomResources(relativeDirectory); FileStream fileStream = new FileStream(absoluteFilename, FileMode.Create); CAssetSerializer.Instance.SerializeToStream(assetToSave, fileStream); } else { throw new Exception("Tried to save an asset that is not registered in the registry, make sure to register assets with RequestRegisterAsset"); } } }
public CDirectoryEntry(string directoryPath, CAssetBrowserViewModel viewModel, CDirectoryEntry parent = null) { ParentDirectory = parent; m_viewModel = viewModel; Path = directoryPath; string absolutePath = ProjectDefinitions.GetAbsolutePath(directoryPath); DirectoryInfo dirInfo = new DirectoryInfo(absolutePath); Name = string.IsNullOrWhiteSpace(directoryPath) ? "Project" : dirInfo.Name; EditName = Name; UpdateSubDirectories(); SelectCommand = new CRelayCommand(OnDirectoryClicked); DragEnterCommand = new CRelayCommand(OnDragEnter); DragOverCommand = new CRelayCommand(OnDragOver); DropCommand = new CRelayCommand(OnDrop); AddFolderCommand = new CRelayCommand(OnAddFolder); DeleteFolderCommand = new CRelayCommand(OnDeleteFolder); }
public bool MoveAssetFile(CAsset assetToMove, string targetPath) { lock (m_registryMutex) { if (m_assetFileMap.TryGet(assetToMove.Guid, out string currentPath)) { string assetFileName = Path.GetFileName(currentPath); string targetRelativePath = SanitizeAssetPath(Path.Combine(targetPath, assetFileName)); string absoluteCurrent = ProjectDefinitions.GetAbsolutePath(currentPath); string absoluteTarget = ProjectDefinitions.GetAbsolutePath(targetRelativePath); File.Move(absoluteCurrent, absoluteTarget); m_assetFileMap[assetToMove.Guid] = targetRelativePath; assetToMove.Path = targetRelativePath; assetToMove.MoveCustomResources(targetRelativePath); SaveRegistry(); return(true); } } return(false); }
public bool RemoveFolder(string folderPath) { folderPath = SanitizeAssetPath(folderPath); string absolutePath = ProjectDefinitions.GetAbsolutePath(folderPath); DirectoryInfo folderInfo = new DirectoryInfo(absolutePath); lock (m_registryMutex) { if (folderInfo.Exists) { folderInfo.Delete(true); List <Guid> guidsToRemove = new List <Guid>(); foreach (var guidPathPair in m_assetFileMap.KeyToValue) { if (guidPathPair.Value.StartsWith(folderPath)) { guidsToRemove.Add(guidPathPair.Key); } } foreach (var guid in guidsToRemove) { if (m_assetMap.TryGetValue(guid, out CAsset asset)) { asset.RemoveCustomResources(); m_assetMap.Remove(guid); } m_assetFileMap.Remove(guid); } SaveRegistry(); return(true); } } return(false); }
public VRExpPluginExampleTarget(TargetInfo Target) : base(Target) { DefaultBuildSettings = BuildSettingsVersion.V2; //bUseLoggingInShipping = true; Type = TargetType.Game; ExtraModuleNames.AddRange(new string[] { "VRExpPluginExample" }); //bUsePCHFiles = false; //bUseUnityBuild = false; /* * This is our Steam App ID. * # Define in both server and client targets */ ProjectDefinitions.Add("UE4_PROJECT_STEAMSHIPPINGID=480"); /* * This is used on SetProduct(), and should be the same as your Product Name * under Dedicated Game Server Information in Steamworks * # Define in the Server target */ //ProjectDefinitions.Add("UE4_PROJECT_STEAMPRODUCTNAME=\"MyGame\""); /* * This is used on SetModDir(), and should be the same as your Product Name * under Dedicated Game Server Information in Steamworks * # Define in the client target */ //ProjectDefinitions.Add("UE4_PROJECT_STEAMGAMEDIR=\"MyGame\""); /* * This is what shows up under the game filter in Steam server browsers. * # Define in both server and client targets */ //ProjectDefinitions.Add("UE4_PROJECT_STEAMGAMEDESC=\"My Game\""); }
public bool MoveAssetFolder(string folderPath, string targetPath) { System.Diagnostics.Debug.Assert(!Path.HasExtension(folderPath)); System.Diagnostics.Debug.Assert(!Path.HasExtension(targetPath)); folderPath = SanitizeAssetPath(folderPath); targetPath = SanitizeAssetPath(targetPath); string absoluteCurrent = ProjectDefinitions.GetAbsolutePath(folderPath); if (Directory.Exists(absoluteCurrent)) { DirectoryInfo current = new DirectoryInfo(absoluteCurrent); targetPath = SanitizeAssetPath(targetPath + current.Name); if (targetPath == folderPath) { return(false); } // We first move the assets on disk string absoluteTarget = ProjectDefinitions.GetAbsolutePath(targetPath); lock (m_registryMutex) { try { if (!Directory.Exists(absoluteTarget)) { Directory.Move(absoluteCurrent, absoluteTarget); } else { DirectoryInfo targetInfo = new DirectoryInfo(absoluteTarget); foreach (FileInfo file in targetInfo.EnumerateFiles()) { file.MoveTo(Path.Combine(absoluteTarget, file.Name)); } foreach (DirectoryInfo directory in targetInfo.EnumerateDirectories()) { directory.MoveTo(absoluteTarget); } } } catch (IOException e) { LogUtility.Log("Could not move folder " + e.Message); return(false); } // Afterwards we fix the file paths in the registry List <(Guid, string)> keysToChange = new List <(Guid, string)>(); foreach (var guidPathPair in m_assetFileMap.KeyToValue) { if (guidPathPair.Value.StartsWith(folderPath)) { string newPath = targetPath + guidPathPair.Value.Substring(folderPath.Length); keysToChange.Add((guidPathPair.Key, newPath)); } } foreach (var change in keysToChange) { if (m_assetMap.TryGetValue(change.Item1, out CAsset changedAsset)) { changedAsset.Path = change.Item2; changedAsset.MoveCustomResources(targetPath); } m_assetFileMap[change.Item1] = change.Item2; } SaveRegistry(); return(true); } } return(false); }
public bool RenameFolder(string folderPath, string newFolderName) { System.Diagnostics.Debug.Assert(!Path.HasExtension(folderPath)); lock (m_registryMutex) { // Can't rename project root if (string.IsNullOrWhiteSpace(folderPath)) { return(false); } folderPath = SanitizeAssetPath(folderPath); string absoluteCurrent = ProjectDefinitions.GetAbsolutePath(folderPath); DirectoryInfo dirInfo = new DirectoryInfo(absoluteCurrent); if (dirInfo.Parent != null) { string absoluteTarget = Path.Combine(dirInfo.Parent.FullName, newFolderName); if (!Directory.Exists(absoluteTarget)) { Directory.CreateDirectory(absoluteTarget); } List <FileInfo> movedFiles = new List <FileInfo>(); List <DirectoryInfo> movedFolders = new List <DirectoryInfo>(); try { foreach (FileInfo file in dirInfo.EnumerateFiles()) { file.MoveTo(Path.Combine(absoluteTarget, file.Name)); movedFiles.Add(file); } foreach (DirectoryInfo directory in dirInfo.EnumerateDirectories()) { directory.MoveTo(absoluteTarget); movedFolders.Add(directory); } } catch (IOException e) { LogUtility.Log("Could not rename folder " + e.Message); // Revert already moved files foreach (FileInfo movedFile in movedFiles) { movedFile.MoveTo(Path.Combine(absoluteCurrent, movedFile.Name)); } foreach (DirectoryInfo movedFolder in movedFolders) { movedFolder.MoveTo(absoluteCurrent); } return(false); } try { dirInfo.Delete(); } catch (IOException) { } string targetPath = SanitizeAssetPath(ProjectDefinitions.GetRelativePath(absoluteTarget)); // Afterwards we fix the file paths in the registry List <(Guid, string)> keysToChange = new List <(Guid, string)>(); foreach (var guidPathPair in m_assetFileMap.KeyToValue) { if (guidPathPair.Value.StartsWith(folderPath)) { string newPath = targetPath + guidPathPair.Value.Substring(folderPath.Length); keysToChange.Add((guidPathPair.Key, newPath)); } } foreach (var change in keysToChange) { if (m_assetMap.TryGetValue(change.Item1, out CAsset changedAsset)) { changedAsset.Path = change.Item2; changedAsset.MoveCustomResources(targetPath); } m_assetFileMap[change.Item1] = change.Item2; } SaveRegistry(); return(true); } return(false); } }
public bool TryGetAsset <T>(Guid assetId, out T outAsset) where T : CAsset { lock (m_registryMutex) { if (m_assetMap.TryGetValue(assetId, out CAsset asset)) { outAsset = (T)asset; return(true); } else if (m_assetFileMap.TryGet(assetId, out string filename)) { T loadedAsset = CAssetSerializer.Instance.DeserializeObject <T>(File.ReadAllText(ProjectDefinitions.GetAbsolutePath(filename))); m_assetMap.Add(assetId, loadedAsset); if (loadedAsset.LoadCustomResources()) { loadedAsset.LoadFinished(); } outAsset = loadedAsset; return(true); } } outAsset = null; return(false); }