private static void CreateItemFromTemplate(string template, string fileExtension, CustomTemplateWizard wizard) { try { string path = Path.ChangeExtension(Path.Combine(CustomAssetHelper.GetSelectedObjectFolder(), wizard.ItemName), fileExtension); if (File.Exists(path)) { if (!EditorUtility.DisplayDialog("File exists already!", "Do you want to overwrite the file?", "Yes", "No")) { return; } } using (var writer = new StreamWriter(path, false)) { writer.Write(ReplaceTemplateTokens(template, new[] { "$ItemName", wizard.ItemName }, new[] { "$User", wizard.ProgrammerName }, new[] { "$Namespace", wizard.Namespace }, new[] { "$Year", DateTime.Now.Year.ToString(CultureInfo.InvariantCulture) }, new[] { "$DateTime", DateTime.Now.ToShortDateString() }, new[] { "$EditingItemName", FindEditingItemName(wizard.ItemName) })); } AssetDatabase.ImportAsset(path); } catch (Exception exception) { Debug.LogException(exception); } }
private void Commit() { Signature signature = GitManager.Signature; try { if (!GitExternalManager.TakeCommit(commitMessage)) { GitManager.Repository.Commit(commitMessage, signature, signature, new CommitOptions() { AllowEmptyCommit = settings.emptyCommit, AmendPreviousCommit = settings.amendCommit, PrettifyMessage = settings.prettify }); GitHistoryWindow.GetWindow(true); } GitManager.Update(); } catch (Exception e) { Debug.LogException(e); } finally { GUI.FocusControl(""); commitMessage = string.Empty; } }
internal override void Load() { if (!string.IsNullOrEmpty(assetBundleName)) { bundle = Assets.LoadBundle(assetBundleName); if (bundle != null) { SceneManager.LoadScene(sceneName, loadSceneMode); } } else { try { SceneManager.LoadScene(sceneName, loadSceneMode); loadState = LoadState.LoadAsset; } catch (Exception e) { Debug.LogException(e); error = e.ToString(); loadState = LoadState.Loaded; } } }
static Log() { try { string dir = Application.dataPath; LogFilePath = Path.Combine(dir, LOG_FILE_NAME); if (File.Exists(LogFilePath)) { File.Delete(LogFilePath); // delete old file to avoid confusion. } var args = Environment.GetCommandLineArgs(); int index = Array.IndexOf(args, "-logFile"); if (index >= 0) { dir = args[index + 1]; dir = Path.GetDirectoryName(dir); // drop output_log.txt LogFilePath = Path.Combine(dir, LOG_FILE_NAME); if (File.Exists(LogFilePath)) { File.Delete(LogFilePath); } } } catch (Exception e) { Debug.LogException(e); } }
/// <summary> /// Process all the events we received through Notify() last frame. /// </summary> private void Update() { // Cache our number of events to prevent a potentially infinite loop if one event triggers another. int initialCount = kEventsFromLastFrame.Count; for (int i = 0; i < initialCount; ++i) { // This is the most exception-safe way to execute this. // It grabs all the delegates from each event and executes them one-by-one, catching exceptions from each. Action e = kEventsFromLastFrame.Dequeue(); var delegates = e.GetInvocationList(); foreach (Delegate d in delegates) { try { d.Method.Invoke(e.Target, null); } catch (Exception except) { Debug.LogException(except); } } } }
protected virtual void SendFile(int id, FileInfo file, bool forceDownload = false) { new Thread(() => { try { if (!file.Exists) { SendError(id, "<h2>File not found</h2>", 404); return; } FileStream fileStream = null; try { fileStream = file.OpenRead(); } catch (Exception ex) { Debug.LogException(ex); SendError(id, "<h2>File unavailable</h2>", 500); return; } string mimeType; var ext = file.Extension; if (ext.Length > 0) { ext = ext.Substring(1).ToLowerInvariant(); } if (!extensionMimeTypes.TryGetValue(ext, out mimeType)) { mimeType = extensionMimeTypes["*"]; } //Debug.Log("response type: " + mimeType + " extension " + file.Extension); var pre = new ResponsePreamble { headers = new Dictionary <string, string>(), length = (int)file.Length, mimeType = mimeType, statusCode = 200, }; if (forceDownload) { pre.headers["Content-Disposition"] = "attachment; filename=\"" + file.Name.Replace("\"", "\\\"") + "\""; } SendPreamble(id, pre); int readCount = -1; byte[] buffer = new byte[Math.Min(pre.length, 32 * 1024)]; while (readCount != 0) { readCount = fileStream.Read(buffer, 0, buffer.Length); SendData(id, buffer, readCount); } SendEnd(id); fileStream.Close(); } catch (Exception ex) { Debug.LogException(ex); } }).Start(); }
public static void Verbose(Exception e) { if (IsVerbose) { UnityDebug.LogException(e); } }
static RiderScriptEditor() { try { var projectGeneration = new ProjectGeneration(); var editor = new RiderScriptEditor(new Discovery(), projectGeneration); CodeEditor.Register(editor); var path = GetEditorRealPath(CodeEditor.CurrentEditorInstallation); if (IsRiderInstallation(path)) { if (!FileSystemUtil.EditorPathExists(path)) // previously used rider was removed { var newEditor = editor.Installations.Last().Path; CodeEditor.SetExternalScriptEditor(newEditor); path = newEditor; } editor.CreateSolutionIfDoesntExist(); if (ShouldLoadEditorPlugin(path)) { editor.m_Initiliazer.Initialize(path); } InitProjectFilesWatcher(); } } catch (Exception e) { Debug.LogException(e); } }
private void Update() { var w = Stopwatch.StartNew(); var actionsAmount = Actions.Count; while (Actions.Count != 0) { if (!Actions.TryDequeue(out Action a)) { continue; } try { a?.Invoke(); } catch (Exception e) { Debug.LogException(e); } } w.Stop(); if (w.ElapsedMilliseconds > 30) { Debug.LogError($"WARNING!!! Main thread invoker took {w.ElapsedMilliseconds} milliseconds" + $" in main thread for {actionsAmount} action(s)."); } }
public static IEnumerable ExecuteSeq <T>(this MonoBehaviour mb, GameObject target, EventAction <T> functor) where T : IEventSystemHandler { var internalHandlers = s_HandlerListPool.Get(); GetEventList <T>(target, internalHandlers); // if (s_InternalHandlers.Count > 0) // Debug.Log("Executing " + typeof (T) + " on " + target); for (var i = 0; i < internalHandlers.Count; i++) { T arg; try { arg = (T)internalHandlers[i]; } catch (Exception e) { var temp = internalHandlers[i]; Debug.LogException(new Exception(string.Format("Type {0} expected {1} received.", typeof(T).Name, temp.GetType().Name), e)); continue; } if (arg == null || functor == null) { Debug.LogError("EzMsg: Signature Type Incompatible or Functor not assigned"); yield break; } yield return(mb.StartCoroutine(functor(arg).GetEnumerator())); } // var handlerCount = internalHandlers.Count; // s_HandlerListPool.Release(internalHandlers); // return handlerCount > 0; }
public static SyntaxTreeNode_Rule ResolveNode(SyntaxTreeNode_Rule node) { if (node == null) { return(null); } while (node.Parent != null) { switch (node.RuleName) { //case "primaryExpression": case "primaryExpressionStart": case "primaryExpressionPart": case "objectCreationExpression": case "objectOrCollectionInitializer": case "typeOrGeneric": case "namespaceOrTypeName": case "typeName": case "nonArrayType": //case "attribute": case "accessIdentifier": case "brackets": case "argumentList": case "attributeArgumentList": case "argumentName": case "attributeMemberName": case "argument": case "attributeArgument": case "attributeArguments": case "arrayCreationExpression": case "implicitArrayCreationExpression": case "arrayInitializer": case "arrayInitializerList": case "qidStart": case "qidPart": case "memberInitializer": case "globalNamespace": node = node.Parent; continue; } break; } try { var result = SymbolDefinition.ResolveNode(node, null, null, 0);//numTypeArgs); if (result == null) { ResolveChildren(node); } } catch (Exception e) { Debug.LogException(e); return(null); } return(node); }
private static void GenerateLog(StringBuilder stringBuilder) { Dictionary <int, RelLoger> newRelLogers = new Dictionary <int, RelLoger>(relLogers.Count); Dictionary <int, JSMgr.JS_CS_Rel> dic1 = JSMgr.GetDict1(); foreach (var item in dic1) { try { RelLoger relLoger; if (relLogers.TryGetValue(item.Key, out relLoger) == false) { relLoger = new RelLoger(item.Key, item.Value.csObj); } relLoger.AddRelSurvival(item.Value.csObj, generateCount); newRelLogers.Add(item.Key, relLoger); //只输出已经Destroy的 if (relLoger.isUnityObj && relLoger.list[relLoger.list.Count - 1].isDestroy) { stringBuilder.AppendLine(relLoger.ToString()); } } catch (Exception e) { Debug.LogException(e); } } relLogers = newRelLogers; }
/// <summary> /// click event that saves the blueprint /// </summary> public void SaveBlueprint() { MessageController messageController = GameController.Instance.messageController; if (BlueprintMenu.blueprintObject == null) { messageController.WarningMessage("Cannot save a creation that doesn't exist.\nLoad one first.", 3); return; } //string blueprintDataStr = JsonConvert.SerializeObject(BlueprintLoader.blueprintObject.ToBlueprintData()); messageController.YesNoMessage("Are you sure you want to save your creation to this blueprint?", yesAction: () => { try { SelectedBlueprintButton.BlueprintContextReference.Blueprint = BlueprintMenu.blueprintObject.ToBlueprintData(); SelectedBlueprintButton.BlueprintContextReference.SaveBlueprint(); messageController.WarningMessage("Creation successfully saved!"); } catch (Exception e) { messageController.WarningMessage("Something went wrong while saving your creation to this blueprint!\nCheck the log for more information", 5); Debug.LogException(e, this); } }, noAction: () => { messageController.WarningMessage("Creation not saved.", 2); }); }
public Func<bool> Update(int fromLine, int toLineInclusive) { // var t = new Stopwatch(); // t.Start(); var lastLine = textBuffer.formatedLines.Length - 1; try { if (this.parseTree != null) ParseLines(fromLine, lastLine); } catch (Exception e) { Debug.LogException(e); } //if (toLineInclusive < textBuffer.lines.Count) //{ // progressiveParseLine = toLineInclusive + 1; // return ProgressiveParser; //} //else { // TODO: Temporary solution, discarding all unused invalid parse tree nodes if (parseTree != null && parseTree.root != null) parseTree.root.CleanUp(); } //ParseAll(assetPath); // t.Stop(); // Debug.Log("Updated parser for lines " + (fromLine + 1) + "-" + (toLineInclusive + 1) + " in " + t.ElapsedMilliseconds + " ms"); return null; }
private static bool AutoFetchChanges() { if (repository == null || !IsValidRepo || !Settings.AutoFetch) { return(false); } Remote remote = repository.Network.Remotes.FirstOrDefault(); if (remote == null) { return(false); } GitProfilerProxy.BeginSample("Git automatic fetching"); try { repository.Network.Fetch(remote, new FetchOptions() { CredentialsProvider = GitCredentialsManager.FetchChangesAutoCredentialHandler, OnTransferProgress = FetchTransferProgressHandler }); } catch (Exception e) { Debug.LogErrorFormat("Automatic Fetching from remote: {0} with URL: {1} Failed!", remote.Name, remote.Url); Debug.LogException(e); } finally { EditorUtility.ClearProgressBar(); } GitProfilerProxy.EndSample(); return(false); }
void ReceivedUDPPacket(IAsyncResult result) { try { receivedBytes = client.EndReceive(result, ref ipEndPoint); var len = receivedBytes.Length; // we only use the buffer until the end, should wrap around if (bufferIndex + len > bufferSize) { Debug.LogError("Buffer finished, should fix this.."); return; } Buffer.BlockCopy(receivedBytes, 0, dump, bufferIndex, len); bufferIndex += len; if (bufferIndex - bufferFrameStart >= imageSize) { frameIndex.Enqueue(bufferFrameStart); frameBufferCount++; bufferFrameStart += imageSize; } } catch (Exception e) { Debug.LogException(e); } client.BeginReceive(AC, obj); }
/// <summary> /// Writes the specified path to the projects git ignore file located at the root of the repository. /// </summary> /// <param name="ignoredPath"></param> public static void WritePathToGitIgnore(string ignoredPath) { if (string.IsNullOrEmpty(ignoredPath)) { Debug.LogError("You cannot pass null or empty parameter."); return; } var rootDir = RepositoryRootDir; ignoredPath = ignoredPath.Replace($"{rootDir.ToBackSlashes()}/", string.Empty); var directory = ignoredPath.Replace(Path.GetFileName(ignoredPath), Path.GetFileNameWithoutExtension(ignoredPath)); directory = directory.Substring(0, directory.LastIndexOf("/", StringComparison.Ordinal)); var gitIgnoreFilePath = $"{rootDir}\\.gitignore"; if (File.Exists(gitIgnoreFilePath)) { bool addPath = true; try { // Create a new StreamReader, tell it which file to read and what encoding the file was saved as // Immediately clean up the reader after this block of code is done. using (var reader = new StreamReader(gitIgnoreFilePath)) { // While there's lines left in the text file, do this: string line; do { line = reader.ReadLine(); if (!string.IsNullOrEmpty(line) && (line.Equals(ignoredPath) || line.Contains(directory))) { // Don't add the line if it already exists. addPath = false; } }while (line != null); // Done reading, close the reader and return true to broadcast success. reader.Close(); } } // If anything broke in the try block, we throw an exception with information on what didn't work. catch (Exception e) { Debug.LogException(e); } if (addPath) { File.AppendAllText(gitIgnoreFilePath, $"{ignoredPath}{Environment.NewLine}", Encoding.UTF8); } } else { File.WriteAllText(gitIgnoreFilePath, $"{ignoredPath}{Environment.NewLine}", Encoding.UTF8); } }
/// <summary> /// 停止监听ADB /// </summary> void StopADB() { if (mADBProcess == null) { return; } try { if (mADBProcess != null && !mADBProcess.HasExited) { mADBProcess.CancelOutputRead(); mADBProcess.CancelErrorRead(); mADBProcess.Kill(); } EditorApplication.update -= ParseADBMsg; } catch (Exception ex) { Debug.LogException(ex); } finally { mADBProcess = null; } }
GameObject LoadGltf(List <string> warnings) { // This is intended to be identical to using GltfModelBuilder, except synchronous. GameObject go; bool fromPoly = (m_Location.GetLocationType() == Location.Type.PolyAssetId); string localPath = m_Location.AbsolutePath; string assetLocation = Path.GetDirectoryName(localPath); // Synchronous, so don't use slow image loading var loader = new TiltBrushUriLoader(localPath, assetLocation, loadImages: false); try { ImportGltf.GltfImportResult result = ImportGltf.Import( localPath, loader, new ImportMaterialCollector(assetLocation, uniqueSeed: localPath), fromPoly ? kPolyGltfImportOptions : kGltfImportOptions); go = result.root; m_ImportMaterialCollector = (ImportMaterialCollector)result.materialCollector; } catch (Exception ex) { m_LoadError = new LoadError("Invalid data", ex.Message); go = null; m_AllowExport = false; Debug.LogException(ex); } m_AllowExport = (go != null); return(go); }
private static void OnUpdate() { lock (new object()) { try { if (_queue == null || _queue.Count <= 0) { return; } _queue.ForEach(action => { if (action != null) { action(); } }); _queue.Clear(); } catch (Exception e) { Debug.LogException(e); if (_queue != null) { _queue.Clear(); } } } }
internal bool Update() { if (checkRequires) { UpdateRequires(); } if (!isDone) { return(true); } if (completed == null) { return(false); } try { completed.Invoke(this); } catch (Exception ex) { Debug.LogException(ex); } completed = null; return(false); }
private static void LogToFile(string msg) { if (!_hasAttemptedOpen) { var logFilePath = PathUtility.GetLogFilePath(); try { _fileStream = File.Open(logFilePath, FileMode.Append, FileAccess.Write, FileShare.Read); _logWriter = new StreamWriter(_fileStream, Encoding.UTF8); } catch (Exception e) { Debug.LogError("Error opening TypeSafe log file at " + logFilePath); Debug.LogException(e); } _hasAttemptedOpen = true; } if (_logWriter == null) { return; } _logWriter.Write(DateTime.Now.ToString("s")); _logWriter.Write("\t"); _logWriter.WriteLine(msg); _logWriter.Flush(); }
public static Texture2D ConvertToTexture(byte[] bytes, string name) { try { var texture = new Texture2D(0, 0, TextureFormat.ARGB32, false, true) { name = name, hideFlags = HideFlags.HideAndDontSave }; //Texture2D.LoadImage changed to an extension method in Unity 2017 //Compiling it with the old method will make the module stop working on 2017 //Compiling it with the extension method will make the module stop working with older versions var imageConversionClass = typeof(Texture2D).Assembly.GetType("UnityEngine.ImageConversion", false); if (imageConversionClass == null) { var loadMethod = typeof(Texture2D).GetMethod("LoadImage", new Type[] { typeof(byte[]) }); loadMethod.Invoke(texture, new object[] { bytes }); } else { var loadMethod = imageConversionClass.GetMethod("LoadImage", new Type[] { typeof(Texture2D), typeof(byte[]) }); loadMethod.Invoke(null, new object[] { texture, bytes }); } return(texture); } catch (Exception e) { Debug.LogException(e); return(null); } }
public static void LogException(this System.Exception exception) { if (debugable) { UnityDebug.LogException(exception); } }
private static void ShowWarningOnUnexpectedScriptEditor(string path) { // Show warning, when Unity was started from Rider, but external editor is different https://github.com/JetBrains/resharper-unity/issues/1127 try { var args = Environment.GetCommandLineArgs(); var commandlineParser = new CommandLineParser(args); if (commandlineParser.Options.ContainsKey("-riderPath")) { var originRiderPath = commandlineParser.Options["-riderPath"]; var originRealPath = GetEditorRealPath(originRiderPath); var originVersion = RiderPathLocator.GetBuildNumber(originRealPath); var version = RiderPathLocator.GetBuildNumber(path); if (originVersion != null && originVersion != version) { Debug.LogWarning("Unity was started by a version of Rider that is not the current default external editor. Advanced integration features cannot be enabled."); Debug.Log($"Unity was started by Rider {originVersion}, but external editor is set to: {path}"); } } } catch (Exception e) { Debug.LogException(e); } }
static String _Md5Asset( String filePath, MD5CryptoServiceProvider md5Service, byte[] buffer, StringBuilder sb ) { try { int bytesRead = 0; using ( var file = FileOpenRead( filePath ) ) { while ( ( bytesRead = file.Read( buffer, 0, buffer.Length ) ) > 0 ) { md5Service.TransformBlock( buffer, 0, bytesRead, buffer, 0 ); } } var meta = filePath + ".meta"; if ( File.Exists( meta ) ) { var lines = ReadFileLines( meta ); var idx = lines.FindIndex( "timeCreated:", ( name, tag ) => name.StartsWith( tag ) ); if ( idx != -1 ) { var _lines = lines.ToList(); _lines.RemoveAt( idx ); lines = _lines.ToArray(); } var content = String.Join( "\n", lines ); var bytes = Encoding.ASCII.GetBytes( content ); md5Service.TransformBlock( bytes, 0, bytes.Length, bytes, 0 ); } md5Service.TransformFinalBlock( buffer, 0, 0 ); var hashBytes = md5Service.Hash; for ( int i = 0; i < hashBytes.Length; i++ ) { sb.Append( hashBytes[ i ].ToString( "x2" ) ); } return sb.ToString(); } catch ( Exception e ) { Debug.LogException( e ); } return String.Empty; }
private static object[] NotifyLocalListeners(string eventType, object[] data, bool notifyWildcard) { List <Func <string, object[], object> > handlers = null; var result = new object[0]; if (s_Events.TryGetValue(eventType, out handlers)) { try { result = handlers.Select(handler => handler(eventType, data)).ToArray(); } catch (Exception e) { result = new object[] { e }; Console.WriteLine(e); } } if (notifyWildcard && s_Events.TryGetValue("*", out handlers)) { try { foreach (var handler in handlers) { handler(eventType, data); } } catch (Exception ex) { Debug.LogException(ex); } } return(result); }
internal override void Load() { if (!string.IsNullOrEmpty(m_AssetBundleName)) { m_Bundle = XAsset.Get().LoadBundle(m_AssetBundleName); if (m_Bundle != null) { SceneManager.LoadScene(m_SceneName, m_LoadSceneMode); } } else { try { SceneManager.LoadScene(m_SceneName, m_LoadSceneMode); m_LoadState = ELoadState.LoadAsset; } catch (Exception e) { Debug.LogException(e); Error = e.ToString(); m_LoadState = ELoadState.Loaded; } } }
/// Update an existing file. Make sure mimetype and existing id are specified. file paramater will /// be altered during this function. public async Task UpdateFileAsync(DriveData.File file, Stream dataStream, CancellationToken token, IProgress <long> progress = null) { Debug.Assert(!string.IsNullOrEmpty(file.Id)); Debug.Assert(!string.IsNullOrEmpty(file.MimeType)); Debug.Assert(dataStream.CanSeek); string id = file.Id; file.Id = null; file.Parents = null; var uploader = m_DriveService.Files.Update(file, id, dataStream, file.MimeType); if (progress != null) { uploader.ProgressChanged += (p) => progress.Report(p.BytesSent); } long position = dataStream.Position; var result = await Retry(() => { dataStream.Seek(position, SeekOrigin.Begin); return(uploader.UploadAsync(token)); }); if (result.Status != UploadStatus.Completed && !token.IsCancellationRequested) { Debug.LogException(new DriveSync.DataTransferError("Google Drive file update failed.", result.Exception)); } await RefreshFreeSpaceAsync(token); }
public static void EpicDebugLog(LogMessage message) { switch (message.Level) { case LogLevel.Info: Debug.Log($"<color=green> Epic Manager: Category - {message.Category} Message - {message.Message} </color>"); break; case LogLevel.Error: Debug.LogError($"<color=orange> Epic Manager: Category - {message.Category} Message - {message.Message} </color>"); break; case LogLevel.Warning: Debug.LogWarning($"<color=yellow> Epic Manager: Category - {message.Category} Message - {message.Message} </color>"); break; case LogLevel.Fatal: Debug.LogException( new Exception($"<color=red> Epic Manager: Category - {message.Category} Message - {message.Message} </color>")); break; default: Debug.Log( $"<color=purple> Epic Manager: Unknown log processing. Category - {message.Category} Message - {message.Message} </color>"); break; } }