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