private void RemoveOtherPlatformAndPackageBundleSettings(List <string> nodeIds, string package) { if (!Directory.Exists(AssetGraphSettings.APPLICATIONDATAPATH_CACHE_PATH)) { return; } /* * get all cache folder of node from cache path. */ var cachedNodeKindFolderPaths = FileController.FolderPathsInFolder(AssetGraphSettings.APPLICATIONDATAPATH_CACHE_PATH); foreach (var cachedNodeKindFolderPath in cachedNodeKindFolderPaths) { var nodeIdFolderPaths = FileController.FolderPathsInFolder(cachedNodeKindFolderPath); foreach (var nodeIdFolderPath in nodeIdFolderPaths) { var nodeIdFromFolder = nodeIdFolderPath.Split(AssetGraphSettings.UNITY_FOLDER_SEPARATOR).Last(); // remove all bundle settings from unrelated nodes. if (!nodeIds.Contains(nodeIdFromFolder)) { RemoveBundleSettings(nodeIdFolderPath); continue; } // related nodes, contains platform_package folder. // remove all bundle settings from unrelated platforms + packages. var platformFolderPaths = FileController.FolderPathsInFolder(nodeIdFolderPath); foreach (var platformFolderPath in platformFolderPaths) { var platformNameFromFolder = platformFolderPath.Split(AssetGraphSettings.UNITY_FOLDER_SEPARATOR).Last(); if (platformNameFromFolder == GraphStackController.Current_Platform_Package_Folder(package)) { continue; } RemoveBundleSettings(platformFolderPath); } } } }
public void Run(string nodeId, string labelToNext, string package, Dictionary <string, List <InternalAssetData> > groupedSources, List <string> alreadyCached, Action <string, string, Dictionary <string, List <InternalAssetData> >, List <string> > Output) { RemoveOtherPlatformAndPackageBundleSettings(relatedNodeIds, package); var recommendedBundleOutputDirSource = FileController.PathCombine(AssetGraphSettings.BUNDLEBUILDER_CACHE_PLACE, nodeId); var recommendedBundleOutputDir = FileController.PathCombine(recommendedBundleOutputDirSource, GraphStackController.Current_Platform_Package_Folder(package)); if (!Directory.Exists(recommendedBundleOutputDir)) { Directory.CreateDirectory(recommendedBundleOutputDir); } /* * merge multi group into ["0"] group. */ var intendedAssetNames = new List <string>(); foreach (var groupKey in groupedSources.Keys) { var internalAssetsOfCurrentGroup = groupedSources[groupKey]; foreach (var internalAsset in internalAssetsOfCurrentGroup) { intendedAssetNames.Add(internalAsset.fileNameAndExtension); intendedAssetNames.Add(internalAsset.fileNameAndExtension + AssetGraphSettings.MANIFEST_FOOTER); } } /* * platform's bundle & manifest. * e.g. iOS & iOS.manifest. */ var currentPlatform_Package_BundleFile = GraphStackController.Current_Platform_Package_Folder(package); var currentPlatform_Package_BundleFileManifest = currentPlatform_Package_BundleFile + AssetGraphSettings.MANIFEST_FOOTER; intendedAssetNames.Add(currentPlatform_Package_BundleFile); intendedAssetNames.Add(currentPlatform_Package_BundleFileManifest); /* * delete not intended assets. */ foreach (var alreadyCachedPath in alreadyCached) { var cachedFileName = Path.GetFileName(alreadyCachedPath); if (intendedAssetNames.Contains(cachedFileName)) { continue; } File.Delete(alreadyCachedPath); } var assetBundleOptions = BuildAssetBundleOptions.None; foreach (var enabled in bundleOptions) { switch (enabled) { case "Uncompressed AssetBundle": { assetBundleOptions = assetBundleOptions | BuildAssetBundleOptions.UncompressedAssetBundle; break; } case "Disable Write TypeTree": { assetBundleOptions = assetBundleOptions | BuildAssetBundleOptions.DisableWriteTypeTree; break; } case "Deterministic AssetBundle": { assetBundleOptions = assetBundleOptions | BuildAssetBundleOptions.DeterministicAssetBundle; break; } case "Force Rebuild AssetBundle": { assetBundleOptions = assetBundleOptions | BuildAssetBundleOptions.ForceRebuildAssetBundle; break; } case "Ignore TypeTree Changes": { assetBundleOptions = assetBundleOptions | BuildAssetBundleOptions.IgnoreTypeTreeChanges; break; } case "Append Hash To AssetBundle Name": { assetBundleOptions = assetBundleOptions | BuildAssetBundleOptions.AppendHashToAssetBundleName; break; } } } BuildPipeline.BuildAssetBundles(recommendedBundleOutputDir, assetBundleOptions, EditorUserBuildSettings.activeBuildTarget); /* * check assumed bundlized resources and actual generated assetbunles. * * "assuned bundlized resources info from bundlizer" are contained by "actual bundlized resources". */ var outputDict = new Dictionary <string, List <InternalAssetData> >(); var outputSources = new List <InternalAssetData>(); var newAssetPaths = new List <string>(); var generatedAssetBundlePaths = FileController.FilePathsInFolder(recommendedBundleOutputDir); foreach (var newAssetPath in generatedAssetBundlePaths) { newAssetPaths.Add(newAssetPath); var newAssetData = InternalAssetData.InternalAssetDataGeneratedByBundleBuilder(newAssetPath); outputSources.Add(newAssetData); } // compare, erase & notice. var containedAssetBundles = new List <string>(); // collect intended output. foreach (var generatedAssetPath in newAssetPaths) { var generatedAssetName = Path.GetFileName(generatedAssetPath); // collect intended assetBundle & assetBundleManifest file. foreach (var bundledName in intendedAssetNames) { if (generatedAssetName == bundledName) { containedAssetBundles.Add(generatedAssetPath); continue; } var bundleManifestName = bundledName + AssetGraphSettings.MANIFEST_FOOTER; if (generatedAssetName == bundleManifestName) { containedAssetBundles.Add(generatedAssetPath); continue; } } } var diffs = newAssetPaths.Except(containedAssetBundles); foreach (var diff in diffs) { Debug.LogWarning("bundleBuilder:AssetBundle:" + diff + " is not intended bundle. please check if unnecessary importer or prefabricator node is exists in graph."); } outputDict["0"] = outputSources; var usedCache = new List <string>(alreadyCached); Output(nodeId, labelToNext, outputDict, usedCache); }
public void Run(string nodeId, string labelToNext, string package, Dictionary <string, List <InternalAssetData> > groupedSources, List <string> alreadyCached, Action <string, string, Dictionary <string, List <InternalAssetData> >, List <string> > Output) { var usedCache = new List <string>(); var outputDict = new Dictionary <string, List <InternalAssetData> >(); var targetDirectoryPath = FileController.PathCombine(AssetGraphSettings.IMPORTER_CACHE_PLACE, nodeId, GraphStackController.Current_Platform_Package_Folder(package)); foreach (var groupKey in groupedSources.Keys) { var inputSources = groupedSources[groupKey]; /* * ready import resources from outside of Unity to inside of Unity. */ InternalImporter.Attach(this); foreach (var inputSource in inputSources) { var absoluteFilePath = inputSource.absoluteSourcePath; var pathUnderSourceBase = inputSource.pathUnderSourceBase; var targetFilePath = FileController.PathCombine(targetDirectoryPath, pathUnderSourceBase); if (GraphStackController.IsCached(inputSource, alreadyCached, targetFilePath)) { usedCache.Add(targetFilePath); continue; } try { /* * copy files into local. */ FileController.CopyFileFromGlobalToLocal(absoluteFilePath, targetFilePath); } catch (Exception e) { Debug.LogError("Importer:" + this + " error:" + e); } } AssetDatabase.Refresh(ImportAssetOptions.ImportRecursive); InternalImporter.Detach(); // get files, which are already assets. var localFilePathsAfterImport = FileController.FilePathsInFolder(targetDirectoryPath); var localFilePathsWithoutTargetDirectoryPath = localFilePathsAfterImport.Select(path => InternalAssetData.GetPathWithoutBasePath(path, targetDirectoryPath)).ToList(); var outputSources = new List <InternalAssetData>(); // generate matching between source and imported assets. foreach (var localFilePathWithoutTargetDirectoryPath in localFilePathsWithoutTargetDirectoryPath) { foreach (var inputtedSourceCandidate in inputSources) { var pathsUnderSourceBase = inputtedSourceCandidate.pathUnderSourceBase; if (localFilePathWithoutTargetDirectoryPath == pathsUnderSourceBase) { var localFilePathWithTargetDirectoryPath = InternalAssetData.GetPathWithBasePath(localFilePathWithoutTargetDirectoryPath, targetDirectoryPath); var newInternalAssetData = InternalAssetData.InternalAssetDataByImporter( inputtedSourceCandidate.traceId, inputtedSourceCandidate.absoluteSourcePath, // /SOMEWHERE_OUTSIDE_OF_UNITY/~ inputtedSourceCandidate.sourceBasePath, // /SOMEWHERE_OUTSIDE_OF_UNITY/ inputtedSourceCandidate.fileNameAndExtension, // A.png inputtedSourceCandidate.pathUnderSourceBase, // (Temp/Imported/nodeId/)~ localFilePathWithTargetDirectoryPath, // Assets/~ AssetDatabase.AssetPathToGUID(localFilePathWithTargetDirectoryPath), AssetGraphInternalFunctions.GetAssetType(localFilePathWithTargetDirectoryPath) ); outputSources.Add(newInternalAssetData); } } } /* * check if new Assets are generated, trace it. */ var assetPathsWhichAreAlreadyTraced = outputSources.Select(path => path.pathUnderSourceBase).ToList(); var assetPathsWhichAreNotTraced = localFilePathsWithoutTargetDirectoryPath.Except(assetPathsWhichAreAlreadyTraced); foreach (var newAssetPath in assetPathsWhichAreNotTraced) { var basePathWithNewAssetPath = InternalAssetData.GetPathWithBasePath(newAssetPath, targetDirectoryPath); if (alreadyCached.Contains(basePathWithNewAssetPath)) { var newInternalAssetData = InternalAssetData.InternalAssetDataGeneratedByImporterOrPrefabricator( basePathWithNewAssetPath, AssetDatabase.AssetPathToGUID(basePathWithNewAssetPath), AssetGraphInternalFunctions.GetAssetType(basePathWithNewAssetPath), false ); outputSources.Add(newInternalAssetData); } else { var newInternalAssetData = InternalAssetData.InternalAssetDataGeneratedByImporterOrPrefabricator( basePathWithNewAssetPath, AssetDatabase.AssetPathToGUID(basePathWithNewAssetPath), AssetGraphInternalFunctions.GetAssetType(basePathWithNewAssetPath), true ); outputSources.Add(newInternalAssetData); } } outputDict[groupKey] = outputSources; } Output(nodeId, labelToNext, outputDict, usedCache); }
public void Run(string nodeId, string labelToNext, string package, Dictionary <string, List <InternalAssetData> > groupedSources, List <string> alreadyCached, Action <string, string, Dictionary <string, List <InternalAssetData> >, List <string> > Output) { var usedCache = new List <string>(); var outputDict = new Dictionary <string, List <InternalAssetData> >(); // caution if import setting file is exists already or not. var samplingDirectoryPath = FileController.PathCombine(AssetGraphSettings.IMPORTER_SAMPLING_PLACE, nodeId, importerPackage); var sampleAssetPath = string.Empty; ValidateImportSample(samplingDirectoryPath, (string noSampleFolder) => { Debug.LogWarning("importer:" + noSampleFolder); }, (string noSampleFile) => { throw new Exception("importer error:" + noSampleFile); }, (string samplePath) => { Debug.Log("using import setting:" + samplePath); sampleAssetPath = samplePath; }, (string tooManysample) => { throw new Exception("importer error:" + tooManysample); } ); // ready. AssetDatabase.Refresh(ImportAssetOptions.ImportRecursive); // construct import path from package info. // importer's package is complicated. // 1. importer uses their own package informatiom. // 2. but imported assets are located at platform-package combined path.(same as other node.) // this is comes from the spec: importer node contains platform settings in themselves. var nodeDirectoryPath = FileController.PathCombine(AssetGraphSettings.IMPORTER_CACHE_PLACE, nodeId, GraphStackController.Current_Platform_Package_Folder(package)); // shrink group to 1 group. if (1 < groupedSources.Keys.Count) { Debug.LogWarning("importer shrinking group to \"" + groupedSources.Keys.ToList()[0] + "\" forcely."); } var inputSources = new List <InternalAssetData>(); foreach (var groupKey in groupedSources.Keys) { inputSources.AddRange(groupedSources[groupKey]); } var oldGeneratedRecord = GraphStackController.LoadImporterRecord(nodeId, package); var oldRemainGeneratedAssetDict = new Dictionary <string, List <string> >(); var newGeneratedAssetDict = new Dictionary <string, List <string> >(); /** * delete unnecessary cache from node. */ { var latestInputImportAssumePaths = inputSources.Select(latestImportAsset => FileController.PathCombine(nodeDirectoryPath, latestImportAsset.pathUnderSourceBase)).ToList(); var oldGeneratedRecordPaths = oldGeneratedRecord.Keys.ToList(); var notExistInLatestButRecordedPaths = oldGeneratedRecordPaths.Except(latestInputImportAssumePaths); foreach (var shouldDeleteCachePath in notExistInLatestButRecordedPaths) { var shouldDetelePaths = oldGeneratedRecord[shouldDeleteCachePath]; foreach (var deletingCachePath in shouldDetelePaths) { // unbundlize unused imported cached asset. var assetImporter = AssetImporter.GetAtPath(deletingCachePath); assetImporter.assetBundleName = string.Empty; FileController.DeleteFileThenDeleteFolderIfEmpty(deletingCachePath); } } } /* * copy all sources from outside to inside of Unity. * apply importSetting to new file. */ { var samplingAssetImporter = AssetImporter.GetAtPath(sampleAssetPath); InternalSamplingImportAdopter.Attach(samplingAssetImporter); { var alreadyImported = new List <string>(); var ignoredResource = new List <string>(); foreach (var inputSource in inputSources) { // non absoluteSoucePath -> not imported. generated one. or else. if (string.IsNullOrEmpty(inputSource.absoluteSourcePath)) { if (!string.IsNullOrEmpty(inputSource.importedPath)) { alreadyImported.Add(inputSource.importedPath); continue; } // already imported. should ignore. ignoredResource.Add(inputSource.fileNameAndExtension); continue; } // construct imported path. var pathUnderSourceBase = inputSource.pathUnderSourceBase; var targetFilePath = FileController.PathCombine(nodeDirectoryPath, pathUnderSourceBase); // skip if cached. if (GraphStackController.IsCached(inputSource, alreadyCached, targetFilePath)) { var alreadyImportedPathAndGeneratedPaths = oldGeneratedRecord[targetFilePath]; // continue using generated info. oldRemainGeneratedAssetDict[targetFilePath] = oldGeneratedRecord[targetFilePath]; usedCache.AddRange(alreadyImportedPathAndGeneratedPaths); continue; } var before = FileController.FilePathsOfFile(targetFilePath); /* * copy files into local. */ var absoluteFilePath = inputSource.absoluteSourcePath; FileController.CopyFileFromGlobalToLocal(absoluteFilePath, targetFilePath); AssetDatabase.Refresh(ImportAssetOptions.ImportRecursive); var after = FileController.FilePathsOfFile(targetFilePath); /* * record relationship of imported file & generated files. */ var diff = after.Except(before).Where(path => !GraphStackController.IsMetaFile(path)).ToList(); newGeneratedAssetDict[targetFilePath] = diff; } if (alreadyImported.Any()) { Debug.LogError("importer:" + string.Join(", ", alreadyImported.ToArray()) + " are already imported."); } if (ignoredResource.Any()) { Debug.LogError("importer:" + string.Join(", ", ignoredResource.ToArray()) + " are ignored."); } } InternalSamplingImportAdopter.Detach(); } /* * input sequence is over. */ // get files, which are imported or cached assets. var localFilePathsAfterImport = FileController.FilePathsInFolder(nodeDirectoryPath); // modify to local path. var localFilePathsWithoutNodeDirectoryPath = localFilePathsAfterImport.Select(path => InternalAssetData.GetPathWithoutBasePath(path, nodeDirectoryPath)).ToList(); var outputSources = new List <InternalAssetData>(); /* * treat all assets inside node. */ foreach (var newAssetPath in localFilePathsWithoutNodeDirectoryPath) { var basePathWithNewAssetPath = InternalAssetData.GetPathWithBasePath(newAssetPath, nodeDirectoryPath); if (usedCache.Contains(basePathWithNewAssetPath)) { // already cached, not new. var newInternalAssetData = InternalAssetData.InternalAssetDataGeneratedByImporterOrPrefabricator( basePathWithNewAssetPath, AssetDatabase.AssetPathToGUID(basePathWithNewAssetPath), AssetGraphInternalFunctions.GetAssetType(basePathWithNewAssetPath), false ); outputSources.Add(newInternalAssetData); } else { // now cached. new resource. var newInternalAssetData = InternalAssetData.InternalAssetDataGeneratedByImporterOrPrefabricator( basePathWithNewAssetPath, AssetDatabase.AssetPathToGUID(basePathWithNewAssetPath), AssetGraphInternalFunctions.GetAssetType(basePathWithNewAssetPath), true ); outputSources.Add(newInternalAssetData); } } outputDict[groupedSources.Keys.ToList()[0]] = outputSources; /* * merge old remains record & new generated record. */ { var newAndOldGeneratedAssetDict = new Dictionary <string, List <string> >(); foreach (var oldRemainGeneratedAssetPath in oldRemainGeneratedAssetDict.Keys) { newAndOldGeneratedAssetDict[oldRemainGeneratedAssetPath] = oldRemainGeneratedAssetDict[oldRemainGeneratedAssetPath]; } foreach (var newGeneratedAssetPath in newGeneratedAssetDict.Keys) { newAndOldGeneratedAssetDict[newGeneratedAssetPath] = newGeneratedAssetDict[newGeneratedAssetPath]; } GraphStackController.UpdateImporterRecord(nodeId, package, newAndOldGeneratedAssetDict); } Output(nodeId, labelToNext, outputDict, usedCache); }
public void _4_0_RunThenCachedGUI() { GraphStackController.CleanCache(); var cacheDict = new Dictionary <string, List <string> >(); var dataPath = Path.Combine(Application.dataPath, "AssetGraphTest/Editor/TestData"); var graphDataPath = Path.Combine(dataPath, "_4_0_RunThenCachedGUI.json"); // load var dataStr = string.Empty; using (var sr = new StreamReader(graphDataPath)) { dataStr = sr.ReadToEnd(); } var graphDict = Json.Deserialize(dataStr) as Dictionary <string, object>; // get cached asset dictionary. var createdDataDict = new Dictionary <string, List <string> >(); Action act = () => { var EndpointNodeIdsAndNodeDatasAndConnectionDatas = GraphStackController.SerializeNodeRoute(graphDict, string.Empty); var endpointNodeIds = EndpointNodeIdsAndNodeDatasAndConnectionDatas.endpointNodeIds; var nodeDatas = EndpointNodeIdsAndNodeDatasAndConnectionDatas.nodeDatas; var connectionDatas = EndpointNodeIdsAndNodeDatasAndConnectionDatas.connectionDatas; var resultDict = new Dictionary <string, Dictionary <string, List <InternalAssetData> > >(); foreach (var endNodeId in endpointNodeIds) { GraphStackController.RunSerializedRoute(endNodeId, nodeDatas, connectionDatas, resultDict, cacheDict, string.Empty); } /* * create first data result. */ foreach (var node in nodeDatas) { var nodeId = node.nodeId; var nodeKind = node.nodeKind; var cachedDataPaths = GraphStackController.GetCachedDataByNodeKind(nodeKind, nodeId, string.Empty); createdDataDict[nodeId] = cachedDataPaths; } }; act(); // reset cacheDict for retake. cacheDict = new Dictionary <string, List <string> >(); act(); /* * check results. */ foreach (var nodeId in createdDataDict.Keys) { if (!cacheDict.Keys.Contains(nodeId)) { if (nodeId == "TestExporter") { continue; } Debug.LogError("cacheDict did not contained:" + nodeId); } } foreach (var nodeId in cacheDict.Keys) { if (!createdDataDict.Keys.Contains(nodeId)) { Debug.LogError("createdDataDict did not contained:" + nodeId); } } foreach (var key in createdDataDict.Keys) { if (!cacheDict.ContainsKey(key)) { continue; } var basePaths = createdDataDict[key]; var targetPaths = cacheDict[key]; foreach (var basePath in basePaths) { // ignore meta files. if (GraphStackController.IsMetaFile(basePath)) { continue; } // avoid sub-creating assets. sub-creating assets never appear as cached. if (basePath.StartsWith("Assets/AssetGraph/Cache/Imported/Testimporter1/" + GraphStackController.Current_Platform_Package_Folder(string.Empty) + "/models/ID_0/Materials")) { continue; } if (basePath.StartsWith("Assets/AssetGraph/Cache/Imported/Testimporter1/" + GraphStackController.Current_Platform_Package_Folder(string.Empty) + "/models/ID_1/Materials")) { continue; } if (basePath.StartsWith("Assets/AssetGraph/Cache/Imported/Testimporter1/" + GraphStackController.Current_Platform_Package_Folder(string.Empty) + "/models/ID_2/Materials")) { continue; } if (!targetPaths.Contains(basePath)) { Debug.LogError("contained in result, but not in cached:" + basePath); } } foreach (var targetPath in targetPaths) { // ignore meta files. if (GraphStackController.IsMetaFile(targetPath)) { continue; } if (!basePaths.Contains(targetPath)) { Debug.LogError("contained in cache, but not in result:" + targetPath); } } } }
public void Run(string nodeId, string labelToNext, string package, Dictionary <string, List <InternalAssetData> > groupedSources, List <string> alreadyCached, Action <string, string, Dictionary <string, List <InternalAssetData> >, List <string> > Output) { ValidateBundleNameTemplate( bundleNameTemplate, () => { throw new Exception("no Bundle Name Template set."); } ); var recommendedBundleOutputDir = FileController.PathCombine(AssetGraphSettings.BUNDLIZER_CACHE_PLACE, nodeId, GraphStackController.Current_Platform_Package_Folder(package)); var outputDict = new Dictionary <string, List <InternalAssetData> >(); foreach (var groupKey in groupedSources.Keys) { var inputSources = groupedSources[groupKey]; var reservedBundlePath = BundlizeAssets(package, groupKey, inputSources, recommendedBundleOutputDir, true); if (string.IsNullOrEmpty(reservedBundlePath)) { continue; } var outputSources = new List <InternalAssetData>(); var newAssetData = InternalAssetData.InternalAssetDataGeneratedByBundlizer(reservedBundlePath); outputSources.Add(newAssetData); outputDict[groupKey] = outputSources; } Output(nodeId, labelToNext, outputDict, new List <string>()); /* * generate additional output: * output bundle resources for next node, for generate another AssetBundles with dependency. */ if (outputResource) { Output(nodeId, AssetGraphSettings.BUNDLIZER_RESOURCES_OUTPUTPOINT_LABEL, groupedSources, new List <string>()); } }
public void Run(string nodeId, string labelToNext, string package, Dictionary <string, List <InternalAssetData> > groupedSources, List <string> alreadyCached, Action <string, string, Dictionary <string, List <InternalAssetData> >, 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.importedPath)) { invalids.Add(source.pathUnderSourceBase); } } } if (invalids.Any()) { throw new Exception("prefabricator:" + string.Join(", ", invalids.ToArray()) + " are not imported yet, should import before prefabricate."); } var recommendedPrefabOutputDirectoryPath = FileController.PathCombine(AssetGraphSettings.PREFABRICATOR_CACHE_PLACE, nodeId, GraphStackController.Current_Platform_Package_Folder(package)); var outputDict = new Dictionary <string, List <InternalAssetData> >(); var cachedOrGenerated = new List <string>(); foreach (var groupKey in groupedSources.Keys) { var inputSources = groupedSources[groupKey]; var recommendedPrefabPath = FileController.PathCombine(recommendedPrefabOutputDirectoryPath, groupKey); if (!recommendedPrefabPath.EndsWith(AssetGraphSettings.UNITY_FOLDER_SEPARATOR.ToString())) { recommendedPrefabPath = recommendedPrefabPath + AssetGraphSettings.UNITY_FOLDER_SEPARATOR.ToString(); } /* * ready input resource info for execute. not contains cache in this node. */ var assets = new List <AssetInfo>(); foreach (var assetData in inputSources) { var assetName = assetData.fileNameAndExtension; var assetType = assetData.assetType; var assetPath = assetData.importedPath; var assetId = assetData.assetId; assets.Add(new AssetInfo(assetName, assetType, assetPath, assetId)); } // collect generated prefab path. var generated = new List <string>(); var outputSources = new List <InternalAssetData>(); Func <GameObject, string, bool, string> Prefabricate = (GameObject baseObject, string prefabName, bool forceGenerate) => { var newPrefabOutputPath = Path.Combine(recommendedPrefabPath, prefabName); if (forceGenerate || !GraphStackController.IsCachedForEachSource(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("AssetGraph prefab:" + newPrefabOutputPath + " is newly generated."); } else { // cached. usedCache.Add(newPrefabOutputPath); cachedOrGenerated.Add(newPrefabOutputPath); Debug.Log("AssetGraph prefab:" + newPrefabOutputPath + " is already cached. if want to regenerate forcely, set Prefabricate(baseObject, prefabName, true) <- forcely regenerate prefab."); } // set used. PrefabricateIsUsed(); return(newPrefabOutputPath); }; if (!Directory.Exists(recommendedPrefabPath)) { // create recommended directory. Directory.CreateDirectory(recommendedPrefabPath); } /* * execute inheritee's input method. */ try { In(groupKey, assets, recommendedPrefabPath, Prefabricate); } catch (Exception e) { Debug.LogError("Prefabricator:" + this + " error:" + e); } if (!isUsed) { Debug.LogWarning("should use 'Prefabricate' method for create prefab in Prefabricator for cache."); } /* * add assets in this node to next output. * it contains "cached" or "generated as prefab" or "else" assets. * output all assets. */ var currentAssetsInThisNode = FileController.FilePathsInFolder(recommendedPrefabPath); foreach (var newAssetPath in currentAssetsInThisNode) { if (generated.Contains(newAssetPath)) { var newAsset = InternalAssetData.InternalAssetDataGeneratedByImporterOrPrefabricator( newAssetPath, AssetDatabase.AssetPathToGUID(newAssetPath), AssetGraphInternalFunctions.GetAssetType(newAssetPath), true ); outputSources.Add(newAsset); } else { var newAsset = InternalAssetData.InternalAssetDataGeneratedByImporterOrPrefabricator( newAssetPath, AssetDatabase.AssetPathToGUID(newAssetPath), AssetGraphInternalFunctions.GetAssetType(newAssetPath), false ); outputSources.Add(newAsset); } } /* * add current resources to next node's resources. */ foreach (var assetData in inputSources) { var inheritedInternalAssetData = InternalAssetData.InternalAssetDataByImporter( assetData.traceId, assetData.absoluteSourcePath, assetData.sourceBasePath, assetData.fileNameAndExtension, assetData.pathUnderSourceBase, assetData.importedPath, assetData.assetId, assetData.assetType ); outputSources.Add(inheritedInternalAssetData); } outputDict[groupKey] = outputSources; } // delete unused cached prefabs. var unusedCachePaths = alreadyCached.Except(cachedOrGenerated).Where(path => !GraphStackController.IsMetaFile(path)).ToList(); foreach (var unusedCachePath in unusedCachePaths) { // unbundlize unused prefabricated cached asset. var assetImporter = AssetImporter.GetAtPath(unusedCachePath); assetImporter.assetBundleName = string.Empty; FileController.DeleteFileThenDeleteFolderIfEmpty(unusedCachePath); } Output(nodeId, labelToNext, outputDict, usedCache); }
public void Setup(string nodeId, string labelToNext, string package, Dictionary <string, List <InternalAssetData> > groupedSources, List <string> alreadyCached, Action <string, string, Dictionary <string, List <InternalAssetData> >, List <string> > Output) { ValidateBundleNameTemplate( bundleNameTemplate, () => { throw new Exception("no Bundle Name Template set."); } ); var recommendedBundleOutputDir = FileController.PathCombine(AssetGraphSettings.BUNDLIZER_CACHE_PLACE, nodeId, GraphStackController.Current_Platform_Package_Folder(package)); var outputDict = new Dictionary <string, List <InternalAssetData> >(); foreach (var groupKey in groupedSources.Keys) { var inputSources = groupedSources[groupKey]; var reservedBundlePath = BundlizeAssets(package, groupKey, inputSources, recommendedBundleOutputDir, false); if (string.IsNullOrEmpty(reservedBundlePath)) { continue; } var outputSources = new List <InternalAssetData>(); var newAssetData = InternalAssetData.InternalAssetDataGeneratedByBundlizer(reservedBundlePath); outputSources.Add(newAssetData); outputDict[groupKey] = outputSources; } Output(nodeId, labelToNext, outputDict, new List <string>()); }
public void Setup(string nodeId, string labelToNext, Dictionary <string, List <InternalAssetData> > groupedSources, List <string> alreadyCached, Action <string, string, Dictionary <string, List <InternalAssetData> >, List <string> > Output) { var invalids = new List <string>(); foreach (var sources in groupedSources.Values) { foreach (var source in sources) { if (string.IsNullOrEmpty(source.importedPath)) { invalids.Add(source.pathUnderSourceBase); } } } if (invalids.Any()) { throw new Exception("prefabricator:" + string.Join(", ", invalids.ToArray()) + " are not imported yet, should import before prefabricate."); } var recommendedPrefabOutputDirectoryPath = FileController.PathCombine(AssetBundleGraphSettings.PREFABRICATOR_CACHE_PLACE, nodeId, GraphStackController.Current_Platform_Package_Folder()); var outputDict = new Dictionary <string, List <InternalAssetData> >(); foreach (var groupKey in groupedSources.Keys) { var inputSources = groupedSources[groupKey]; var recommendedPrefabPath = FileController.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 <AssetInfo>(); foreach (var assetData in inputSources) { var assetName = assetData.fileNameAndExtension; var assetType = assetData.assetType; var assetPath = assetData.importedPath; var assetId = assetData.assetId; assets.Add(new AssetInfo(assetName, assetType, assetPath, assetId)); } // collect generated prefab path. var generated = new List <string>(); /* * Prefabricate(string prefabName) method. */ Func <string, string> Prefabricate = (string prefabName) => { var newPrefabOutputPath = Path.Combine(recommendedPrefabPath, prefabName); generated.Add(newPrefabOutputPath); // set used. PrefabricateIsUsed(); return(newPrefabOutputPath); }; /* * execute inheritee's input method. */ try { Estimate(groupKey, assets, recommendedPrefabPath, Prefabricate); } catch (Exception e) { Debug.LogError("Prefabricator:" + this + " error:" + e); } if (!isUsed) { Debug.LogWarning("should use 'Prefabricate' method for create prefab in Prefabricator for cache."); } foreach (var generatedPrefabPath in generated) { var newAsset = InternalAssetData.InternalAssetDataGeneratedByImporterOrModifierOrPrefabricator( generatedPrefabPath, string.Empty, // dummy data typeof(string), // dummy data true, // absolutely new in setup. false ); if (!outputDict.ContainsKey(groupKey)) { outputDict[groupKey] = new List <InternalAssetData>(); } outputDict[groupKey].Add(newAsset); } outputDict[groupKey].AddRange(inputSources); } Output(nodeId, labelToNext, outputDict, new List <string>()); }