void DrawDependencyView(ProjectIssue issue, DependencyNode root) { EditorGUILayout.BeginVertical(GUI.skin.box, GUILayout.Height(LayoutSize.DependencyViewHeight)); m_Preferences.dependencies = BoldFoldout(m_Preferences.dependencies, m_Desc.dependencyViewGuiContent); if (m_Preferences.dependencies) { if (root != null) { var r = EditorGUILayout.GetControlRect(GUILayout.ExpandHeight(true)); dependencyView.OnGUI(r); } else if (issue != null) { GUIStyle s = new GUIStyle(EditorStyles.textField); s.normal.textColor = Color.yellow; EditorGUILayout.LabelField(k_AnalysisIsRequiredText, s, GUILayout.MaxHeight(LayoutSize.FoldoutMaxHeight)); } else { EditorGUILayout.LabelField(k_NoIssueSelectedText); } } EditorGUILayout.EndVertical(); }
public async Task <IActionResult> AddIssue(AddNewIssueViewModel model) { if (ModelState.IsValid) { Console.WriteLine("Testing"); var userId = userManager.GetUserId(User); var currentUser = await userManager.FindByIdAsync(userId); var userClaims = await userManager.GetClaimsAsync(currentUser); Global.globalCurrentUserClaims = userClaims.ToList(); var IsUserManagerLevel = ClaimsLevel.IsManager(userClaims.ToList(), model.NewIssue.AssociatedProject); if (IsUserManagerLevel && model.NewIssue.AssigneeUserId != null) { var assignedUser = await userManager.FindByIdAsync(model.NewIssue.AssigneeUserId); model.NewIssue.AssigneeUserName = assignedUser.UserName; } model.NewIssue.SubmitterId = userManager.GetUserId(User); model.NewIssue.SubmitterUserName = userManager.GetUserName(User); model.NewIssue.CreatedTime = DateTime.Now; var issue = _issueRepository.AddIssue(model.NewIssue); if (issue.Title == null) { issue.Title = $"issue {issue.IssueId}"; _issueRepository.Update(issue); } var projectIssue = new ProjectIssue { ProjectId = issue.AssociatedProject, IssueId = issue.IssueId }; _projectRepository.AddProjectIssues(projectIssue); Console.WriteLine("HERERERER"); var fileNames = new List <ScreenShots>(); if (Global.globalInitialScreenShots == true) { Console.WriteLine("Globally"); fileNames = await UploadScreenShotsToStorage(issue.IssueId); } Global.InitialScreenShots = false; _issueRepository.AddScreenShots(fileNames); Console.WriteLine(_issueRepository.ScreenShots(issue.IssueId)); return(RedirectToAction("projectissues", "Project", new { projectId = model.NewIssue.AssociatedProject })); } return(View()); }
void AddVariants(Shader shader, string assetPath, int id, List <ShaderVariantData> shaderVariants, Action <ProjectIssue> onIssueFound) { var shaderName = shader.name; var descriptor = new ProblemDescriptor ( id++, shaderName ); foreach (var shaderVariantData in shaderVariants) { var compilerData = shaderVariantData.compilerData; var keywords = GetShaderKeywords(shader, compilerData.shaderKeywordSet.GetShaderKeywords()); var issue = new ProjectIssue(descriptor, shaderName, IssueCategory.ShaderVariants, new Location(assetPath)); issue.SetCustomProperties(new string[(int)ShaderVariantProperty.Num] { k_NoRuntimeData, compilerData.shaderCompilerPlatform.ToString(), shaderVariantData.passName, KeywordsToString(keywords), compilerData.shaderRequirements.ToString() }); onIssueFound(issue); } }
public bool Find(ProjectIssue issue) { if (ProjectIssue == issue) { return(true); } return(children != null && children.FirstOrDefault(child => (child as IssueTableItem).ProjectIssue == issue) != null); }
private static void AnalyzePackedAssets(Action <ProjectIssue> onIssueFound, BuildReport buildReport) { foreach (var packedAsset in buildReport.packedAssets) { // note that there can be several entries for each source asset (for example, a prefab can reference a Texture, a Material and a shader) var dict = new Dictionary <GUID, List <PackedAssetInfo> >(); foreach (var content in packedAsset.contents) { var assetPath = content.sourceAssetPath; if (!Path.HasExtension(assetPath)) { continue; } if (Path.GetExtension(assetPath).Equals(".cs")) { continue; } if (!dict.ContainsKey(content.sourceAssetGUID)) { dict.Add(content.sourceAssetGUID, new List <PackedAssetInfo>()); } dict[content.sourceAssetGUID].Add(content); } foreach (var entry in dict) { var content = entry.Value[0]; // sourceAssets are the same for all entries var assetPath = content.sourceAssetPath; ulong sum = 0; foreach (var v in entry.Value) { sum += v.packedSize; } var assetName = Path.GetFileNameWithoutExtension(assetPath); string description; if (entry.Value.Count > 1) { description = string.Format("{0} ({1})", assetName, entry.Value.Count); } else { description = assetName; } var issue = new ProjectIssue(k_Descriptor, description, IssueCategory.BuildFiles, new Location(assetPath)); issue.SetCustomProperties(new[] { sum.ToString(), packedAsset.shortPath }); onIssueFound(issue); } } }
public void UninitializedIssueTestPasses() { var uninitialised = new ProjectIssue(s_Descriptor, "dummy issue", IssueCategory.Code); Assert.AreEqual(string.Empty, uninitialised.filename); Assert.AreEqual(string.Empty, uninitialised.relativePath); Assert.AreEqual(string.Empty, uninitialised.GetCallingMethod()); Assert.AreEqual(string.Empty, uninitialised.name); Assert.False(uninitialised.isPerfCriticalContext); }
public void UninitializedIssueTestPasses() { var uninitialised = new ProjectIssue(new ProblemDescriptor { }, "dummy issue", IssueCategory.ApiCalls); Assert.AreEqual(string.Empty, uninitialised.filename); Assert.AreEqual(string.Empty, uninitialised.relativePath); Assert.AreEqual(string.Empty, uninitialised.callingMethod); Assert.AreEqual(string.Empty, uninitialised.name); }
private void SetupContribute() { if (IsManager) { item = (ItemID == 0) ? new SPA.ProjectIssue() : new SPA.ProjectIssue(ItemID); } else { Response.Redirect(string.Format("{0}/{1}?code={2}", SPContext.Current.Web.Url, Message.URL_USERMESSAGE, Message.Code.MngrAccessReq), false); } }
public void OnGUI() { ProblemDescriptor problemDescriptor = null; var selectedItems = m_Table.GetSelectedItems(); var selectedDescriptors = selectedItems.Select(i => i.ProblemDescriptor); var selectedIssues = selectedItems.Select(i => i.ProjectIssue); // find out if all descriptors are the same var firstDescriptor = selectedDescriptors.FirstOrDefault(); if (selectedDescriptors.Count() == selectedDescriptors.Count(d => d.id == firstDescriptor.id)) { problemDescriptor = firstDescriptor; } ProjectIssue issue = null; if (selectedIssues.Count() == 1) { issue = selectedIssues.First(); } EditorGUILayout.BeginHorizontal(); DrawTable(selectedIssues.ToArray()); if (m_Desc.showRightPanels) { EditorGUILayout.BeginVertical(GUILayout.Width(LayoutSize.FoldoutWidth)); DrawFoldouts(problemDescriptor); EditorGUILayout.EndVertical(); } EditorGUILayout.EndHorizontal(); if (m_Desc.showDependencyView) { DependencyNode dependencies = null; if (issue != null && issue.dependencies != null) { if (issue.dependencies as CallTreeNode != null) { dependencies = issue.dependencies.GetChild(); // skip self } else { dependencies = issue.dependencies; } } dependencyView.SetRoot(dependencies); DrawDependencyView(issue, dependencies); } }
public static string GetCallingMethod(this ProjectIssue issue) { if (issue.dependencies == null) return string.Empty; if (!issue.dependencies.HasChildren()) return string.Empty; var callTree = issue.dependencies.GetChild() as CallTreeNode; if (callTree == null) return string.Empty; return callTree.name; }
public static string GetProperty(this ProjectIssue issue, PropertyType propertyType) { switch (propertyType) { case PropertyType.Severity: return(issue.severity.ToString()); case PropertyType.Area: return(issue.descriptor.area); case PropertyType.FileType: var ext = issue.location.Extension; if (ext.StartsWith(".")) { ext = ext.Substring(1); } return(ext); case PropertyType.Description: return(issue.description); case PropertyType.Filename: var filename = string.Format("{0}", issue.filename); if (string.IsNullOrEmpty(filename)) { return(k_NotAvailable); } if (filename.EndsWith(".cs")) { filename += string.Format(":{0}", issue.line); } return(filename); case PropertyType.Path: var path = string.Format("{0}", issue.relativePath); if (string.IsNullOrEmpty(path)) { return(k_NotAvailable); } if (path.EndsWith(".cs")) { path += string.Format(":{0}", issue.line); } return(path); case PropertyType.CriticalContext: return(issue.isPerfCriticalContext.ToString()); default: var propertyIndex = propertyType - PropertyType.Num; return(issue.GetCustomProperty(propertyIndex)); } }
public bool Match(ProjectIssue issue) { if (!m_MainFilter.Match(issue)) { return(false); } if (m_HideCompiledVariants) { return(!issue.GetCustomPropertyAsBool((int)ShaderVariantProperty.Compiled)); } return(true); }
public bool Match(ProjectIssue issue) { UnityEngine.Profiling.Profiler.BeginSample("MatchAssembly"); var matchAssembly = !m_ActiveAnalysisView.desc.showAssemblySelection || m_AssemblySelection != null && (m_AssemblySelection.Contains(issue.assembly) || m_AssemblySelection.ContainsGroup("All")); UnityEngine.Profiling.Profiler.EndSample(); if (!matchAssembly) { return(false); } UnityEngine.Profiling.Profiler.BeginSample("MatchArea"); var matchArea = m_AreaSelection.Contains(issue.descriptor.area) || m_AreaSelection.ContainsGroup("All"); UnityEngine.Profiling.Profiler.EndSample(); if (!matchArea) { return(false); } if (!m_ProjectAuditor.config.DisplayMutedIssues) { UnityEngine.Profiling.Profiler.BeginSample("IsMuted"); var muted = m_ProjectAuditor.config.GetAction(issue.descriptor, issue.callingMethod) == Rule.Action.None; UnityEngine.Profiling.Profiler.EndSample(); if (muted) { return(false); } } if (m_ActiveAnalysisView.desc.showCritical && m_ProjectAuditor.config.DisplayOnlyCriticalIssues && !issue.isPerfCriticalContext) { return(false); } if (!string.IsNullOrEmpty(m_SearchText)) { if (!MatchesSearch(issue.description) && !MatchesSearch(issue.filename) && !MatchesSearch(issue.name)) { return(false); } } return(true); }
public bool Match(ProjectIssue issue) { // return false if the issue does not match one of these criteria: // - assembly name, if applicable // - area // - is not muted, if enabled // - critical context, if enabled/applicable Profiler.BeginSample("MatchAssembly"); var matchAssembly = !activeView.desc.showAssemblySelection || m_AssemblySelection != null && (m_AssemblySelection.Contains(issue.GetCustomProperty((int)CodeProperty.Assembly)) || m_AssemblySelection.ContainsGroup("All")); Profiler.EndSample(); if (!matchAssembly) { return(false); } Profiler.BeginSample("MatchArea"); var matchArea = !activeView.desc.showAreaSelection || m_AreaSelection.ContainsAny(issue.descriptor.area.Split('|')) || m_AreaSelection.ContainsGroup("All"); Profiler.EndSample(); if (!matchArea) { return(false); } if (!m_Preferences.mutedIssues && activeView.desc.showMuteOptions) { Profiler.BeginSample("IsMuted"); var muted = m_ProjectAuditor.config.GetAction(issue.descriptor, issue.GetCallingMethod()) == Rule.Severity.None; Profiler.EndSample(); if (muted) { return(false); } } if (activeView.desc.showCritical && m_Preferences.onlyCriticalIssues && !issue.isPerfCriticalContext) { return(false); } return(m_TextFilter.Match(issue)); }
void ProcessCompilerMessages(string assemblyName, CompilerMessage[] compilerMessages, Action <ProjectIssue> onIssueFound) { foreach (var message in compilerMessages) { var descriptor = (ProblemDescriptor)null; if (m_RuntimeDescriptors.ContainsKey(message.code)) { descriptor = m_RuntimeDescriptors[message.code]; } else { var severity = Rule.Severity.Info; switch (message.type) { case CompilerMessageType.Error: severity = Rule.Severity.Error; break; case CompilerMessageType.Warning: severity = Rule.Severity.Warning; break; case CompilerMessageType.Info: severity = Rule.Severity.Info; break; } descriptor = new ProblemDescriptor ( k_CompilerMessageFirstId + m_RuntimeDescriptors.Count, message.code, Area.CPU ) { severity = severity }; m_RuntimeDescriptors.Add(message.code, descriptor); } var issue = new ProjectIssue(descriptor, message.message, IssueCategory.CodeCompilerMessages, new Location(message.file, message.line), new[] { message.code, assemblyName }); onIssueFound(issue); } }
public void CustomPropertiesAreSet() { string[] properties = { "property #0", "property #1" }; var issue = new ProjectIssue(s_Descriptor, "dummy issue", IssueCategory.Code); issue.SetCustomProperties(properties); Assert.True(issue.GetCustomProperty(0).Equals(properties[0])); Assert.True(issue.GetCustomProperty(1).Equals(properties[1])); }
public bool Match(ProjectIssue issue) { if (!m_MainFilter.Match(issue)) { return(false); } var compiled = issue.GetCustomPropertyAsBool(ShaderVariantProperty.Compiled); if (compiled && m_ShowCompiledVariants) { return(true); } if (!compiled && m_ShowUncompiledVariants) { return(true); } return(false); }
public void UninitializedIssueTestPasses() { var p = new ProblemDescriptor ( 102001, "test", Area.CPU, "this is not actually a problem", "do nothing" ); var uninitialised = new ProjectIssue(p, "dummy issue", IssueCategory.ApiCalls); Assert.AreEqual(string.Empty, uninitialised.filename); Assert.AreEqual(string.Empty, uninitialised.relativePath); Assert.AreEqual(string.Empty, uninitialised.callingMethod); Assert.AreEqual(string.Empty, uninitialised.name); Assert.False(uninitialised.isPerfCriticalContext); }
void WriteIssue(ProjectIssue issue) { var stringBuilder = new StringBuilder(); for (int i = 0; i < m_Layout.properties.Length; i++) { var columnType = m_Layout.properties[i].type; var prop = issue.GetProperty(columnType); stringBuilder.Append('"'); stringBuilder.Append(prop); stringBuilder.Append('"'); if (i + 1 < m_Layout.properties.Length) { stringBuilder.Append(","); } } m_StreamWriter.WriteLine(stringBuilder); }
void AddVariants(Shader shader, string assetPath, int id, List <ShaderVariantData> shaderVariants, Action <ProjectIssue> onIssueFound) { var shaderName = shader.name; var descriptor = new ProblemDescriptor ( id++, shaderName, Area.BuildSize, string.Empty, string.Empty ); foreach (var shaderVariantData in shaderVariants) { var compilerData = shaderVariantData.compilerData; var shaderKeywordSet = compilerData.shaderKeywordSet.GetShaderKeywords().ToArray(); #if UNITY_2019_3_OR_NEWER var keywords = shaderKeywordSet.Select(keyword => ShaderKeyword.IsKeywordLocal(keyword) ? ShaderKeyword.GetKeywordName(shader, keyword) : ShaderKeyword.GetGlobalKeywordName(keyword)).ToArray(); #else var keywords = shaderKeywordSet.Select(keyword => keyword.GetKeywordName()).ToArray(); #endif var keywordString = String.Join(", ", keywords); if (string.IsNullOrEmpty(keywordString)) { keywordString = "<no keywords>"; } var issue = new ProjectIssue(descriptor, shaderName, IssueCategory.ShaderVariants, new Location(assetPath)); issue.SetCustomProperties(new[] { compilerData.shaderCompilerPlatform.ToString(), shaderVariantData.passName, keywordString, }); onIssueFound(issue); } }
public async Task <IActionResult> MyProjects() { var userId = userManager.GetUserId(HttpContext.User); var userName = userManager.GetUserName(HttpContext.User); var currentUser = await userManager.FindByIdAsync(userId); var currentUserClaims = await userManager.GetClaimsAsync(currentUser); Global.globalCurrentUserClaims = currentUserClaims.ToList(); var projectList = _projectRepository.GetAllOwnedProjects(userId).Result; foreach (var project in projectList) { var projectIssueList = new List <ProjectIssue>(); var projectIssues = _issueRepository.GetAllProjectIssues(project.ProjectId); foreach (var issue in projectIssues) { var projectIssue = new ProjectIssue { IssueId = issue.IssueId, ProjectId = issue.AssociatedProject }; projectIssueList.Add(projectIssue); } project.ProjectIssues = projectIssueList; } var viewModel = new MyProjectsViewModel { ProjectList = projectList, UserId = userId }; return(View(viewModel)); }
private bool SaveItem() { bool success = false; try { bool isUpdate = (IView == ItemView.Edit); item = (isUpdate) ? new SPA.ProjectIssue(ItemID) : new SPA.ProjectIssue(); item.Issue = txtIssue.Text.Trim(); item.ActionTaken = txtActionTaken.Text.Trim(); item.ModifiedBy = CurrentUser.DisplayName; if (!isUpdate) { item.CreatedBy = item.ModifiedBy; if (item.Insert()) { success = true; } } else { if (item.Update()) { success = true; } } ItemID = (success) ? item.ID : 0; } catch (Exception ex) { SPA.Error.WriteError(ex); if (ShowDebug) { lblErrorMessage.Text = ex.ToString(); } } return(success); }
void AddShader(Shader shader, string assetPath, int id, Action <ProjectIssue> onIssueFound) { // set initial state (-1: info not available) var variantCount = s_ShaderVariantData.Count > 0 ? 0 : -1; #if UNITY_2018_2_OR_NEWER // add variants first if (s_ShaderVariantData.ContainsKey(shader)) { var variants = s_ShaderVariantData[shader]; variantCount = variants.Count; AddVariants(shader, assetPath, id++, variants, onIssueFound); } #endif var shaderName = shader.name; var shaderHasError = false; #if UNITY_2019_4_OR_NEWER shaderHasError = ShaderUtil.ShaderHasError(shader); #endif if (shaderHasError) { shaderName = Path.GetFileNameWithoutExtension(assetPath) + ": Parse Error"; var issueWithError = new ProjectIssue(k_ParseErrorDescriptor, shaderName, IssueCategory.Shaders, new Location(assetPath)); issueWithError.SetCustomProperties((int)ShaderProperty.Num, k_NotAvailable); onIssueFound(issueWithError); return; } var descriptor = new ProblemDescriptor ( id++, shaderName ); /* * var usedBySceneOnly = false; * if (m_GetShaderVariantCountMethod != null) * { * var value = (ulong)m_GetShaderVariantCountMethod.Invoke(null, new object[] { shader, usedBySceneOnly}); * variantCount = value.ToString(); * } */ var passCount = -1; var globalKeywords = ShaderUtilProxy.GetShaderGlobalKeywords(shader); var localKeywords = ShaderUtilProxy.GetShaderLocalKeywords(shader); var hasInstancing = ShaderUtilProxy.HasInstancing(shader); var subShaderIndex = ShaderUtilProxy.GetShaderActiveSubshaderIndex(shader); var isSrpBatcherCompatible = ShaderUtilProxy.GetSRPBatcherCompatibilityCode(shader, subShaderIndex) == 0; #if UNITY_2019_1_OR_NEWER passCount = shader.passCount; #endif var issue = new ProjectIssue(descriptor, shaderName, IssueCategory.Shaders, new Location(assetPath)); issue.SetCustomProperties(new string[(int)ShaderProperty.Num] { variantCount == -1 ? k_NotAvailable : variantCount.ToString(), passCount == -1 ? k_NotAvailable : passCount.ToString(), (globalKeywords == null || localKeywords == null) ? k_NotAvailable : (globalKeywords.Length + localKeywords.Length).ToString(), shader.renderQueue.ToString(), hasInstancing.ToString(), isSrpBatcherCompatible.ToString() }); onIssueFound(issue); }
void AddShader(Shader shader, string assetPath, int id, Action <ProjectIssue> onIssueFound) { var variantCount = k_NotAvailable; #if UNITY_2018_2_OR_NEWER // add variants first if (s_ShaderVariantData != null) { if (s_ShaderVariantData.ContainsKey(shader)) { var variants = s_ShaderVariantData[shader]; variantCount = variants.Count.ToString(); AddVariants(shader, assetPath, id++, variants, onIssueFound); } else { variantCount = "0"; } } #endif var shaderName = shader.name; var shaderHasError = false; #if UNITY_2019_4_OR_NEWER shaderHasError = ShaderUtil.ShaderHasError(shader); #endif if (shaderHasError) { shaderName = Path.GetFileNameWithoutExtension(assetPath) + ": Parse Error"; var issueWithError = new ProjectIssue(k_ParseErrorDescriptor, shaderName, IssueCategory.Shaders, new Location(assetPath)); issueWithError.SetCustomProperties(new[] { k_NotAvailable, k_NotAvailable, k_NotAvailable, k_NotAvailable, k_NotAvailable, k_NotAvailable }); onIssueFound(issueWithError); return; } var descriptor = new ProblemDescriptor ( id++, shaderName, Area.BuildSize ); var passCount = k_NotAvailable; var keywordCount = k_NotAvailable; var hasInstancing = k_NotAvailable; /* * var usedBySceneOnly = false; * if (m_GetShaderVariantCountMethod != null) * { * var value = (ulong)m_GetShaderVariantCountMethod.Invoke(null, new object[] { shader, usedBySceneOnly}); * variantCount = value.ToString(); * } */ if (m_GetShaderGlobalKeywordsMethod != null && m_GetShaderLocalKeywordsMethod != null) { var globalKeywords = (string[])m_GetShaderGlobalKeywordsMethod.Invoke(null, new object[] { shader }); var localKeywords = (string[])m_GetShaderLocalKeywordsMethod.Invoke(null, new object[] { shader }); keywordCount = (globalKeywords.Length + localKeywords.Length).ToString(); } if (m_HasInstancingMethod != null) { var value = (bool)m_HasInstancingMethod.Invoke(null, new object[] { shader }); hasInstancing = value.ToString(); } // srp batcher var isSrpBatcherCompatible = false; if (m_GetShaderGlobalKeywordsMethod != null && m_GetShaderLocalKeywordsMethod != null) { #if UNITY_2019_1_OR_NEWER if (RenderPipelineManager.currentPipeline != null) { int subShader = (int)m_GetShaderActiveSubshaderIndex.Invoke(null, new object[] { shader }); int SRPErrCode = (int)m_GetSRPBatcherCompatibilityCode.Invoke(null, new object[] { shader, subShader }); isSrpBatcherCompatible = (0 == SRPErrCode); } #endif } #if UNITY_2019_1_OR_NEWER passCount = shader.passCount.ToString(); #endif var issue = new ProjectIssue(descriptor, shaderName, IssueCategory.Shaders, new Location(assetPath)); issue.SetCustomProperties(new[] { variantCount, passCount, keywordCount, shader.renderQueue.ToString(), hasInstancing, isSrpBatcherCompatible.ToString() }); onIssueFound(issue); }
public void Audit(Action <ProjectIssue> onIssueFound, Action onComplete, IProgressBar progressBar = null) { var shaderPathMap = new Dictionary <Shader, string>(); var shaderGuids = AssetDatabase.FindAssets("t:shader"); foreach (var guid in shaderGuids) { var assetPath = AssetDatabase.GUIDToAssetPath(guid); // skip editor shaders if (assetPath.IndexOf("/editor/", StringComparison.OrdinalIgnoreCase) != -1) { continue; } // vfx shaders are not currently supported if (Path.HasExtension(assetPath) && Path.GetExtension(assetPath).Equals(".vfx")) { continue; } var shader = AssetDatabase.LoadMainAssetAtPath(assetPath) as Shader; shaderPathMap.Add(shader, assetPath); } var id = k_ShaderVariantFirstId; if (s_ShaderVariantData == null) { var descriptor = new ProblemDescriptor ( id++, "Shader Variants analysis incomplete", Area.BuildSize, string.Empty, string.Empty ); var message = "Build the project to view the Shader Variants"; #if !UNITY_2018_2_OR_NEWER message = "This feature requires Unity 2018.2 or newer"; #endif var issue = new ProjectIssue(descriptor, message, IssueCategory.ShaderVariants); issue.SetCustomProperties(new[] { string.Empty, string.Empty, string.Empty }); onIssueFound(issue); } else { #if UNITY_2018_2_OR_NEWER // find hidden shaders var shadersInBuild = s_ShaderVariantData.Select(variant => variant.Key); foreach (var shader in shadersInBuild) { // skip shader if it's been removed since the last build if (shader == null) { continue; } if (!shaderPathMap.ContainsKey(shader)) { var assetPath = AssetDatabase.GetAssetPath(shader); shaderPathMap.Add(shader, assetPath); } } #endif } var sortedShaders = shaderPathMap.Keys.ToList().OrderBy(shader => shader.name); foreach (var shader in sortedShaders) { var assetPath = shaderPathMap[shader]; AddShader(shader, assetPath, id++, onIssueFound); } onComplete(); }
public IssueTableItem(int id, int depth, string displayName, ProblemDescriptor problemDescriptor, ProjectIssue projectIssue) : base(id, depth, displayName) { ProblemDescriptor = problemDescriptor; ProjectIssue = projectIssue; }
public void Audit(Action <ProjectIssue> onIssueFound, Action onComplete, IProgressBar progressBar = null) { var id = k_ShaderVariantFirstId; if (s_ShaderCompilerData == null) { var descriptor = new ProblemDescriptor ( id, "Shader analysis incomplete", Area.BuildSize, string.Empty, string.Empty ); var message = "Build the project and run Project Auditor analysis"; #if !UNITY_2018_2_OR_NEWER message = "This feature requires Unity 2018"; #endif var issue = new ProjectIssue(descriptor, message, IssueCategory.Shaders); issue.SetCustomProperties(new[] { string.Empty, string.Empty }); onIssueFound(issue); onComplete(); return; } var shaderGuids = AssetDatabase.FindAssets("t:shader"); foreach (var guid in shaderGuids) { var assetPath = AssetDatabase.GUIDToAssetPath(guid); var shader = AssetDatabase.LoadMainAssetAtPath(assetPath) as Shader; List <ShaderCompilerData> shaderCompilerDataContainer; s_ShaderCompilerData.TryGetValue(shader.name, out shaderCompilerDataContainer); if (shaderCompilerDataContainer != null) { var descriptor = new ProblemDescriptor ( id++, shader.name, Area.BuildSize, string.Empty, string.Empty ); foreach (var shaderCompilerData in shaderCompilerDataContainer) { var shaderKeywordSet = shaderCompilerData.shaderKeywordSet.GetShaderKeywords().ToArray(); #if UNITY_2019_3_OR_NEWER var keywords = shaderKeywordSet.Select(keyword => ShaderKeyword.IsKeywordLocal(keyword) ? ShaderKeyword.GetKeywordName(shader, keyword) : ShaderKeyword.GetGlobalKeywordName(keyword)).ToArray(); #else var keywords = shaderKeywordSet.Select(keyword => keyword.GetKeywordName()).ToArray(); #endif var keywordString = String.Join(", ", keywords); if (string.IsNullOrEmpty(keywordString)) { keywordString = "<no keywords>"; } var issue = new ProjectIssue(descriptor, shader.name, IssueCategory.Shaders, new Location(assetPath)); issue.SetCustomProperties(new[] { shaderCompilerData.shaderCompilerPlatform.ToString(), keywordString, }); onIssueFound(issue); } } } onComplete(); }
void AddShader(Shader shader, string assetPath, int id, Action <ProjectIssue> onIssueFound) { const string NotAvailable = "N/A"; var variantCount = NotAvailable; #if UNITY_2018_2_OR_NEWER // add variants first if (s_ShaderVariantData != null) { if (s_ShaderVariantData.ContainsKey(shader)) { var variants = s_ShaderVariantData[shader]; variantCount = variants.Count.ToString(); AddVariants(shader, assetPath, id++, variants, onIssueFound); } else { variantCount = "0"; } } #endif var shaderName = shader.name; var descriptor = new ProblemDescriptor ( id++, shaderName, Area.BuildSize, string.Empty, string.Empty ); var passCount = NotAvailable; var keywordCount = NotAvailable; var hasInstancing = NotAvailable; /* * var usedBySceneOnly = false; * if (m_GetShaderVariantCountMethod != null) * { * var value = (ulong)m_GetShaderVariantCountMethod.Invoke(null, new object[] { shader, usedBySceneOnly}); * variantCount = value.ToString(); * } */ if (m_GetShaderGlobalKeywordsMethod != null && m_GetShaderLocalKeywordsMethod != null) { var globalKeywords = (string[])m_GetShaderGlobalKeywordsMethod.Invoke(null, new object[] { shader }); var localKeywords = (string[])m_GetShaderLocalKeywordsMethod.Invoke(null, new object[] { shader }); keywordCount = (globalKeywords.Length + localKeywords.Length).ToString(); } if (m_HasInstancingMethod != null) { var value = (bool)m_HasInstancingMethod.Invoke(null, new object[] { shader }); hasInstancing = value ? "Yes" : "No"; } #if UNITY_2019_1_OR_NEWER passCount = shader.passCount.ToString(); #endif var issue = new ProjectIssue(descriptor, shader.name, IssueCategory.Shaders, new Location(assetPath)); issue.SetCustomProperties(new[] { variantCount, passCount, keywordCount, shader.renderQueue.ToString(), hasInstancing, }); onIssueFound(issue); }
public ProjectIssue AddProjectIssues(ProjectIssue issue) { _context.ProjectIssues.Add(issue); _context.SaveChanges(); return(issue); }