public StaticAnalysisEntry(
Object asset,
string assetAlias,
string assetCategory,
ShaderProgramFilter filter,
string filterName,
string filterCategory,
string testName,
BuildTarget buildTarget,
float timeout
)
{
errorString = null;
this.asset = asset;
this.filter = filter;
this.buildTarget = buildTarget;
this.timeout = timeout;
this.testName = new TestName(
string.IsNullOrEmpty(assetAlias) ? asset.ToString() : assetAlias,
assetCategory,
filterName,
filterCategory,
testName
);
}
public StaticAnalysisEntry(string error)
{
errorString = error;
asset = null;
filter = null;
testName = default;
buildTarget = 0;
timeout = 0;
}
public static IEnumerable <StaticAnalysisEntry> GetStaticAnalysisEntries(BuildTarget buildTarget)
{
var resource = PerformanceTestSettings.GetStaticAnalysisAsset() as EditorShaderStaticAnalysisAsset;
if (resource == null)
{
yield break;
}
foreach (var definition in resource.processAssetDefinitions)
{
// Skip when not included in this build target
if (definition.includeInTargets != null && Array.IndexOf(definition.includeInTargets, buildTarget) == -1)
{
continue;
}
if (definition.asset == null || definition.asset.Equals(null))
{
yield return(new StaticAnalysisEntry("Missing asset in definition."));
continue;
}
var assetType = definition.asset.GetType();
if (assetType != typeof(Material) &&
assetType != typeof(Shader) &&
assetType != typeof(ComputeShader))
{
yield return(new StaticAnalysisEntry($"Invalid asset type {assetType}"));
continue;
}
if (!definition.filter.Resolve(resource.filters, out var filter, out var errorMessage))
{
yield return(new StaticAnalysisEntry($"Invalid filter ({errorMessage})"));
continue;
}
var programFilter = ShaderProgramFilter.Parse(filter.passNameFilter, filter.keywordFilter);
yield return(new StaticAnalysisEntry(definition.asset,
definition.assetAlias,
definition.assetCategory,
programFilter,
filter.name,
filter.category,
definition.testName,
buildTarget,
resource.staticAnalysisTimeout));
}
}
IAsyncJob BuildMaterialReport()
{
m_ShaderFilter = ShaderProgramFilter.Parse(m_ShaderPassFilter, m_KeywordFilter);
return(EditorShaderTools.GenerateBuildReportAsync(ShaderAnalysis.ShaderAnalysisReport.New(m_Material, m_CurrentPlatform, m_ShaderFilter, m_BuildReportFeature, m_LogCompilerArguments)));
}
public static IEnumerator BuildDefinesFromMultiCompiles(List <HashSet <string> > multicompiles, List <HashSet <string> > defines, ShaderProgramFilter filter)
{
if (multicompiles.Count == 0)
{
defines.Add(new HashSet <string>());
yield break;
}
var mc = new string[multicompiles.Count][];
for (var i = 0; i < mc.Length; i++)
{
mc[i] = new string[multicompiles[i].Count];
multicompiles[i].CopyTo(mc[i]);
}
// current multicompile index
var indices = new int[multicompiles.Count];
while (true)
{
// Add an entry with current indices
var entry = new HashSet <string>();
for (var i = 0; i < indices.Length; i++)
{
var token = mc[i][indices[i]];
if (token == "_")
{
continue;
}
entry.Add(token);
}
var success = false;
if (filter != null && filter.includedKeywords.Count != 0)
{
foreach (var keywordSet in filter.includedKeywords)
{
if (keywordSet.IsSubsetOf(entry))
{
success = true;
break;
}
}
}
else
{
success = true;
}
if (success)
{
defines.Add(entry);
yield return(defines.Count);
}
var incrementIndex = indices.Length - 1;
while (true)
{
// increment last index
++indices[incrementIndex];
if (indices[incrementIndex] >= multicompiles[incrementIndex].Count)
{
// We have done all multicompiles at this index
// So increment previous indices
indices[incrementIndex] = 0;
--incrementIndex;
}
else
{
break;
}
// Loop complete
if (incrementIndex < 0)
{
break;
}
}
// Loop complete
if (incrementIndex < 0)
{
break;
}
}
}
