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);
}
