public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> data)
{
if (shader.name.StartsWith("Shapes/") == false)
{
return; // ignore all non-Shapes shaders
}
// Shapes immediate mode has to force instancing on.
// find variants that don't have an instancing counterpart, copy them, and add instancing
string GetKeywordsStrWithoutInstancing(ShaderCompilerData set)
{
return(string.Join(",", set.shaderKeywordSet.GetShaderKeywords()
#if UNITY_2019_3_OR_NEWER
.Select(ShaderKeyword.GetGlobalKeywordName).Where(a => a != ShaderKeyword.GetGlobalKeywordName(inst))
#else
.Select(a => a.GetKeywordName()).Where(a => a != inst.GetKeywordName())
#endif
.OrderBy(a => a)));
}
HashSet <string> thingsWithInstancing = new HashSet <string>(data.Where(x => x.shaderKeywordSet.IsEnabled(inst)).Select(GetKeywordsStrWithoutInstancing));
HashSet <string> thingsWithoutInstancing = new HashSet <string>(data.Where(x => !x.shaderKeywordSet.IsEnabled(inst)).Select(GetKeywordsStrWithoutInstancing));
thingsWithoutInstancing.ExceptWith(thingsWithInstancing); // filter out only the ones missing instancing versions
List <ShaderCompilerData> thingsToClone = data.Where(x => !x.shaderKeywordSet.IsEnabled(inst) && thingsWithoutInstancing.Contains(GetKeywordsStrWithoutInstancing(x))).ToList();
foreach (ShaderCompilerData thing in thingsToClone)
{
ShaderCompilerData copy = thing;
copy.shaderKeywordSet.Enable(inst);
data.Add(copy);
}
}
private string[] GetExistingShaderKeywords(Shader shader, IList <ShaderCompilerData> data)
{
return(data.SelectMany(d => d.shaderKeywordSet.GetShaderKeywords())
.Where(k => ShaderKeyword.IsKeywordLocal(k))
.Select(k => ShaderKeyword.GetKeywordName(shader, k))
.Where(kwd => WFCommonUtility.IsEnableKeyword(kwd)).Distinct().ToArray());
}
public ShaderVariantsInfo(Shader sh, PassType pass, string[] words)
{
int wordsLength = 0;
if (words != null)
{
wordsLength = words.Length;
}
this.shader = sh;
this.passType = pass;
this.keywords = words;
this.keywordInfos = new List <ShaderKeyword>(wordsLength);
for (int i = 0; i < wordsLength; ++i)
{
if (string.IsNullOrEmpty(words[i]))
{
continue;
}
ShaderKeyword shKeyword = new ShaderKeyword(sh, words[i]);
keywordInfos.Add(shKeyword);
}
keywordsForCheck = new List <string>();
foreach (var keywordInfo in keywordInfos)
{
if (!string.IsNullOrEmpty(ShaderKeyword.GetKeywordName(sh, keywordInfo)) &&
ShaderKeyword.GetKeywordType(sh, keywordInfo) != ShaderKeywordType.BuiltinDefault)
{
keywordsForCheck.Add(ShaderKeyword.GetKeywordName(sh, keywordInfo));
}
}
keywordsForCheck.Sort();
}
private string GetKeywordName(Shader shader, ShaderKeyword keyword)
{
#if UNITY_2021_2_OR_NEWER
return(keyword.name);
#else
return(ShaderKeyword.GetKeywordName(shader, keyword));
#endif
}
public static string GetKeywordName(ShaderKeyword k)
{
#if UNITY_2018_3_OR_NEWER
return(k.GetKeywordName());
#else
return( = k.GetName());
#endif
}
public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> data)
{
Debug.Log($"Before Shader {shader.name} --> {data.Count}");
if (!m_shaderKeywordCollector.TryGetValue(shader, out var collectKeywords))
{
if (m_shaderKeywordCollector.Count == 0)
{
return;
}
data.Clear();
Debug.Log($"Shader {shader.name} --> {data.Count}");
return;
}
for (int i = data.Count - 1; i >= 0; i--)
{
var compilerData = data[i];
var keywords = compilerData.shaderKeywordSet.GetShaderKeywords();
foreach (var shaderKeyword in keywords)
{
if (Array.IndexOf(STRIP_BUILD_IN_KEYWORDS, shaderKeyword) != -1)
{
data.RemoveAt(i);
break;
}
var keywordName = ShaderKeyword.GetKeywordName(shader, shaderKeyword);
if (!keywordName.StartsWith("_"))
{
if (!m_filteredBuildInKeywords.Contains(keywordName))
{
m_filteredBuildInKeywords.Add(keywordName);
}
continue;
}
bool inUsed = false;
foreach (var collectKeyword in collectKeywords)
{
if (collectKeyword.Contains(keywordName))
{
inUsed = true;
break;
}
}
if (!inUsed)
{
data.RemoveAt(i);
break;
}
}
}
Debug.Log($"Shader {shader.name} --> {data.Count}");
}
private List <string> Convert(Shader shader, ShaderKeyword[] keywords)
{
List <string> converted = new List <string>(keywords.Length);
for (int i = 0; i < keywords.Length; ++i)
{
if (!string.IsNullOrEmpty(ShaderKeyword.GetKeywordName(shader, keywords[i])) &&
ShaderKeyword.GetKeywordType(shader, keywords[i]) != ShaderKeywordType.BuiltinDefault)
{
converted.Add(ShaderKeyword.GetKeywordName(shader, keywords[i]));
}
}
converted.Sort();
return(converted);
}
private void AppendShaderInfo(StringBuilder sb, Shader shader, ShaderSnippetData snippet, ShaderCompilerData compilerData)
{
if (sb.Length == 0)
{
sb.Append("Shader:" + shader.name).Append("\n");
sb.Append("ShaderType:").Append(snippet.shaderType).Append("\n").
Append("PassName:").Append(snippet.passName).Append("\n").
Append("PassType:").Append(snippet.passType).Append("\n\n");
}
var keywords = compilerData.shaderKeywordSet.GetShaderKeywords();
var sortKeywords = new ShaderKeyword[keywords.Length];
for (int i = 0; i < keywords.Length; ++i)
{
sortKeywords[i] = keywords[i];
}
System.Array.Sort(sortKeywords, new SortShaderKeyword(shader));
sb.Append(" Keyword:");
foreach (var keyword in sortKeywords)
{
#if UNITY_2019_3_OR_NEWER
sb.Append(ShaderKeyword.GetKeywordName(shader, keyword)).Append(" ");
#else
sb.Append(keyword.GetKeywordName()).Append(" ");
#endif
}
sb.Append("\n KeywordType:");
foreach (var keyword in sortKeywords)
{
#if UNITY_2019_3_OR_NEWER
sb.Append(ShaderKeyword.GetKeywordType(shader, keyword)).Append(" ");
#else
sb.Append(keyword.GetKeywordType()).Append(" ");
#endif
}
#if UNITY_2019_3_OR_NEWER
sb.Append("\n IsLocalkeyword:");
foreach (var keyword in sortKeywords)
{
sb.Append(ShaderKeyword.IsKeywordLocal(keyword)).Append(" ");
}
#endif
sb.Append("\n").Append("\n");
}
public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> data)
{
if (!UPRToolSetting.Instance.enableShaderVariantsCheck)
{
return;
}
if (snippet.shaderType != ShaderType.Fragment)
{
return;
}
var shaderName = shader.name;
if (!s_ShaderNames.Contains(shaderName))
{
return;
}
if (!s_ShaderReports.ContainsKey(shaderName))
{
s_ShaderReports.Add(shaderName, new List <ShaderVariantsCheckResult>());
}
foreach (var shaderCompilerData in data)
{
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>";
}
s_ShaderReports[shaderName].Add(new ShaderVariantsCheckResult(shaderName,
shaderCompilerData.shaderCompilerPlatform.ToString(),
shaderCompilerData.graphicsTier.ToString(), snippet.passName,
keywordString));
}
}
public void OnProcessShader(
Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> shaderCompilerData)
{
try {
if (shaderCompilerData == null)
{
return;
}
if (!"Hidden/Universal Render Pipeline/UberPost".Equals(shader.name) && !"Hidden/Kronnect/Beautify".Equals(shader.name))
{
return;
}
string strippedKeywords = PlayerPrefs.GetString(PLAYER_PREF_KEYNAME);
if (string.IsNullOrEmpty(strippedKeywords))
{
return;
}
for (int k = shaderCompilerData.Count - 1; k >= 0; k--)
{
ShaderCompilerData data = shaderCompilerData[k];
ShaderKeyword[] keywords = data.shaderKeywordSet.GetShaderKeywords();
for (int s = 0; s < keywords.Length; s++)
{
ShaderKeyword keyword = keywords[s];
string keywordName;
if (ShaderKeyword.IsKeywordLocal(keyword))
{
keywordName = ShaderKeyword.GetKeywordName(shader, keyword);
}
else
{
keywordName = ShaderKeyword.GetGlobalKeywordName(keyword);
}
if (keywordName.Length > 0 && strippedKeywords.Contains(keywordName))
{
shaderCompilerData.RemoveAt(k);
break;
}
}
}
} catch { }
}
public ShaderVariantsInfo(Shader sh, PassType pass, string[] words)
{
this.shader = sh;
this.passType = pass;
this.keywords = words;
this.keywordInfos = new List <ShaderKeyword>(words.Length);
for (int i = 0; i < words.Length; ++i)
{
if (string.IsNullOrEmpty(words[i]) || sh == null)
{
continue;
}
#if UNITY_2019 || UNITY_2019_3_OR_NEWER
ShaderKeyword shKeyword = new ShaderKeyword(sh, words[i]);
#else
ShaderKeyword shKeyword = new ShaderKeyword(words[i]);
#endif
keywordInfos.Add(shKeyword);
}
keywordsForCheck = new List <string>();
foreach (var keywordInfo in keywordInfos)
{
#if UNITY_2019_3_OR_NEWER
if (!string.IsNullOrEmpty(ShaderKeyword.GetKeywordName(sh, keywordInfo)) &&
ShaderKeyword.GetKeywordType(sh, keywordInfo) != ShaderKeywordType.BuiltinAutoStripped)
{
keywordsForCheck.Add(ShaderKeyword.GetKeywordName(sh, keywordInfo));
}
#else
if (!string.IsNullOrEmpty(keywordInfo.GetKeywordName()) &&
keywordInfo.GetKeywordType() != ShaderKeywordType.BuiltinAutoStripped)
{
keywordsForCheck.Add(keywordInfo.GetKeywordName());
}
#endif
}
keywordsForCheck.Sort();
}
private List <string> Convert(Shader shader, ShaderKeyword[] keywords)
{
List <string> converted = new List <string>(keywords.Length);
for (int i = 0; i < keywords.Length; ++i)
{
#if UNITY_2019_3_OR_NEWER
if (!string.IsNullOrEmpty(ShaderKeyword.GetKeywordName(shader, keywords[i])) &&
ShaderKeyword.GetKeywordType(shader, keywords[i]) != ShaderKeywordType.BuiltinAutoStripped)
{
converted.Add(ShaderKeyword.GetKeywordName(shader, keywords[i]));
}
#else
if (!string.IsNullOrEmpty(keywords[i].GetKeywordName()) &&
keywords[i].GetKeywordType() != ShaderKeywordType.BuiltinAutoStripped)
{
converted.Add(keywords[i].GetKeywordName());
}
#endif
}
converted.Sort();
return(converted);
}
public void OnProcessShader(
Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> shaderCompilerData)
{
bool skipCompilation = false;
if (SCWindow.GetEditorPrefBool("QUICK_BUILD", false))
{
skipCompilation = true;
}
if (shadersBuildInfo == null)
{
string filename = GetStoredDataPath();
shadersBuildInfo = AssetDatabase.LoadAssetAtPath <ShadersBuildInfo>(filename);
if (shadersBuildInfo == null)
{
shadersBuildInfo = ScriptableObject.CreateInstance <ShadersBuildInfo>();
Directory.CreateDirectory(Path.GetDirectoryName(filename));
AssetDatabase.CreateAsset(shadersBuildInfo, filename);
EditorUtility.SetDirty(shadersBuildInfo);
}
}
ShaderBuildInfo sb = shadersBuildInfo.GetShader(shader.name);
if (sb == null)
{
sb = new ShaderBuildInfo();
sb.name = shader.name;
sb.simpleName = SCShader.GetSimpleName(sb.name);
sb.type = snippet.shaderType;
string path = AssetDatabase.GetAssetPath(shader);
sb.isInternal = string.IsNullOrEmpty(path) || !File.Exists(path);
shadersBuildInfo.Add(sb);
EditorUtility.SetDirty(shadersBuildInfo);
}
else if (!sb.includeInBuild)
{
skipCompilation = true;
}
int count = shaderCompilerData.Count;
for (int i = 0; i < count; ++i)
{
ShaderKeywordSet ks = shaderCompilerData[i].shaderKeywordSet;
foreach (ShaderKeyword kw in ks.GetShaderKeywords())
{
#if UNITY_2019_3_OR_NEWER
string kname = ShaderKeyword.GetKeywordName(shader, kw);
#else
string kname = kw.GetKeywordName();
#endif
if (string.IsNullOrEmpty(kname))
{
continue;
}
if (!sb.KeywordsIsIncluded(kname))
{
shaderCompilerData.RemoveAt(i);
count--;
i--;
break;
}
else
{
EditorUtility.SetDirty(shadersBuildInfo);
}
}
}
if (skipCompilation)
{
shaderCompilerData.Clear();
}
}
public void OnProcessShader(
Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> shaderCompilerData)
{
try {
bool skipCompilation = false;
if (SCWindow.GetEditorPrefBool("QUICK_BUILD", false))
{
skipCompilation = true;
}
if (shadersBuildInfo == null)
{
string filename = GetStoredDataPath();
shadersBuildInfo = AssetDatabase.LoadAssetAtPath <ShadersBuildInfo>(filename);
if (shadersBuildInfo == null)
{
return;
}
}
ShaderBuildInfo sb = shadersBuildInfo.GetShader(shader.name);
if (sb == null)
{
sb = new ShaderBuildInfo();
sb.name = shader.name;
sb.simpleName = SCShader.GetSimpleName(sb.name);
sb.type = snippet.shaderType;
string path = AssetDatabase.GetAssetPath(shader);
sb.isInternal = string.IsNullOrEmpty(path) || !File.Exists(path);
shadersBuildInfo.Add(sb);
EditorUtility.SetDirty(shadersBuildInfo);
}
else if (!sb.includeInBuild)
{
skipCompilation = true;
}
int count = shaderCompilerData.Count;
for (int i = 0; i < count; ++i)
{
ShaderKeywordSet ks = shaderCompilerData[i].shaderKeywordSet;
foreach (ShaderKeyword kw in ks.GetShaderKeywords())
{
#if UNITY_2019_3_OR_NEWER
string kname = ShaderKeyword.GetKeywordName(shader, kw);
#else
string kname = kw.GetName();
#endif
if (string.IsNullOrEmpty(kname))
{
continue;
}
if (!sb.KeywordsIsIncluded(kname))
{
shaderCompilerData.RemoveAt(i);
count--;
i--;
break;
}
else
{
EditorUtility.SetDirty(shadersBuildInfo);
}
}
}
if (skipCompilation)
{
shaderCompilerData.Clear();
return;
}
} catch (Exception ex) {
Debug.LogWarning("Shader Control detected an error during compilation of one shader: " + ex.ToString());
}
}
public static string GetKeywordName(this ShaderKeyword keyword, Shader shader)
{
return(ShaderKeyword.IsKeywordLocal(keyword) ? ShaderKeyword.GetKeywordName(shader, keyword) : ShaderKeyword.GetGlobalKeywordName(keyword));
}
private string[] ToKeywordArray(Shader shader, ShaderKeywordSet keys)
{
return(keys.GetShaderKeywords().Select(kwd => ShaderKeyword.GetKeywordName(shader, kwd)).ToArray());
}
static string[] GetShaderKeywords(Shader shader, ShaderKeyword[] shaderKeywords)
{
#if UNITY_2019_3_OR_NEWER
var keywords = shaderKeywords.Select(keyword => ShaderKeyword.IsKeywordLocal(keyword) ? ShaderKeyword.GetKeywordName(shader, keyword) : ShaderKeyword.GetGlobalKeywordName(keyword)).ToArray();
#else
var keywords = shaderKeywords.Select(keyword => keyword.GetKeywordName()).ToArray();
#endif
return(keywords);
}
/// <summary>
/// Strips shader variants from the underwater shader based on what features are enabled on the ocean material.
/// </summary>
public void ProcessUnderwaterShader(Shader shader, IList <ShaderCompilerData> data)
{
// This should not happen. There should always be at least one variant.
if (data.Count == 0)
{
return;
}
#if CREST_DEBUG
var shaderVariantCount = data.Count;
var shaderVarientStrippedCount = 0;
#endif
// Collect all shader keywords.
var unusedShaderKeywords = new HashSet <ShaderKeyword>();
for (int i = 0; i < data.Count; i++)
{
// Each ShaderCompilerData is a variant which is a combination of keywords. Since each list will be
// different, simply getting a list of all keywords is not possible. This also appears to be the only
// way to get a list of keywords without trying to extract them from shader property names. Lastly,
// shader_feature will be returned only if they are enabled.
unusedShaderKeywords.UnionWith(data[i].shaderKeywordSet.GetShaderKeywords());
}
// Get used shader keywords so we can exclude them.
var usedShaderKeywords = new List <ShaderKeyword>();
foreach (var shaderKeyword in unusedShaderKeywords)
{
// Do not handle built-in shader keywords.
if (ShaderKeyword.GetKeywordType(shader, shaderKeyword) != ShaderKeywordType.UserDefined)
{
usedShaderKeywords.Add(shaderKeyword);
continue;
}
// GetKeywordName will work for both global and local keywords.
var shaderKeywordName = ShaderKeyword.GetKeywordName(shader, shaderKeyword);
// These keywords will not be on ocean material.
if (shaderKeywordName.Contains("_MENISCUS") || shaderKeywordName.Contains("_FULL_SCREEN_EFFECT"))
{
usedShaderKeywords.Add(shaderKeyword);
continue;
}
// TODO: Strip this once post-processing is more unified.
if (shaderKeywordName.Contains("_DEBUG_VIEW_OCEAN_MASK"))
{
usedShaderKeywords.Add(shaderKeyword);
continue;
}
foreach (var oceanMaterial in _oceanMaterials)
{
if (oceanMaterial.IsKeywordEnabled(shaderKeywordName))
{
usedShaderKeywords.Add(shaderKeyword);
break;
}
}
}
// Exclude used keywords to obtain list of unused keywords.
unusedShaderKeywords.ExceptWith(usedShaderKeywords);
for (int index = 0; index < data.Count; index++)
{
foreach (var unusedShaderKeyword in unusedShaderKeywords)
{
// IsEnabled means this variant uses this keyword and we can strip it.
if (data[index].shaderKeywordSet.IsEnabled(unusedShaderKeyword))
{
data.RemoveAt(index--);
#if CREST_DEBUG
shaderVarientStrippedCount++;
#endif
break;
}
}
}
#if CREST_DEBUG
this.shaderVarientStrippedCount += shaderVarientStrippedCount;
Debug.Log($"Crest: {shaderVarientStrippedCount} shader variants stripped of {shaderVariantCount} from {shader.name}.");
#endif
}
public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> data)
{
int newVariantsForThisShader = 0;
//The real variant count
newVariantsForThisShader += data.Count;
//Go through all the variants
for (int i = 0; i < data.Count; ++i)
{
ShaderKeyword[] sk = data[i].shaderKeywordSet.GetShaderKeywords();
//The default variant
if (sk.Length == 0)
{
CompiledShaderVariant scv_default = new CompiledShaderVariant();
//scv.id = id;
scv_default.shaderName = shader.name;
scv_default.passName = "" + snippet.passName;
scv_default.passType = "" + snippet.passType.ToString();
scv_default.shaderType = "" + snippet.shaderType.ToString();
scv_default.graphicsTier = "--";
scv_default.shaderCompilerPlatform = "--";
scv_default.shaderKeywordName = "No Keyword / All Off";
scv_default.shaderKeywordType = "--";
scv_default.shaderKeywordIndex = "-1";
scv_default.isShaderKeywordValid = "--";
scv_default.isShaderKeywordEnabled = "--";
SVL.variantlist.Add(scv_default);
SVL.compiledTotalCount++;
}
for (int k = 0; k < sk.Length; ++k)
{
CompiledShaderVariant scv = new CompiledShaderVariant();
//scv.id = id;
scv.shaderName = shader.name;
scv.passName = "" + snippet.passName;
scv.passType = "" + snippet.passType.ToString();
scv.shaderType = "" + snippet.shaderType.ToString();
scv.graphicsTier = "" + data[i].graphicsTier;
scv.shaderCompilerPlatform = "" + data[i].shaderCompilerPlatform;
//scv.shaderRequirements = ""+data[i].shaderRequirements;
//scv.platformKeywordName = ""+data[i].platformKeywordSet.ToString();
//scv.isplatformKeywordEnabled = ""+data[i].platformKeywordSet.IsEnabled(BuiltinShaderDefine.SHADER_API_DESKTOP);
bool isLocal = ShaderKeyword.IsKeywordLocal(sk[k]);
scv.shaderKeywordName = (isLocal? "[Local] " : "[Global] ") + ShaderKeyword.GetKeywordName(shader, sk[k]); //sk[k].GetKeywordName();
scv.shaderKeywordType = "" + ShaderKeyword.GetKeywordType(shader, sk[k]); //""+sk[k].GetKeywordType().ToString();
scv.shaderKeywordIndex = "" + sk[k].index;
scv.isShaderKeywordValid = "" + sk[k].IsValid();
scv.isShaderKeywordEnabled = "" + data[i].shaderKeywordSet.IsEnabled(sk[k]);
SVL.variantlist.Add(scv);
SVL.compiledTotalCount++;
//Just to verify API is correct
string globalShaderKeywordName = ShaderKeyword.GetGlobalKeywordName(sk[k]);
if (!isLocal && globalShaderKeywordName != ShaderKeyword.GetKeywordName(shader, sk[k]))
{
Debug.LogError("Bug. ShaderKeyword.GetGlobalKeywordName() and ShaderKeyword.GetKeywordName() is wrong");
}
ShaderKeywordType globalShaderKeywordType = ShaderKeyword.GetGlobalKeywordType(sk[k]);
if (!isLocal && globalShaderKeywordType != ShaderKeyword.GetKeywordType(shader, sk[k]))
{
Debug.LogError("Bug. ShaderKeyword.GetGlobalKeywordType() and ShaderKeyword.GetKeywordType() is wrong");
}
}
}
//Add to shader list
int compiledShaderId = SVL.shaderlist.FindIndex(o => o.name == shader.name);
if (compiledShaderId == -1)
{
CompiledShader newCompiledShader = new CompiledShader();
newCompiledShader.name = shader.name;
newCompiledShader.guiEnabled = false;
newCompiledShader.noOfVariantsForThisShader = 0;
SVL.shaderlist.Add(newCompiledShader);
compiledShaderId = SVL.shaderlist.Count - 1;
}
//Add variant count to shader
CompiledShader compiledShader = SVL.shaderlist[compiledShaderId];
compiledShader.noOfVariantsForThisShader += newVariantsForThisShader;
SVL.shaderlist[compiledShaderId] = compiledShader;
//Add to total count
SVL.variantTotalCount += newVariantsForThisShader;
}
/// <inheritdoc />
public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> data)
{
if (!ShaderVariantCollectionGenerator3.IsCreating)
{
return;
}
#if DEBUG_ON
Debug.Log("SVCG_ShaderPreprocessor.OnProcessShader(" + shader.name + ")");
#endif
ShaderVariantCollection svc = ShaderVariantCollectionGenerator3.CurrentSVC;
if (!ShaderVariantCollectionGenerator3.WillWriteToFile && svc == null)
{
return;
}
//处理剔除配置
if (ShaderVariantCollectionGenerator3.CurrentConfig != null)
{
EditorUtility.DisplayProgressBar("正在执行剔除", $"Shader: {shader.name}", 0);
ShaderKeywordConfig config = ShaderVariantCollectionGenerator3.CurrentConfig;
if (DoExcludeShader(config, shader))
{
return;
}
EditorUtility.DisplayProgressBar("正在执行剔除", $"Shader: {shader.name}", 0.3333f);
if (DoExclude(config.GetGlobalConfig(), snippet, data))
{
return;
}
EditorUtility.DisplayProgressBar("正在执行剔除", $"Shader: {shader.name}", 0.6666f);
if (DoExclude(config.GetConfigOfShader(shader), snippet, data))
{
return;
}
EditorUtility.DisplayProgressBar("正在执行剔除", $"Shader: {shader.name}", 1);
}
for (int i = 0; i < data.Count; i++)
{
EditorUtility.DisplayProgressBar("正在处理变体", $"Shader: {shader.name}, data: {i}/{data.Count}", (float)i / data.Count);
ShaderKeyword[] kws = data[i].shaderKeywordSet.GetShaderKeywords();
if (ShaderVariantCollectionGenerator3.WillWriteToFile)
{
string[] strKWs = new string[kws.Length + 1];
strKWs[0] = ((int)snippet.passType).ToString();
for (int j = 1; j < kws.Length + 1; j++)
{
#if UNITY_2019_3_OR_NEWER
strKWs[j] = ShaderKeyword.GetKeywordName(shader, kws[j - 1]);
#else
strKWs[j] = kws[j - 1].GetKeywordName();
#endif
}
HashSet <string> d = null;
if (ShaderVariantCollectionGenerator3.DataDictionary.TryGetValue(shader, out d))
{
d.Add(DebugUtil.LogString(strKWs));
}
else
{
d = new HashSet <string>();
d.Add(DebugUtil.LogString(strKWs));
ShaderVariantCollectionGenerator3.DataDictionary.Add(shader, d);
}
#if DEBUG_ON
Debug.Log("file.Add(" + DebugUtil.LogString(strKWs) + ")");
#endif
}
else
{
string[] strKWs = new string[kws.Length];
for (int j = 0; j < kws.Length; j++)
{
#if UNITY_2019_3_OR_NEWER
strKWs[j] = ShaderKeyword.GetKeywordName(shader, kws[j]);
#else
strKWs[j] = kws[j].GetKeywordName();
#endif
}
#if DEBUG_ON
Debug.Log("svc.Add(" + shader + ", " + snippet.passType + ", " + DebugUtil.LogString(strKWs) + ")");
#endif
if (ShaderVariantCollectionGenerator3.StopOnException)
{
svc.Add(new ShaderVariantCollection.ShaderVariant(shader, snippet.passType, strKWs));
}
else
{
//不使用构造函数可以避免调用 ShaderVariantCollection.ShaderVariant.CheckShaderVariant
//它将耗费大量时间来判断输入数据是否存在异常
ShaderVariantCollection.ShaderVariant sv = new ShaderVariantCollection.ShaderVariant();
sv.shader = shader;
sv.passType = snippet.passType;
sv.keywords = strKWs;
svc.Add(sv);
}
}
}
//实际打包时不编译shader变体，仅收集信息，大幅优化执行时间
data.Clear();
}
public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> shaderVariants)
{
if (!ShaderVariantsStripperConfigure.Configure.useStripper)
{
return;
}
int inputShaderVariantCount = shaderVariants.Count;
string prefix = "VARIANT: " + shader.name + " (";
if (snippet.passName.Length > 0)
{
prefix += snippet.passName + ", ";
}
prefix += snippet.shaderType.ToString() + ") ";
if (ShaderVariantsStripperConfigure.Configure.enableLog)
{
if (shaderSets.Add(shader.name))
{
File.AppendAllText(allshaderFile, shader.name + "\n");
}
}
for (int i = 0; i < shaderVariants.Count; ++i)
{
string log = prefix;
log += shaderVariants[i].shaderCompilerPlatform.ToString() + " ";
log += shaderVariants[i].graphicsTier.ToString() + " ";
if (ShaderVariantsStripperConfigure.Configure.enableLog)
{
ShaderKeyword[] keywords = shaderVariants[i].shaderKeywordSet.GetShaderKeywords();
for (int labelIndex = 0; labelIndex < keywords.Count(); ++labelIndex)
{
ShaderKeyword akey = keywords[labelIndex];
bool isUserDefined = akey.GetKeywordType() == ShaderKeywordType.UserDefined;
bool isBuiltinDefault = akey.GetKeywordType() == ShaderKeywordType.BuiltinDefault;
bool isBuiltinExtra = akey.GetKeywordType() == ShaderKeywordType.BuiltinExtra;
bool isBuiltinAutoStripped = akey.GetKeywordType() == ShaderKeywordType.BuiltinAutoStripped;
#if UNITY_2018_3_OR_NEWER
string keyWordName = akey.GetKeywordName();
#else
string keyWordName = akey.GetName();
#endif
log += keyWordName + " ";
{
if (keySets.Add(keyWordName))
{
File.AppendAllText(keywordFile, keyWordName + "\n");
}
}
if (isBuiltinDefault)
{
if (!buildInKeys.Contains(keyWordName))
{
buildInKeys.Add(keyWordName);
File.AppendAllText(buildInFile, keyWordName + "\n");
}
}
if (isBuiltinExtra)
{
if (!buildInExtraKeys.Contains(keyWordName))
{
buildInExtraKeys.Add(keyWordName);
File.AppendAllText(buildExtraFile, keyWordName + "\n");
}
}
if (isBuiltinAutoStripped)
{
if (!buildInAutoStripKeys.Contains(keyWordName))
{
buildInAutoStripKeys.Add(keyWordName);
File.AppendAllText(buildInAutoStripFile, keyWordName + "\n");
}
}
if (isUserDefined)
{
if (!userDefineKeys.Contains(keyWordName))
{
userDefineKeys.Add(keyWordName);
File.AppendAllText(userDefineFile, keyWordName + "\n");
}
}
}
}
bool keepVariant = true;
if (ShaderVariantsStripperConfigure.Configure.useWhitelist)
{
keepVariant = KeepVariantByWhitelist(shader, snippet, shaderVariants[i]);
}
else
{
keepVariant = KeepVariantByConfigure(shader, snippet, shaderVariants[i]);
}
if (ShaderVariantsStripperConfigure.Configure.enableLog)
{
//填写编译结果
ShaderCompileReport.Report.AddCompileInfo(shader.name, snippet, shaderVariants[i], !keepVariant);
}
if (!keepVariant)
{
shaderVariants.RemoveAt(i);
--i;
}
if (ShaderVariantsStripperConfigure.Configure.enableLog)
{
File.AppendAllText(logFile, log + "\n");
}
}
if (ShaderVariantsStripperConfigure.Configure.enableLog)
{
float percentage = (float)shaderVariants.Count / (float)inputShaderVariantCount * 100f;
string logresult = "STRIPPING(" + shader.name + " " + snippet.passName + " " + snippet.shaderType.ToString() + ") = Kept / Total = " + shaderVariants.Count + " / " + inputShaderVariantCount + " = " + percentage + "% of the generated shader variants remain in the player data";
//Debug.Log(BText(logresult));
File.AppendAllText(logFile, logresult + "\n");
}
}
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 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();
}
