public static PrefabInstance CreateFromAssetPath(AssetPath inPath) { GameObject resource = inPath.Load<GameObject>(); GameObject gameObject = GameObject.Instantiate<GameObject>(resource); PrefabInstance prefabInstance = gameObject.GetComponentInChildren<PrefabInstance>(true); if(prefabInstance) { prefabInstance.PrefabSource = inPath; } return prefabInstance; }
public override CompilerMessage[] GetCompilerMessages() { if (!Poll()) { Debug.LogWarning("Compile process is not finished yet. This should not happen."); } if (process == null) { return(new CompilerMessage[0]); } var outputFile = AssetPath.Combine(tempOutputDirectory, assembly.Filename); DumpStreamOutputToLog(outputFile); return(CreateOutputParser().Parse( GetStreamContainingCompilerMessages(), CompilationHadFailure(), assembly.Filename ).ToArray()); }
private string GetBundleNameOfExternalScene(ParsedNode node) { var bundleName = string.Empty; var scenePath = AssetPath.CorrectSlashes(node.ContentsPath); foreach (var sceneExtension in scenesExtensions) { string sceneBundle; if (!sceneToBundleMap.TryGetValue(scenePath + sceneExtension, out sceneBundle)) { continue; } bundleName = sceneBundle; break; } if (string.IsNullOrEmpty(bundleName)) { Console.WriteLine("Warning! Can not find external scene \'{0}\' in \'{1}!\'", scenePath, currentCookingScene); } return(bundleName); }
internal static void WriteContextFiles(string nameSpace) { if (string.IsNullOrEmpty(nameSpace)) { nameSpace = "MyNamespace"; } var filePath = AssetPath.Combine(Application.dataPath, "BasicContext.cs"); using (var writer = new StreamWriter(filePath)) { writer.Write(Template.ContextTemplate, nameSpace); } filePath = AssetPath.Combine(Application.dataPath, "BasicContextProvider.cs"); using (var writer = new StreamWriter(filePath)) { writer.Write(Template.ProviderTemplate, nameSpace); } AssetDatabase.Refresh(); }
internal bool Delete() { if (_aiStorage == null) { return(true); } var path = AssetPath.Combine(AIGeneralSettings.instance.storagePath, string.Concat(_aiStorage.name, ".asset")); if (!AssetDatabase.DeleteAsset(path)) { Debug.LogWarning(this.ToString() + " could not be deleted, path checked: " + path); return(false); } if (UserSettings.instance.autoGenerateNameMap) { AINameMapGenerator.WriteNameMapFile(); } return(true); }
public List <string> Get(string folderToLookForResponseFilesIn) { if (!string.IsNullOrEmpty(folderToLookForResponseFilesIn) && !Path.IsPathRooted(folderToLookForResponseFilesIn)) { folderToLookForResponseFilesIn = AssetPath.Combine(ProjectPath, folderToLookForResponseFilesIn); } var result = new List <string>(); var folderResponseFile = GetCompilerSpecific(folderToLookForResponseFilesIn); if (!string.IsNullOrEmpty(folderResponseFile)) { AddIfNotNull(result, folderResponseFile); } else { AddIfNotNull(result, GetDefaultResponseFiles()); } return(result); }
public ContentPlan BuildPlan() { var library = new TransformerPolicyLibrary(_policies); var combinations = new AssetCombinationCache(); if (_combination != null) { combinations.StoreCombination(_combination.MimeType, _combination); } var pipeline = new AssetFileGraph(); _files.Each(f => { var path = new AssetPath(AssetFileGraph.Application, f.Name, f.Folder); pipeline.AddFile(path, f); }); var planner = new ContentPlanner(combinations, pipeline, library); return(planner.BuildPlanFor(_name)); }
public Document OpenDocument(string path, bool pathIsGlobal = false) { string localPath = path; if (pathIsGlobal) { if (this == Null || !Current.TryGetAssetPath(path, out localPath)) { OpenFileOutsideProjectAttempt(path); return(null); } } localPath = AssetPath.CorrectSlashes(localPath); var doc = Documents.FirstOrDefault(i => i.Path == localPath); if (doc == null) { var tmpFile = AutosaveProcessor.GetTemporalFilePath(localPath); string systemPath; if (GetSystemPath(tmpFile, out systemPath) && TempFileLoadConfirmation.Invoke(localPath)) { doc = new Document(tmpFile); doc.SaveAs(localPath); } else { doc = new Document(localPath); } if (systemPath != null) { File.Delete(systemPath); } documents.Add(doc); } doc.MakeCurrent(); AddRecentDocument(doc.Path); return(doc); }
/// <summary> /// Imports the corresponding asset. /// </summary> public override void Import() { // Create expression data. var expressionData = CubismExpressionData.CreateInstance(ExpressionJson); AssetDatabase.CreateAsset(expressionData, AssetPath.Replace(".exp3.json", ".exp3.asset")); // Add expression data to expression list. var directoryName = Path.GetDirectoryName(AssetPath).ToString(); var modelDir = Path.GetDirectoryName(directoryName).ToString(); var modelName = Path.GetFileName(modelDir).ToString(); var expressionListPath = Path.GetDirectoryName(directoryName).ToString() + "/" + modelName + ".expressionList.asset"; var expressionList = AssetDatabase.LoadAssetAtPath <CubismExpressionList>(expressionListPath); // Create expression list. if (expressionList == null) { expressionList = ScriptableObject.CreateInstance <CubismExpressionList>(); expressionList.CubismExpressionObjects = new CubismExpressionData[0]; AssetDatabase.CreateAsset(expressionList, expressionListPath); } var instanceId = expressionData.GetInstanceID(); var motionIndex = Array.IndexOf(expressionList.CubismExpressionObjects, instanceId); if (motionIndex != -1) { expressionList.CubismExpressionObjects[motionIndex] = expressionData; } else { motionIndex = expressionList.CubismExpressionObjects.Length; Array.Resize(ref expressionList.CubismExpressionObjects, motionIndex + 1); expressionList.CubismExpressionObjects[motionIndex] = expressionData; } EditorUtility.SetDirty(expressionList); }
public static bool ExtractAssetPathOrShowAlert(string filePath, out string assetPath, out string assetType) { string path = AssetPath.CorrectSlashes(filePath); string assetsPath = AssetPath.CorrectSlashes(Core.Project.Current.AssetsDirectory); if (Path.IsPathRooted(path)) { if (!path.StartsWith(assetsPath, StringComparison.CurrentCultureIgnoreCase)) { AlertDialog.Show($"Asset '{filePath}' outside the project directory"); assetPath = null; assetType = null; return(false); } else { path = path.Substring(assetsPath.Length + 1); } } assetPath = Path.ChangeExtension(path, null); assetType = Path.GetExtension(path).ToLower(); return(true); }
void refresh(SpriteDatabase db) { Debug.Log("Refreshing sprite database \"" + db.name + "\""); db.sprites = new List <Sprite>(); string path = AssetDatabase.GetAssetPath(db); path = AssetPath.getAbsolutePath(path); path = path.Replace(Path.GetFileName(path), ""); foreach (var f in FileSearch.search(path, "*")) { var assets = AssetDatabase.LoadAllAssetsAtPath(AssetPath.getRelativePath(f.FullName)); foreach (var a in assets) { Sprite s = a as Sprite; if (s != null) { db.sprites.Add(s); Debug.Log("Find sprite \"" + s.name + "\""); } } } Debug.Log("Sprite database \"" + db.name + "\" refreshed:(" + db.sprites.Count + ")"); }
public static void AddToBundleConfig(string assetFullPath) { if (Path.GetFileName(assetFullPath) == Constant.ASSET_CONFIG_NAME) { ChangeAssetConfigBundleName(assetFullPath); } else { ChangeAssetBundleName(assetFullPath); var assetPath = AssetPath.GetAssetPathFromBundlePath(assetFullPath); var assetConfig = GetAssetConfig(); assetConfig.Add(new AssetInfo() { assetPath = assetPath, assetName = AssetPath.GetAssetName(assetPath), bundleName = AssetPath.GetBundleName(assetPath, assetFullPath, assetConfig.indvAssetPathList), isFromBundle = true }); EditorUtility.SetDirty(assetConfig); } }
static void ChangeAssetBundleName(string assetFullPath) { if (assetFullPath.Contains(Constant.EXTENSION_META)) { return; } var assetSetting = AssetDatabase.LoadAssetAtPath <AssetSetting>(AssetEditorConstant.ASSET_SETTING_PATH); var assetPath = AssetPath.GetAssetPathFromBundlePath(assetFullPath); var assetBundleName = AssetPath.GetBundleName(assetPath, assetFullPath, assetSetting.assetConfig.indvAssetPathList); var assetName = AssetPath.GetAssetName(assetPath); var assetImporter = AssetImporter.GetAtPath(assetFullPath); if (assetImporter.name != assetName || assetImporter.assetBundleName != assetBundleName) { assetImporter.assetBundleName = assetBundleName; assetImporter.name = assetName; EditorUtility.SetDirty(assetImporter); } }
private static string GetPromptImagePath(this GamepadAxis axis, GamepadType type) { if (type == GamepadType.Unknown) { type = GamepadType.Xbox360; } string buttonName; switch (axis) { case GamepadAxis.LeftStickX: case GamepadAxis.LeftStickY: { buttonName = "left_stick"; break; } case GamepadAxis.RightStickX: case GamepadAxis.RightStickY: { buttonName = "right_stick"; break; } default: { buttonName = axis.ToString().ToLowerUnderscored(); break; } } return(AssetPath.Combine( "gui/prompts/" + type.ToString().ToLowerUnderscored(), buttonName + ".png" )); }
public static Texture GetLocalised(string path, Language language, bool filter) { // Try the current language and it's fallbacks bool triedEnglish = false; while (language != null) { var specificPath = AssetPath.Combine( AssetPath.GetDirectoryName(path), AssetPath.GetFileNameWithoutExtension(path) + "_" + language.Code + ".png" ); if (Assets.Assets.Exists <Texture>(specificPath)) { return(Texture.Get(specificPath, filter)); } if (language.Code == "en") { triedEnglish = true; } language = language.Fallback; } if (!triedEnglish) { // Try english var englishPath = AssetPath.Combine( AssetPath.GetDirectoryName(path), AssetPath.GetFileNameWithoutExtension(path) + "_en.png" ); if (Assets.Assets.Exists <Texture>(englishPath)) { return(Texture.Get(englishPath, filter)); } } // Try unlocalised return(Texture.Get(path, filter)); }
protected override void beforeEach() { var assetPath = new AssetPath("scripts/combo1.js"); assetPath.IsBinary().ShouldBeFalse(); theFiles = new AssetFile[] { new AssetFile("script1.js") { FullPath = "1.js" }, new AssetFile("script2.js") { FullPath = "2.js" }, new AssetFile("script3.js") { FullPath = "3.js" }, new AssetFile("script4.js") { FullPath = "4.js" }, }; MockFor <IContentPlanCache>().Stub(x => x.SourceFor(assetPath)) .Return(MockFor <IContentSource>()); MockFor <IContentSource>().Expect(x => x.GetContent(MockFor <IContentPipeline>())) .Return(theContent); MockFor <IContentSource>().Stub(x => x.Files).Return(theFiles); theAction = files => _files = files; wasReturned = ClassUnderTest.Write(assetPath, theAction); }
private bool ChangeNameMapFolder(string proposedFolder) { if (string.Equals(proposedFolder, _nameMapPath, StringComparison.OrdinalIgnoreCase) || !AssetPath.IsProjectPath(proposedFolder)) { return(false); } proposedFolder = AssetPath.ProjectRelativePath(proposedFolder); AssetPath.EnsurePath(proposedFolder); //Move map from current location to new location. if (!string.IsNullOrEmpty(_nameMapPath)) { var existingFile = AssetPath.Combine(AssetPath.GetFullPath(_nameMapPath), NameMapFileName); if (File.Exists(existingFile)) { var oldFilePath = AssetPath.Combine(_nameMapPath, NameMapFileName); var newFilePath = AssetPath.Combine(proposedFolder, NameMapFileName); var msg = AssetDatabase.MoveAsset(oldFilePath, newFilePath); if (!string.IsNullOrEmpty(msg)) { EditorUtility.DisplayDialog("Error Moving Asset", msg, "Ok"); return(false); } else { AssetDatabase.Refresh(); } } } _nameMapPath = proposedFolder; return(true); }
protected virtual void OnSelectClicked() { var current = CoalescedPropertyValue().GetDataflow(); current.Poll(); var value = current.Value; var path = ValueToStringConverter(value.Value); var dlg = new FileDialog { AllowedFileTypes = allowedFileTypes, Mode = FileDialogMode.Open, InitialDirectory = current.GotValue && value.IsDefined && !string.IsNullOrEmpty(path) && TryGetClosestAvailableDirectory( AssetPath.Combine(Project.Current.AssetsDirectory, path), out var dir) ? dir : Directory.Exists(LastOpenedDirectory) ? LastOpenedDirectory : Project.Current.AssetsDirectory }; if (dlg.RunModal()) { SetFilePath(dlg.FileName); LastOpenedDirectory = Path.GetDirectoryName(dlg.FileName); } } }
/// <summary> /// スキルの実行 /// </summary> /// <param name="battleData"></param> public void InvokeSkill(MenkoBattleData battleData, Menko invoker) { Debug.Log("Invoke Skill"); string skillPath = AssetPath.GetSkillPrefabPath(battleData.SkillData.UseSkillID); var skillPrefab = AssetManager.Load <SkillBase>(skillPath).Asset as SkillBase; SkillBase skill = GameObject.Instantiate(skillPrefab); skill.gameObject.SetActive(false); skill.transform.position = invoker.transform.position; skill.transform.SetPosY(0f); var playTask = new SkillPlayTask(manager, invoker, battleData, skill, NextCall); if (currentPlay == null) { manager.MenkoList.StopRigidAll(); currentPlay = playTask; currentPlay.Invoke(); } else { task.Enqueue(playTask); } }
private IEnumerator <Action> ResolveReferences() { _aiReferences = new Dictionary <string, AIReference>(StringComparer.Ordinal); _referencers = new List <SceneOrPrefab>(); //AIs var ais = StoredAIs.AIs.ToArray(); for (int i = 0; i < ais.Length; i++) { if (_cancelled) { yield break; } _progressMessage = string.Format("Processing AI {0}/{1}: {2}", i, ais.Length, ais[i].name); _owner.Repaint(); yield return(() => { var curAI = GetAIReference(ais[i]); for (int j = 0; j < ais.Length; j++) { if (j == i) { continue; } if (ais[j].configuration.Contains(curAI.id)) { var refedBy = GetAIReference(ais[j]); refedBy.directReferences.Add(curAI); } } }); } //Scenes var scenes = GetScenePaths(_scenes); if (scenes == null) { yield return(() => { var references = GetSceneReferences(); CreateSceneOrPrefab(GetCurrentScene(), references, false); }); } else { string curScene = GetCurrentScene(); for (int i = 0; i < scenes.Length; i++) { if (_cancelled) { yield break; } _progressMessage = string.Format("Processing scene {0}/{1}: {2}", i, scenes.Length, scenes[i]); _owner.Repaint(); yield return(() => { OpenScene(scenes[i]); var references = GetSceneReferences(); CreateSceneOrPrefab(scenes[i], references, false); }); } OpenScene(curScene); } //Prefabs if (_includePrefabs) { var prefabs = (from f in Directory.GetFiles(Application.dataPath, "*.prefab", SearchOption.AllDirectories) select AssetPath.ProjectRelativePath(f)).ToArray(); for (int i = 0; i < prefabs.Length; i++) { if (_cancelled) { yield break; } _progressMessage = string.Format("Processing prefab {0}/{1}: {2}", i, prefabs.Length, prefabs[i]); _owner.Repaint(); yield return(() => { var pf = AssetDatabase.LoadMainAssetAtPath(prefabs[i]) as GameObject; if (pf != null) { var references = GetPrefabReferences(pf); CreateSceneOrPrefab(prefabs[i], references, true); } }); } } _progressMessage = "Cross referencing"; _owner.Repaint(); yield return(() => { PrepareAIResult(); }); }
protected override void Paste() { try { AssignAsset(AssetPath.CorrectSlashes(Clipboard.Text)); } catch (System.Exception) { } }
private void SetPathPrefix(string oldPrefix, string prefix) => this.SetProperty <T>(current => StringToValueConverter(AssetPath.CorrectSlashes( Path.Combine(prefix, ValueToStringConverter(current).Substring(oldPrefix.Length).TrimStart('/')))));
static AssemblyDefintionState LoadAssemblyDefintionState(string path) { var asset = AssetDatabase.LoadAssetAtPath <AssemblyDefinitionAsset>(path); if (asset == null) { return(null); } var data = CustomScriptAssemblyData.FromJson(asset.text); if (data == null) { return(null); } var state = new AssemblyDefintionState(); state.asset = asset; state.name = data.name; state.references = new List <AssemblyDefinitionReference>(); state.precompiledReferences = new List <PrecompiledReference>(); state.defineConstraints = new List <DefineConstraint>(); state.autoReferenced = ToMixedBool(data.autoReferenced); state.allowUnsafeCode = ToMixedBool(data.allowUnsafeCode); state.overrideReferences = ToMixedBool(data.overrideReferences); if (data.defineConstraints != null) { foreach (var defineConstaint in data.defineConstraints) { try { var symbolName = defineConstaint.StartsWith(DefineConstraintsHelper.Not) ? defineConstaint.Substring(1) : defineConstaint; if (!SymbolNameRestrictions.IsValid(symbolName)) { throw new AssemblyDefinitionException($"Invalid define constraint {symbolName}", path); } state.defineConstraints.Add(new DefineConstraint { name = defineConstaint, displayValue = MixedBool.False, }); } catch (AssemblyDefinitionException e) { Debug.LogException(e, asset); state.modified = true; } } } if (data.references != null) { foreach (var reference in data.references) { try { var assemblyDefinitionFile = new AssemblyDefinitionReference(); var referencePath = Compilation.CompilationPipeline.GetAssemblyDefinitionFilePathFromAssemblyName(reference); if (string.IsNullOrEmpty(referencePath)) { throw new AssemblyDefinitionException(string.Format("Could not find assembly reference '{0}'", reference), path); } assemblyDefinitionFile.asset = AssetDatabase.LoadAssetAtPath <AssemblyDefinitionAsset>(referencePath); if (assemblyDefinitionFile.asset == null) { throw new AssemblyDefinitionException(string.Format("Reference assembly definition file '{0}' not found", referencePath), path); } assemblyDefinitionFile.data = CustomScriptAssemblyData.FromJson(assemblyDefinitionFile.asset.text); assemblyDefinitionFile.displayValue = MixedBool.False; state.references.Add(assemblyDefinitionFile); } catch (AssemblyDefinitionException e) { UnityEngine.Debug.LogException(e, asset); state.references.Add(new AssemblyDefinitionReference()); state.modified = true; } } } var nameToPrecompiledReference = EditorCompilationInterface.Instance.GetAllPrecompiledAssemblies() .Where(x => (x.Flags & AssemblyFlags.UserAssembly) == AssemblyFlags.UserAssembly) .ToDictionary(x => AssetPath.GetFileName(x.Path), x => x); foreach (var precompiledReferenceName in data.precompiledReferences ?? Enumerable.Empty <String>()) { try { var precompiledReference = new PrecompiledReference(); var precompiledAssemblyPossibleReference = nameToPrecompiledReference.ContainsKey(precompiledReferenceName); if (!precompiledAssemblyPossibleReference && !data.overrideReferences) { throw new AssemblyDefinitionException(string.Format("Referenced precompiled assembly '{0}' not found", precompiledReferenceName), path); } precompiledReference.precompiled = nameToPrecompiledReference[precompiledReferenceName]; precompiledReference.displayValue = MixedBool.True; state.precompiledReferences.Add(precompiledReference); } catch (AssemblyDefinitionException e) { Debug.LogException(e, asset); state.precompiledReferences.Add(new PrecompiledReference()); state.modified = true; } } var platforms = CompilationPipeline.GetAssemblyDefinitionPlatforms(); state.platformCompatibility = new MixedBool[platforms.Length]; var OptinalUnityAssemblies = CustomScriptAssembly.OptinalUnityAssemblies; state.optionalUnityReferences = new MixedBool[OptinalUnityAssemblies.Length]; if (data.optionalUnityReferences != null) { for (int i = 0; i < OptinalUnityAssemblies.Length; i++) { var optionalUnityReferences = OptinalUnityAssemblies[i].OptionalUnityReferences.ToString(); var any = data.optionalUnityReferences.Any(x => x == optionalUnityReferences); if (any) { state.optionalUnityReferences[i] = MixedBool.True; } } } state.compatibleWithAnyPlatform = MixedBool.True; string[] dataPlatforms = null; if (data.includePlatforms != null && data.includePlatforms.Length > 0) { state.compatibleWithAnyPlatform = MixedBool.False; dataPlatforms = data.includePlatforms; } else if (data.excludePlatforms != null && data.excludePlatforms.Length > 0) { state.compatibleWithAnyPlatform = MixedBool.True; dataPlatforms = data.excludePlatforms; } if (dataPlatforms != null) { foreach (var platform in dataPlatforms) { var platformIndex = GetPlatformIndex(platforms, platform); state.platformCompatibility[platformIndex] = MixedBool.True; } } return(state); }
public void Start() { Console.WriteLine("Generating scenes code for {0} scenes...", scenesForProcessing.Count); var generatedScenesPath = $"{directory}/{projectName}.GeneratedScenes"; if (!Directory.Exists(generatedScenesPath)) { GenerateProjectFiles(generatedScenesPath); } var scenesPath = $@"{directory}/{projectName}.GeneratedScenes/Scenes"; RemoveOrphanedGeneratedCodeItems(); RemoveUpdatingCommonPartsFromCache(); foreach (var scenePath in allScenes) { externalSceneToOriginalScenePath.Add(Path.ChangeExtension(scenePath, null), scenePath); } var sceneToFrameTree = new List <Tuple <string, ParsedFramesTree> >(); foreach (var scene in scenesForProcessing) { var bundleName = sceneToBundleMap[scene.Key]; var bundleSourcePath = $"{scenesPath}/{bundleName}"; if (!Directory.Exists(bundleSourcePath)) { RetryUntilSuccessCreateDirectory(bundleSourcePath); } currentCookingScene = scene.Key; var parsedFramesTree = GenerateParsedFramesTree(scene.Key, scene.Value); sceneToFrameTree.Add(new Tuple <string, ParsedFramesTree>(scene.Key, parsedFramesTree)); } foreach (var kv in sceneToFrameTree) { var parsedFramesTree = kv.Item2; currentCookingScene = kv.Item1; var k = Path.ChangeExtension(kv.Item1, null); k = AssetPath.CorrectSlashes(k); var id = scenesForProcessing[kv.Item1].Id; var bundleName = sceneToBundleMap[kv.Item1]; var bundleSourcePath = $"{scenesPath}/{bundleName}"; var generatedCodePath = bundleSourcePath + "/" + parsedFramesTree.ClassName + ".cs"; var useful = parsedFramesTree.ParsedNodes.Count > 0 || parsedFramesTree.InnerClasses.Count > 0 || (id != null && (id.StartsWith("@") || id.StartsWith(">"))); if (!useful) { if (File.Exists(generatedCodePath)) { File.Delete(generatedCodePath); } continue; } var code = parsedFramesTree.GenerateCode(this); code = code.Replace("<%PROJECT_NAME%>", projectName); code = code.Replace("<%NAMESPACE%>", GetBundleNamespace(bundleName)); code = new CodeFormatter(code).FormattedCode; File.WriteAllText(generatedCodePath, code); } UpdateCache(); // Collect not loaded scenes which are also contains common parts affected by actually modified and referred to them scenes // Because we need those to correctly update common parts. i.e. to calc common parts you need all of common parts referrers List <string> reprocessScenes = new List <string>(); foreach (var kv in codeCookerCache.CommonPartToReferredScenes) { if (commonParts.ContainsKey(kv.Key)) { foreach (var scene in kv.Value) { if (!modifiedScenes.Contains(scene)) { reprocessScenes.Add(scene); } } } } foreach (var scene in reprocessScenes) { GenerateParsedFramesTree(scene, Node.CreateFromAssetBundle(scene)); } GenerateCommonParts(scenesPath); UpdateCommonPartsCache(); }
public override bool Execute() { Log.LogMessage($"Copying static web assets to blazor project via task..."); try { foreach (string projectName in ProjectsWithStaticFiles) { if (AssetPath.Contains(projectName)) { var fileName = Path.GetFileName(AssetPath); var folderName = $"{TargetPath}/_content/{projectName}/"; var sourcePath = AssetPath.Replace(fileName, ""); if (!Directory.Exists(folderName)) { Directory.CreateDirectory(folderName); } // copy all directories foreach (string dirPath in Directory.GetDirectories(sourcePath, "*", SearchOption.AllDirectories)) { Directory.CreateDirectory(dirPath.Replace(sourcePath, folderName)); } // copy all files foreach (string filePath in Directory.GetFiles(sourcePath, "*.*", SearchOption.AllDirectories)) { File.Copy(filePath, filePath.Replace(sourcePath, folderName), true); } if (File.Exists(JsImportsPath)) { var jsImports = JsonConvert.DeserializeObject <List <string> >(File.ReadAllText(JsImportsPath)); var indexTsxFielPath = $"{TargetPath}/index.tsx"; var jsImportsString = ""; foreach (var jsImport in jsImports) { if (!File.ReadAllText(indexTsxFielPath).Contains($"import '{jsImport}';")) { jsImportsString += $"import '{jsImport}';\n"; } } File.WriteAllText(indexTsxFielPath, jsImportsString + File.ReadAllText(indexTsxFielPath)); } else { Log.LogError($"The file '{JsImportsPath}' does not exist."); } Log.LogMessage($"'{AssetPath}' copied to '{folderName}'."); } } } catch (Exception error) { Log.LogError(error.Message); return(false); } return(true); }
public DiskSelector(Screen screen, string initialDiskPath, Mod initialDiskMod, Progress progress) { m_geometry = new Geometry(Primitive.Triangles); m_disks = ArcadeUtils.GetAllDisks().ToArray(); m_disksUnlocked = m_disks.Select(disk => ArcadeUtils.IsDiskUnlocked(disk.Disk, disk.Mod, progress)).ToArray(); m_page = 0; if (m_disks.Length <= COLUMNS_PER_PAGE) { m_numColumns = m_disks.Length; m_numRows = 1; } else if (m_disks.Length < NUM_PER_PAGE) { m_numColumns = (m_disks.Length + ROWS_PER_PAGE - 1) / ROWS_PER_PAGE; m_numRows = ROWS_PER_PAGE; } else { m_numColumns = COLUMNS_PER_PAGE; m_numRows = ROWS_PER_PAGE; } m_highlight = -1; m_backPrompt = new InputPrompt(UIFonts.Smaller, screen.Language.Translate("menus.close"), TextAlignment.Right); m_backPrompt.Key = Key.Escape; m_backPrompt.MouseButton = MouseButton.Left; m_backPrompt.GamepadButton = GamepadButton.B; m_backPrompt.SteamControllerButton = SteamControllerButton.MenuBack; m_backPrompt.Anchor = Anchor.BottomRight; m_backPrompt.LocalPosition = new Vector2(-16.0f, -16.0f - m_backPrompt.Height); m_backPrompt.Parent = this; m_backPrompt.OnClick += delegate(object o, EventArgs args) { m_closeNextFrame = true; }; m_selectPrompt = new InputPrompt(UIFonts.Smaller, screen.Language.Translate("menus.select"), TextAlignment.Left); m_selectPrompt.Key = Key.Return; m_selectPrompt.GamepadButton = GamepadButton.A; m_selectPrompt.SteamControllerButton = SteamControllerButton.MenuSelect; m_selectPrompt.Anchor = Anchor.BottomLeft; m_selectPrompt.LocalPosition = new Vector2(16.0f, -16.0f - m_selectPrompt.Height); m_selectPrompt.Parent = this; m_browseWorkshopPrompt = new InputPrompt(UIFonts.Smaller, screen.Language.Translate("menus.arcade.browse_workshop"), TextAlignment.Right); m_browseWorkshopPrompt.Key = Key.LeftCtrl; m_browseWorkshopPrompt.GamepadButton = GamepadButton.Y; m_browseWorkshopPrompt.SteamControllerButton = SteamControllerButton.MenuAltSelect; m_browseWorkshopPrompt.Anchor = Anchor.BottomRight; m_browseWorkshopPrompt.LocalPosition = new Vector2(-16.0f, -16.0f - m_selectPrompt.Height - m_browseWorkshopPrompt.Height); m_browseWorkshopPrompt.Parent = this; m_previousPageButton = new Button(Texture.Get("gui/arrows.png", true), 32.0f, 32.0f); m_previousPageButton.Region = new Quad(0.0f, 0.5f, 0.5f, 0.5f); m_previousPageButton.HighlightRegion = m_previousPageButton.Region; m_previousPageButton.DisabledRegion = m_previousPageButton.Region; m_previousPageButton.ShortcutButton = GamepadButton.LeftBumper; m_previousPageButton.AltShortcutButton = GamepadButton.LeftTrigger; m_previousPageButton.ShortcutSteamControllerButton = SteamControllerButton.MenuPreviousPage; m_previousPageButton.Colour = UIColours.Title; m_previousPageButton.HighlightColour = UIColours.White; m_previousPageButton.DisabledColour = m_previousPageButton.Colour; m_previousPageButton.Anchor = Anchor.CentreMiddle; m_previousPageButton.LocalPosition = new Vector2( -0.5f * (float)COLUMNS_PER_PAGE * (DISK_SIZE + DISK_PADDING) - m_previousPageButton.Width, -0.5f * m_previousPageButton.Height ); m_previousPageButton.Parent = this; m_previousPageButton.OnClicked += delegate(object o, EventArgs e) { PreviousPage(); }; m_nextPageButton = new Button(Texture.Get("gui/arrows.png", true), 32.0f, 32.0f); m_nextPageButton.Region = new Quad(0.0f, 0.0f, 0.5f, 0.5f); m_nextPageButton.HighlightRegion = m_nextPageButton.Region; m_nextPageButton.DisabledRegion = m_nextPageButton.Region; m_nextPageButton.ShortcutButton = GamepadButton.RightBumper; m_nextPageButton.AltShortcutButton = GamepadButton.RightTrigger; m_nextPageButton.ShortcutSteamControllerButton = SteamControllerButton.MenuNextPage; m_nextPageButton.Colour = UIColours.Title; m_nextPageButton.HighlightColour = UIColours.White; m_nextPageButton.DisabledColour = m_nextPageButton.Colour; m_nextPageButton.Anchor = Anchor.CentreMiddle; m_nextPageButton.LocalPosition = new Vector2( 0.5f * (float)COLUMNS_PER_PAGE * (DISK_SIZE + DISK_PADDING), -0.5f * m_previousPageButton.Height ); m_nextPageButton.Parent = this; m_nextPageButton.OnClicked += delegate(object o, EventArgs e) { NextPage(); }; // Load labels m_diskLabels = new Texture[m_disks.Length]; for (int i = 0; i < m_disks.Length; ++i) { var disk = m_disks[i]; var labelPath = AssetPath.ChangeExtension(disk.Disk.Path, "png"); if (disk.Mod != null) { if (disk.Mod.Assets.CanLoad(labelPath)) { m_diskLabels[i] = disk.Mod.Assets.Load <Texture>(labelPath); m_diskLabels[i].Filter = false; } } else { m_diskLabels[i] = Texture.Get(labelPath, false); } } m_framesOpen = 0; m_closeNextFrame = false; // Determine initial disk index m_initialDisk = -1; if (initialDiskPath != null && m_disks.Length > 0) { for (int i = 0; i < m_disks.Length; ++i) { var disk = m_disks[i]; if (disk.Disk.Path == initialDiskPath && disk.Mod == initialDiskMod && m_disksUnlocked[i]) { m_initialDisk = i; break; } } } }
public AssetFile Find(AssetPath path) { throw new NotImplementedException(); }
private List<AssetPath> GenerateAssetList(string contentPath) { string appPath = Application.dataPath.Substring(0, Application.dataPath.LastIndexOf(@"Assets")); var lst = new List<AssetPath>(); var directoryInfo = new DirectoryInfo(contentPath).GetDirectories(); foreach (var item in directoryInfo) { string pathnameFromFile = File.ReadAllLines(Path.Combine(item.FullName, "pathname")).ToList().First(); //ensure path correction pathnameFromFile = pathnameFromFile.Replace(@"\\", "/"); pathnameFromFile = pathnameFromFile.Replace(@"\", "/"); var asset = new AssetPath(); if (Directory.Exists(Path.Combine(appPath, pathnameFromFile))) { asset.name = Path.GetDirectoryName(pathnameFromFile); if (!pathnameFromFile.EndsWith("/")) { pathnameFromFile += "/"; } } else { asset.name = Path.GetFileName(pathnameFromFile); } asset.filePath = pathnameFromFile; lst.Add(asset); } var ordered = lst.OrderByDescending(i => i.filePath.Count(x => x == '/')); return ordered.ToList(); }
static void LoadAssemblyDefintionState(AssemblyDefinitionState state, string path) { var asset = AssetDatabase.LoadAssetAtPath <AssemblyDefinitionAsset>(path); if (asset == null) { return; } var data = CustomScriptAssemblyData.FromJsonNoFieldValidation(asset.text); if (data == null) { return; } try { data.ValidateFields(); } catch (Exception e) { Debug.LogException(e, asset); } state.asset = asset; state.assemblyName = data.name; state.references = new List <AssemblyDefinitionReference>(); state.precompiledReferences = new List <PrecompiledReference>(); state.defineConstraints = new List <DefineConstraint>(); state.versionDefines = new List <VersionDefine>(); state.autoReferenced = data.autoReferenced; state.allowUnsafeCode = data.allowUnsafeCode; state.overrideReferences = data.overrideReferences; // If the .asmdef has no references (true for newly created .asmdef), then use GUIDs. // Otherwise do not use GUIDs. This value might be changed below if any reference is a GUID. state.useGUIDs = (data.references == null || data.references.Length == 0); if (data.versionDefines != null) { foreach (var versionDefine in data.versionDefines) { if (!SymbolNameRestrictions.IsValid(versionDefine.define)) { var exception = new AssemblyDefinitionException($"Invalid version define {versionDefine.define}", path); Debug.LogException(exception, asset); } else { state.versionDefines.Add(new VersionDefine { name = versionDefine.name, expression = versionDefine.expression, define = versionDefine.define, }); } } } if (data.defineConstraints != null) { foreach (var defineConstraint in data.defineConstraints) { var symbolName = defineConstraint.StartsWith(DefineConstraintsHelper.Not) ? defineConstraint.Substring(1) : defineConstraint; if (!SymbolNameRestrictions.IsValid(symbolName)) { var exception = new AssemblyDefinitionException($"Invalid define constraint {symbolName}", path); Debug.LogException(exception, asset); } else { state.defineConstraints.Add(new DefineConstraint { name = defineConstraint, }); } } } if (data.references != null) { foreach (var reference in data.references) { try { var assemblyDefinitionFile = new AssemblyDefinitionReference { name = reference, serializedReference = reference }; // If any references is a GUID, use GUIDs. var isGuid = CompilationPipeline.GetAssemblyDefinitionReferenceType(reference) == AssemblyDefinitionReferenceType.Guid; if (isGuid) { state.useGUIDs = true; } assemblyDefinitionFile.Load(reference, isGuid); state.references.Add(assemblyDefinitionFile); } catch (AssemblyDefinitionException e) { UnityEngine.Debug.LogException(e, asset); state.references.Add(new AssemblyDefinitionReference()); } } } var nameToPrecompiledReference = EditorCompilationInterface.Instance.GetAllPrecompiledAssemblies() .Where(x => (x.Flags & AssemblyFlags.UserAssembly) == AssemblyFlags.UserAssembly) .ToDictionary(x => AssetPath.GetFileName(x.Path), x => x); foreach (var precompiledReferenceName in data.precompiledReferences ?? Enumerable.Empty <String>()) { try { var precompiledReference = new PrecompiledReference { name = precompiledReferenceName, }; PrecompiledAssembly assembly; if (nameToPrecompiledReference.TryGetValue(precompiledReferenceName, out assembly)) { precompiledReference.path = assembly.Path; precompiledReference.fileName = AssetPath.GetFileName(assembly.Path); } state.precompiledReferences.Add(precompiledReference); } catch (AssemblyDefinitionException e) { Debug.LogException(e, asset); state.precompiledReferences.Add(new PrecompiledReference()); } } var platforms = CompilationPipeline.GetAssemblyDefinitionPlatforms(); state.platformCompatibility = new bool[platforms.Length]; state.compatibleWithAnyPlatform = true; string[] dataPlatforms = null; if (data.includePlatforms != null && data.includePlatforms.Length > 0) { state.compatibleWithAnyPlatform = false; dataPlatforms = data.includePlatforms; } else if (data.excludePlatforms != null && data.excludePlatforms.Length > 0) { state.compatibleWithAnyPlatform = true; dataPlatforms = data.excludePlatforms; } if (dataPlatforms != null) { foreach (var platform in dataPlatforms) { var platformIndex = GetPlatformIndex(platforms, platform); state.platformCompatibility[platformIndex] = true; } } }
// pass target as null to build cooking rules disregarding targets public static Dictionary <string, CookingRules> Build(IFileEnumerator fileEnumerator, Target target) { var shouldRescanEnumerator = false; var pathStack = new Stack <string>(); var rulesStack = new Stack <CookingRules>(); var map = new Dictionary <string, CookingRules>(); pathStack.Push(""); var rootRules = new CookingRules(); rootRules.DeduceEffectiveRules(target); rulesStack.Push(rootRules); using (new DirectoryChanger(fileEnumerator.Directory)) { foreach (var fileInfo in fileEnumerator.Enumerate()) { var path = fileInfo.Path; while (!path.StartsWith(pathStack.Peek())) { rulesStack.Pop(); pathStack.Pop(); } if (Path.GetFileName(path) == CookingRulesFilename) { var dirName = Lime.AssetPath.GetDirectoryName(path); pathStack.Push(dirName == string.Empty ? "" : dirName + "/"); var rules = ParseCookingRules(rulesStack.Peek(), path, target); rules.SourceFilename = AssetPath.Combine(fileEnumerator.Directory, path); rulesStack.Push(rules); // Add 'ignore' cooking rules for this #CookingRules.txt itself var ignoreRules = rules.InheritClone(); ignoreRules.Ignore = true; map[path] = ignoreRules; var directoryName = pathStack.Peek(); if (!string.IsNullOrEmpty(directoryName)) { directoryName = directoryName.Remove(directoryName.Length - 1); // it is possible for map to not contain this directoryName since not every IFileEnumerator enumerates directories if (map.ContainsKey(directoryName)) { map[directoryName] = rules; } } } else { if (Path.GetExtension(path) == ".txt") { var filename = path.Remove(path.Length - 4); if (File.Exists(filename) || Directory.Exists(filename)) { continue; } } var rulesFile = path + ".txt"; var rules = rulesStack.Peek(); if (File.Exists(rulesFile)) { rules = ParseCookingRules(rulesStack.Peek(), rulesFile, target); rules.SourceFilename = AssetPath.Combine(fileEnumerator.Directory, rulesFile); // Add 'ignore' cooking rules for this cooking rules text file var ignoreRules = rules.InheritClone(); ignoreRules.Ignore = true; map[rulesFile] = ignoreRules; } if (rules.CommonRules.LastChangeTime > fileInfo.LastWriteTime) { try { File.SetLastWriteTime(path, rules.CommonRules.LastChangeTime); } catch (UnauthorizedAccessException) { // In case this is a folder } shouldRescanEnumerator = true; } map[path] = rules; } } } if (shouldRescanEnumerator) { fileEnumerator.Rescan(); } return(map); }
internal static string GenerateResponseFile(ScriptAssembly assembly, string tempBuildDirectory) { var assemblyOutputPath = PrepareFileName(AssetPath.Combine(tempBuildDirectory, assembly.Filename)); var arguments = new List <string> { "/target:library", "/nowarn:0169", "/out:" + assemblyOutputPath }; if (assembly.CompilerOptions.AllowUnsafeCode) { arguments.Add("/unsafe"); } if (assembly.CompilerOptions.UseDeterministicCompilation) { arguments.Add("/deterministic"); } arguments.Add("/debug:portable"); if (assembly.CompilerOptions.CodeOptimization == CodeOptimization.Release) { arguments.Add("/optimize+"); } else { arguments.Add("/optimize-"); } FillCompilerOptions(arguments, assembly.BuildTarget); string[] scriptAssemblyReferences = new string[assembly.ScriptAssemblyReferences.Length]; for (var index = 0; index < assembly.ScriptAssemblyReferences.Length; index++) { var reference = assembly.ScriptAssemblyReferences[index]; scriptAssemblyReferences[index] = "/reference:" + PrepareFileName(AssetPath.Combine(assembly.OutputDirectory, reference.Filename)); } Array.Sort(scriptAssemblyReferences, StringComparer.Ordinal); arguments.AddRange(scriptAssemblyReferences); Array.Sort(assembly.References, StringComparer.Ordinal); foreach (var reference in assembly.References) { arguments.Add("/reference:" + PrepareFileName(reference)); } var defines = assembly.Defines.Distinct().ToArray(); Array.Sort(defines, StringComparer.Ordinal); foreach (var define in defines) { arguments.Add("/define:" + define); } Array.Sort(assembly.Files, StringComparer.Ordinal); foreach (var source in assembly.Files) { var f = PrepareFileName(source); f = Paths.UnifyDirectorySeparator(f); arguments.Add(f); } var responseFileProvider = assembly.Language?.CreateResponseFileProvider(); var responseFilesList = responseFileProvider?.Get(assembly.OriginPath) ?? new List <string>(); HashSet <string> responseFiles = new HashSet <string>(responseFilesList); string obsoleteResponseFile = responseFiles.SingleOrDefault( x => CompilerSpecificResponseFiles.MicrosoftCSharpCompilerObsolete.Contains(AssetPath.GetFileName(x))); if (!string.IsNullOrEmpty(obsoleteResponseFile)) { Debug.LogWarning($"Using obsolete custom response file '{AssetPath.GetFileName(obsoleteResponseFile)}'. Please use '{CompilerSpecificResponseFiles.MicrosoftCSharpCompiler}' instead."); } foreach (var file in responseFiles) { AddResponseFileToArguments(arguments, file, assembly.CompilerOptions.ApiCompatibilityLevel); } var responseFile = CommandLineFormatter.GenerateResponseFile(arguments); return(responseFile); }
private bool ChangeStorageFolder(string proposedFolder) { if (string.Equals(proposedFolder, _storagePath, StringComparison.OrdinalIgnoreCase) || !AssetPath.IsProjectPath(proposedFolder)) { return(false); } proposedFolder = AssetPath.ProjectRelativePath(proposedFolder); bool apexified = proposedFolder.EndsWith("Resources/" + AIManager.StorageFolder); if (!proposedFolder.EndsWith("Resources") && !apexified) { EditorUtility.DisplayDialog("Invalid Storage Folder", "The storage folder selected must be a Resources folder. This can however be anywhere inside the Assets folder.", "Ok"); return(false); } if (!apexified) { proposedFolder = AssetPath.Combine(proposedFolder, AIManager.StorageFolder); } AssetPath.EnsurePath(proposedFolder); //Move files from current storage location to new location. var fullStoragePath = AssetPath.GetFullPath(_storagePath); if (Directory.Exists(fullStoragePath)) { foreach (var asset in Directory.GetFiles(fullStoragePath, "*.asset", SearchOption.TopDirectoryOnly)) { var fileName = Path.GetFileName(asset); var msg = AssetDatabase.MoveAsset(AssetPath.ProjectRelativePath(asset), AssetPath.Combine(proposedFolder, fileName)); if (!string.IsNullOrEmpty(msg)) { EditorUtility.DisplayDialog("Error Moving Assets", msg, "Ok"); return(false); } } AssetDatabase.DeleteAsset(_storagePath); } _storagePath = proposedFolder; return(true); }