public static IsMetaFile ( string filePath ) : bool | ||
filePath | string | |
return | bool |
public static void RemoveBundleSettings(string nodePath) { EditorUtility.DisplayProgressBar("AssetBundleGraph unbundlize all resources...", nodePath, 0); var filePathsInFolder = FileUtility.FilePathsInFolder(nodePath); foreach (var filePath in filePathsInFolder) { if (FileUtility.IsMetaFile(filePath)) { continue; } if (FileUtility.ContainsHiddenFiles(filePath)) { continue; } var assetImporter = AssetImporter.GetAtPath(filePath); // assetImporter is null when the asset is not accepted by Unity. // e.g. file.my_new_extension is ignored by Unity. if (assetImporter == null) { continue; } if (assetImporter.GetType() == typeof(UnityEditor.MonoImporter)) { continue; } assetImporter.assetBundleName = string.Empty; } EditorUtility.ClearProgressBar(); }
/** * returns file paths which are located in the folder. * * this method is main point for supporting path format of cross platform. * * Usually Unity Editor uses '/' as folder delimter. * * e.g. * Application.dataPath returns * C:/somewhere/projectPath/Assets @ Windows. * or * /somewhere/projectPath/Assets @ Mac, Linux. * * * but "Directory.GetFiles(localFolderPath + "/")" method returns different formatted path by platform. * * @ Windows: * localFolderPath + / + somewhere\folder\file.extention * * @ Mac/Linux: * localFolderPath + / + somewhere/folder/file.extention * * the problem is, "Directory.GetFiles" returns mixed format path of files @ Windows. * this is the point of failure. * * this method replaces folder delimiters to '/'. */ public static List <string> FilePathsInFolderOnly1Level(string localFolderPath) { // change platform-depends folder delimiter -> '/' var filePaths = ConvertSeparater(Directory.GetFiles(localFolderPath) .Where(path => !(Path.GetFileName(path).StartsWith(AssetBundleGraphSettings.DOTSTART_HIDDEN_FILE_HEADSTRING))) .ToList()); if (AssetBundleGraphSettings.IGNORE_META) { filePaths = filePaths.Where(path => !FileUtility.IsMetaFile(path)).ToList(); } return(filePaths); }
// Get files under given path public static List <string> GetFilePathsInFolder(string folderPath, bool includeHidden = false, bool includeMeta = !AssetBundleGraphSettings.IGNORE_META) { var filePaths = Directory.GetFiles(folderPath).Select(p => p); if (!includeHidden) { filePaths = filePaths.Where(path => !(Path.GetFileName(path).StartsWith(AssetBundleGraphSettings.DOTSTART_HIDDEN_FILE_HEADSTRING))); } if (!includeMeta) { filePaths = filePaths.Where(path => !FileUtility.IsMetaFile(path)); } // Directory.GetFiles() returns platform dependent delimiter, so make sure replace with "/" if (Path.DirectorySeparatorChar != AssetBundleGraphSettings.UNITY_FOLDER_SEPARATOR) { filePaths = filePaths.Select(filePath => filePath.Replace(Path.DirectorySeparatorChar.ToString(), AssetBundleGraphSettings.UNITY_FOLDER_SEPARATOR.ToString())); } return(filePaths.ToList()); }
public void Run(string nodeName, string nodeId, string connectionIdToNextNode, Dictionary <string, List <Asset> > groupedSources, List <string> alreadyCached, Action <string, string, Dictionary <string, List <Asset> >, List <string> > Output) { var usedCache = new List <string>(); var invalids = new List <string>(); foreach (var sources in groupedSources.Values) { foreach (var source in sources) { if (string.IsNullOrEmpty(source.importFrom)) { invalids.Add(source.absoluteAssetPath); } } } if (invalids.Any()) { throw new NodeException(string.Join(", ", invalids.ToArray()) + " are not imported yet. These assets need to be imported before prefabricated.", nodeId); } var recommendedPrefabOutputDirectoryPath = FileUtility.PathCombine(AssetBundleGraphSettings.PREFABRICATOR_CACHE_PLACE, nodeId, SystemDataUtility.GetCurrentPlatformKey()); var outputDict = new Dictionary <string, List <Asset> >(); var cachedOrGenerated = new List <string>(); foreach (var groupKey in groupedSources.Keys) { var inputSources = groupedSources[groupKey]; var recommendedPrefabPath = FileUtility.PathCombine(recommendedPrefabOutputDirectoryPath, groupKey); if (!recommendedPrefabPath.EndsWith(AssetBundleGraphSettings.UNITY_FOLDER_SEPARATOR.ToString())) { recommendedPrefabPath = recommendedPrefabPath + AssetBundleGraphSettings.UNITY_FOLDER_SEPARATOR.ToString(); } /* * ready input resource info for execute. not contains cache in this node. */ var assets = new List <DepreacatedAssetInfo>(); foreach (var assetData in inputSources) { var assetName = assetData.fileNameAndExtension; var assetType = assetData.assetType; var assetPath = assetData.importFrom; var assetDatabaseId = assetData.assetDatabaseId; assets.Add(new DepreacatedAssetInfo(assetName, assetType, assetPath, assetDatabaseId)); } // collect generated prefab path. var generated = new List <string>(); var outputSources = new List <Asset>(); /* * Prefabricate(GameObject baseObject, string prefabName, bool forceGenerate) method. */ Func <GameObject, string, bool, string> Prefabricate = (GameObject baseObject, string prefabName, bool forceGenerate) => { var newPrefabOutputPath = Path.Combine(recommendedPrefabPath, prefabName); if (forceGenerate || !SystemDataUtility.IsAllAssetsCachedAndUpdated(inputSources, alreadyCached, newPrefabOutputPath)) { // not cached, create new. UnityEngine.Object prefabFile = PrefabUtility.CreateEmptyPrefab(newPrefabOutputPath); // export prefab data. PrefabUtility.ReplacePrefab(baseObject, prefabFile); // save prefab. AssetDatabase.Refresh(ImportAssetOptions.ImportRecursive); AssetDatabase.SaveAssets(); generated.Add(newPrefabOutputPath); cachedOrGenerated.Add(newPrefabOutputPath); Debug.Log(nodeName + " created new prefab: " + newPrefabOutputPath); } else { // cached. usedCache.Add(newPrefabOutputPath); cachedOrGenerated.Add(newPrefabOutputPath); Debug.Log(nodeName + " used cached prefab: " + newPrefabOutputPath); } isPrefabricateFunctionCalled = true; return(newPrefabOutputPath); }; if (!Directory.Exists(recommendedPrefabPath)) { // create recommended directory. Directory.CreateDirectory(recommendedPrefabPath); } /* * execute inheritee's input method. */ try { CreatePrefab(nodeName, nodeId, groupKey, assets, recommendedPrefabPath, Prefabricate); } catch (Exception e) { Debug.LogError(nodeName + " Error:" + e); throw new NodeException(nodeName + " Error:" + e, nodeId); } if (!isPrefabricateFunctionCalled) { Debug.LogWarning(nodeName + ": Prefabricate delegate was not called. Prefab might not be created properly."); } /* * ready assets-output-data from this node to next output. * it contains "cached" or "generated as prefab" or "else" assets. * output all assets. */ var currentAssetsInThisNode = FileUtility.FilePathsInFolder(recommendedPrefabPath); foreach (var generatedCandidateAssetPath in currentAssetsInThisNode) { /* * candidate is new, regenerated prefab. */ if (generated.Contains(generatedCandidateAssetPath)) { var newAsset = Asset.CreateNewAssetWithImportPathAndStatus( generatedCandidateAssetPath, true, false ); outputSources.Add(newAsset); continue; } /* * candidate is not new prefab. */ var cachedPrefabAsset = Asset.CreateNewAssetWithImportPathAndStatus( generatedCandidateAssetPath, false, false ); outputSources.Add(cachedPrefabAsset); } /* * add current resources to next node's resources. */ outputSources.AddRange(inputSources); outputDict[groupKey] = outputSources; } // delete unused cached prefabs. var unusedCachePaths = alreadyCached.Except(cachedOrGenerated).Where(path => !FileUtility.IsMetaFile(path)).ToList(); foreach (var unusedCachePath in unusedCachePaths) { // unbundlize unused prefabricated cached asset. var assetImporter = AssetImporter.GetAtPath(unusedCachePath); assetImporter.assetBundleName = string.Empty; FileUtility.DeleteFileThenDeleteFolderIfEmpty(unusedCachePath); } Output(nodeId, connectionIdToNextNode, outputDict, usedCache); }
public string BundlizeAssets(string nodeName, string groupkey, List <Asset> sources, string recommendedBundleOutputDir, bool isRun) { var invalids = new List <string>(); foreach (var source in sources) { if (string.IsNullOrEmpty(source.importFrom)) { invalids.Add(source.absoluteAssetPath); } } if (invalids.Any()) { throw new AssetBundleGraphBuildException(nodeName + ": Invalid files to bundle. Following files need to be imported before bundlize: " + string.Join(", ", invalids.ToArray())); } var bundleName = bundleNameTemplate; /* * if contains KEYWORD_WILDCARD, use group identifier to bundlize name. */ if (bundleNameTemplate.Contains(AssetBundleGraphSettings.KEYWORD_WILDCARD)) { var templateHead = bundleNameTemplate.Split(AssetBundleGraphSettings.KEYWORD_WILDCARD)[0]; var templateTail = bundleNameTemplate.Split(AssetBundleGraphSettings.KEYWORD_WILDCARD)[1]; bundleName = (templateHead + groupkey + templateTail + "." + SystemDataUtility.GetCurrentPlatformShortName()).ToLower(); } var bundlePath = FileUtility.PathCombine(recommendedBundleOutputDir, bundleName); for (var i = 0; i < sources.Count; i++) { var source = sources[i]; // if already bundled in this running, avoid changing that name. if (source.isBundled) { continue; } if (isRun) { if (FileUtility.IsMetaFile(source.importFrom)) { continue; } var assetImporter = AssetImporter.GetAtPath(source.importFrom); if (assetImporter == null) { continue; } assetImporter.assetBundleName = bundleName; } // set as this resource is already bundled. sources[i] = Asset.DuplicateAssetWithNewStatus(sources[i], sources[i].isNew, true); } return(bundlePath); }