public BaseShaderPreprocessor()
{
// NOTE: All these keyword should be automatically stripped so there's no need to handle them ourselves.
// LIGHTMAP_ON, DIRLIGHTMAP_COMBINED, DYNAMICLIGHTMAP_ON, LIGHTMAP_SHADOW_MIXING, SHADOWS_SHADOWMASK
// FOG_LINEAR, FOG_EXP, FOG_EXP2
// STEREO_INSTANCING_ON, STEREO_MULTIVIEW_ON, STEREO_CUBEMAP_RENDER_ON, UNITY_SINGLE_PASS_STEREO
// INSTANCING_ON
m_Transparent = new ShaderKeyword("_SURFACE_TYPE_TRANSPARENT");
m_DebugDisplay = new ShaderKeyword("DEBUG_DISPLAY");
m_TileLighting = new ShaderKeyword("USE_FPTL_LIGHTLIST");
m_ClusterLighting = new ShaderKeyword("USE_CLUSTERED_LIGHTLIST");
m_LodFadeCrossFade = new ShaderKeyword("LOD_FADE_CROSSFADE");
m_DecalsOFF = new ShaderKeyword("DECALS_OFF");
m_Decals3RT = new ShaderKeyword("DECALS_3RT");
m_Decals4RT = new ShaderKeyword("DECALS_4RT");
m_LightLayers = new ShaderKeyword("LIGHT_LAYERS");
m_ShadowLow = new ShaderKeyword("SHADOW_LOW");
m_ShadowMedium = new ShaderKeyword("SHADOW_MEDIUM");
m_ShadowHigh = new ShaderKeyword("SHADOW_HIGH");
m_WriteNormalBuffer = new ShaderKeyword("WRITE_NORMAL_BUFFER");
m_WriteMSAADepth = new ShaderKeyword("WRITE_MSAA_DEPTH");
m_SubsurfaceScattering = new ShaderKeyword("OUTPUT_SPLIT_LIGHTING");
m_ShadowVariants = new Dictionary <HDShadowQuality, ShaderKeyword>
{
{ HDShadowQuality.Low, m_ShadowLow },
{ HDShadowQuality.Medium, m_ShadowMedium },
{ HDShadowQuality.High, m_ShadowHigh },
};
}
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[] 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());
}
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());
sb.Append(" Keyword:");
foreach (var keyword in sortKeywords)
{
sb.Append(keyword.GetKeywordName()).Append(" ");
}
sb.Append("\n KeywordType:");
foreach (var keyword in sortKeywords)
{
sb.Append(keyword.GetKeywordType()).Append(" ");
}
sb.Append("\n").Append("\n");
}
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]))
{
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 (!string.IsNullOrEmpty(keywordInfo.GetKeywordName()) &&
keywordInfo.GetKeywordType() != ShaderKeywordType.BuiltinAutoStripped)
{
keywordsForCheck.Add(keywordInfo.GetKeywordName());
}
}
keywordsForCheck.Sort();
}
public bool KeepVariants(Shader shader, ShaderSnippetData snippet, ShaderCompilerData variants)
{
keywords.Clear();
var shaderKeywords = variants.shaderKeywordSet.GetShaderKeywords();
foreach (var shaderkeyword in shaderKeywords)
{
keywords.Add(ShaderKeyword.GetGlobalKeywordName(shaderkeyword));
}
bool hasKeywords = keywords.Count > 0;
Debug.Log(shader.name + "\tVariants:" + (hasKeywords ? string.Join("\t", keywords.ToArray()) : "<no keywords>"));
if (hasKeywords && keepExportVariants != null)
{
ShaderVariant shaderVariant = new ShaderVariant(shader, snippet.passType, keywords.ToArray());
// 必须，自动导出的变体组合
if (keepExportVariants.Contains(shaderVariant))
{
return(true);
}
// 可选，自定义变体组合
if (keepCustomVariants != null && keepCustomVariants.Contains(shaderVariant))
{
return(true);
}
return(false);
}
return(true);
}
void BuildEnumKeywordField(PropertySheet propertySheet, ShaderKeyword keyword)
{
// Clamp value between entry list
int value = Mathf.Clamp(keyword.value, 0, keyword.entries.Count - 1);
// Default field
var field = new PopupField <string>(keyword.entries.Select(x => x.displayName).ToList(), value);
field.RegisterValueChangedCallback(evt =>
{
this._preChangeValueCallback("Change Keyword Value");
keyword.value = field.index;
this._postChangeValueCallback(false, ModificationScope.Graph);
});
AddPropertyRowToSheet(propertySheet, field, "Default");
// Entries
var container = new IMGUIContainer(() => OnKeywordGUIHandler())
{
name = "ListContainer"
};
AddPropertyRowToSheet(propertySheet, container, "Entries");
container.SetEnabled(!keyword.isBuiltIn);
}
void InitializeLocalShaderKeywords(Shader shader)
{
m_LocalDetailMulx2 = new ShaderKeyword(shader, ShaderKeywordStrings._DETAIL_MULX2);
m_LocalDetailScaled = new ShaderKeyword(shader, ShaderKeywordStrings._DETAIL_SCALED);
m_LocalClearCoat = new ShaderKeyword(shader, ShaderKeywordStrings._CLEARCOAT);
m_LocalClearCoatMap = new ShaderKeyword(shader, ShaderKeywordStrings._CLEARCOATMAP);
}
public BaseShaderPreprocessor()
{
// NOTE: All these keyword should be automatically stripped so there's no need to handle them ourselves.
// LIGHTMAP_ON, DIRLIGHTMAP_COMBINED, DYNAMICLIGHTMAP_ON, LIGHTMAP_SHADOW_MIXING, SHADOWS_SHADOWMASK
// FOG_LINEAR, FOG_EXP, FOG_EXP2
// STEREO_INSTANCING_ON, STEREO_MULTIVIEW_ON, STEREO_CUBEMAP_RENDER_ON, UNITY_SINGLE_PASS_STEREO
// INSTANCING_ON
m_Transparent = new ShaderKeyword("_SURFACE_TYPE_TRANSPARENT");
m_AlphaTestOn = new ShaderKeyword("_ALPHATEST_ON");
m_DebugDisplay = new ShaderKeyword("DEBUG_DISPLAY");
m_TileLighting = new ShaderKeyword("USE_FPTL_LIGHTLIST");
m_ClusterLighting = new ShaderKeyword("USE_CLUSTERED_LIGHTLIST");
m_LodFadeCrossFade = new ShaderKeyword("LOD_FADE_CROSSFADE");
m_DecalsOFF = new ShaderKeyword("DECALS_OFF");
m_Decals3RT = new ShaderKeyword("DECALS_3RT");
m_Decals4RT = new ShaderKeyword("DECALS_4RT");
m_LightLayers = new ShaderKeyword("LIGHT_LAYERS");
m_WriteNormalBuffer = new ShaderKeyword("WRITE_NORMAL_BUFFER");
m_WriteDecalBuffer = new ShaderKeyword("WRITE_DECAL_BUFFER");
m_WriteMSAADepth = new ShaderKeyword("WRITE_MSAA_DEPTH");
m_SubsurfaceScattering = new ShaderKeyword("OUTPUT_SPLIT_LIGHTING");
m_ScreenSpaceShadowOFFKeywords = new ShaderKeyword("SCREEN_SPACE_SHADOWS_OFF");
m_ScreenSpaceShadowONKeywords = new ShaderKeyword("SCREEN_SPACE_SHADOWS_ON");
m_ProbeVolumesL1 = new ShaderKeyword("PROBE_VOLUMES_L1");
m_ProbeVolumesL2 = new ShaderKeyword("PROBE_VOLUMES_L2");
m_DecalSurfaceGradient = new ShaderKeyword("DECAL_SURFACE_GRADIENT");
m_EditorVisualization = new ShaderKeyword("EDITOR_VISUALIZATION");
m_ShadowKeywords = new ShadowKeywords();
}
public BaseShaderPreprocessor()
{
m_Transparent = new ShaderKeyword("_SURFACE_TYPE_TRANSPARENT");
m_DebugDisplay = new ShaderKeyword("DEBUG_DISPLAY");
m_TileLighting = new ShaderKeyword("USE_FPTL_LIGHTLIST");
m_ClusterLighting = new ShaderKeyword("USE_CLUSTERED_LIGHTLIST");
}
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}");
}
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);
}
void AddKeywordItems(GenericMenu gm)
{
gm.AddItem(new GUIContent($"Keyword/Boolean"), false, () => AddInputRow(new ShaderKeyword(KeywordType.Boolean), true));
gm.AddItem(new GUIContent($"Keyword/Enum"), false, () => AddInputRow(new ShaderKeyword(KeywordType.Enum), true));
gm.AddSeparator($"Keyword/");
foreach (var builtinKeywordDescriptor in KeywordUtil.GetBuiltinKeywordDescriptors())
{
var keyword = ShaderKeyword.CreateBuiltInKeyword(builtinKeywordDescriptor);
AddBuiltinKeyword(gm, keyword);
}
}
void AddBuiltinKeyword(GenericMenu gm, ShaderKeyword keyword)
{
if (m_Graph.keywords.Where(x => x.referenceName == keyword.referenceName).Any())
{
gm.AddDisabledItem(new GUIContent($"Keyword/{keyword.displayName}"));
}
else
{
gm.AddItem(new GUIContent($"Keyword/{keyword.displayName}"), false, () => AddInputRow(m_Graph.AddCopyOfShaderInput(keyword)));
}
}
public void KeywordEnumCanAddAndRemovePort()
{
ShaderKeyword enumAKeyword = m_Collector.keywords.Where(x => x.displayName == "Enum A").FirstOrDefault();
ShaderKeyword enumBKeyword = m_Collector.keywords.Where(x => x.displayName == "Enum B").FirstOrDefault();
if (enumAKeyword == null || enumBKeyword == null)
{
Assert.Fail("One or more Keywords not in graph.");
}
var keywordNodes = m_Graph.GetNodes <KeywordNode>().ToList();
KeywordNode enumANode = keywordNodes.Where(x => x.keyword == enumAKeyword).FirstOrDefault();
KeywordNode enumBNode = keywordNodes.Where(x => x.keyword == enumBKeyword).FirstOrDefault();
if (enumANode == null || enumBNode == null)
{
Assert.Fail("One or more Keywords Nodes not in graph.");
}
KeywordEntry newEntry1 = new KeywordEntry(4, "D", "D");
KeywordEntry newEntry2 = new KeywordEntry(5, "E", "E");
KeywordEntry newEntry3 = new KeywordEntry(6, "F", "F");
KeywordEntry newEntry4 = new KeywordEntry(5, "E", "E");
enumAKeyword.entries.Add(newEntry1);
enumAKeyword.entries.Add(newEntry2);
enumAKeyword.entries.Add(newEntry3);
enumBKeyword.entries.Add(newEntry4);
Assert.AreEqual(6, enumAKeyword.entries.Count, "Enum A Keyword has incorrect # of entries after adding");
Assert.AreEqual(5, enumBKeyword.entries.Count, "Enum B Keyword has incorrect # of entries after adding");
enumANode.UpdateNode();
enumBNode.UpdateNode();
Assert.AreEqual(7, enumANode.GetSlots <MaterialSlot>().Count(), "Enum A Node has incorrect # of entries after adding");
Assert.AreEqual(6, enumBNode.GetSlots <MaterialSlot>().Count(), "Enum B Node has incorrect # of entries after adding");
enumAKeyword.entries.Remove(newEntry1);
enumAKeyword.entries.Remove(newEntry2);
enumAKeyword.entries.Remove(newEntry3);
enumBKeyword.entries.Remove(newEntry4);
Assert.AreEqual(3, enumAKeyword.entries.Count, "Enum A Keyword has incorrect # of entries after removing");
Assert.AreEqual(4, enumBKeyword.entries.Count, "Enum B Keyword has incorrect # of entries after removing");
enumANode.UpdateNode();
enumBNode.UpdateNode();
Assert.AreEqual(4, enumANode.GetSlots <MaterialSlot>().Count(), "Enum A Node has incorrect # of entries after removing");
Assert.AreEqual(5, enumBNode.GetSlots <MaterialSlot>().Count(), "Enum B Node has incorrect # of entries after removing");
}
public override void BuildCustomFields(ShaderInput input)
{
m_Keyword = input as ShaderKeyword;
if (m_Keyword == null)
{
return;
}
// KeywordDefinition
var keywordDefinitionField = new EnumField((Enum)m_Keyword.keywordDefinition);
keywordDefinitionField.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Keyword Type");
if (m_Keyword.keywordDefinition == (KeywordDefinition)evt.newValue)
{
return;
}
m_Keyword.keywordDefinition = (KeywordDefinition)evt.newValue;
Rebuild();
});
AddRow("Definition", keywordDefinitionField, m_Keyword.isEditable);
// KeywordScope
if (m_Keyword.keywordDefinition != KeywordDefinition.Predefined)
{
var keywordScopeField = new EnumField((Enum)m_Keyword.keywordScope);
keywordScopeField.RegisterValueChangedCallback(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change Keyword Type");
if (m_Keyword.keywordScope == (KeywordScope)evt.newValue)
{
return;
}
m_Keyword.keywordScope = (KeywordScope)evt.newValue;
});
AddRow("Scope", keywordScopeField, m_Keyword.isEditable);
}
switch (m_Keyword.keywordType)
{
case KeywordType.Boolean:
BuildBooleanKeywordField(m_Keyword);
break;
case KeywordType.Enum:
BuildEnumKeywordField(m_Keyword);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public BaseShaderPreprocessor()
{
m_Transparent = new ShaderKeyword("_SURFACE_TYPE_TRANSPARENT");
m_DebugDisplay = new ShaderKeyword("DEBUG_DISPLAY");
m_TileLighting = new ShaderKeyword("USE_FPTL_LIGHTLIST");
m_ClusterLighting = new ShaderKeyword("USE_CLUSTERED_LIGHTLIST");
m_LodFadeCrossFade = new ShaderKeyword("LOD_FADE_CROSSFADE");
m_DecalsOFF = new ShaderKeyword("DECALS_OFF");
m_Decals3RT = new ShaderKeyword("DECALS_3RT");
m_Decals4RT = new ShaderKeyword("DECALS_4RT");
m_LightLayers = new ShaderKeyword("LIGHT_LAYERS");
}
//判断字符串是那种关键字
public static ShaderKeywordType GetKeywordType(string key)
{
try
{
ShaderKeyword shaderKeyword = new ShaderKeyword(key);
return(shaderKeyword.GetKeywordType());
}
catch
{
return(ShaderKeywordType.None);
}
}
public ShadowKeywords()
{
ShadowLow = new ShaderKeyword("SHADOW_LOW");
ShadowMedium = new ShaderKeyword("SHADOW_MEDIUM");
ShadowHigh = new ShaderKeyword("SHADOW_HIGH");
ShadowVariants = new Dictionary <HDShadowFilteringQuality, ShaderKeyword>
{
{ HDShadowFilteringQuality.Low, ShadowLow },
{ HDShadowFilteringQuality.Medium, ShadowMedium },
{ HDShadowFilteringQuality.High, ShadowHigh },
};
}
protected override bool MatchVariant(ShaderCompilerData variantData)
{
for (int i = 0; i < _blacklistedKeywords.Count; ++i)
{
var s = _blacklistedKeywords[i];
var key = new ShaderKeyword(s);
if (variantData.shaderKeywordSet.IsEnabled(key))
{
return(true);
}
}
return(false);
}
void BuildBooleanKeywordField(PropertySheet propertySheet, ShaderKeyword keyword)
{
var toggleDataPropertyDrawer = new ToggleDataPropertyDrawer();
propertySheet.Add(toggleDataPropertyDrawer.CreateGUI(
newValue =>
{
this._preChangeValueCallback("Change property value");
keyword.value = newValue.isOn ? 1 : 0;
this._postChangeValueCallback(false, ModificationScope.Graph);
},
new ToggleData(keyword.value == 1),
"Default",
out var boolKeywordField));
}
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);
}
protected override bool StripCustom(Shader shader, ShaderSnippetData passData, IList <ShaderCompilerData> variantData)
{
foreach (var d in variantData)
{
// Builtins
foreach (var b in _forceBuiltins)
{
bool matched = d.platformKeywordSet.IsEnabled(b.defineToMatch);
if (b.invertMatch)
{
matched = !matched;
}
if (matched)
{
if (b.invertForce)
{
d.platformKeywordSet.Disable(b.defineToForce);
}
else
{
d.platformKeywordSet.Enable(b.defineToForce);
}
}
}
// Keywords
foreach (var k in _forceKeywords)
{
bool matched = d.shaderKeywordSet.IsEnabled(new ShaderKeyword(k.keywordToMatch));
if (k.invertMatch)
{
matched = !matched;
}
if (matched)
{
ShaderKeyword sk = new ShaderKeyword(k.keywordToForce);
if (k.invertForce)
{
d.shaderKeywordSet.Disable(sk);
}
else
{
d.shaderKeywordSet.Enable(sk);
}
}
}
}
return(true);
}
public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> data)
{
return;
if (shader.name != "MJ/Test_shaderfeature")
{
return;
}
// 只处理 vertex 和 fragment lit.shad阶段 //
List <string> kwToKeep = null;
if (snippet.shaderType == ShaderType.Vertex)
{
kwToKeep = KeyworsToKeep_VP;
}
else if (snippet.shaderType == ShaderType.Fragment)
{
kwToKeep = KeyworsToKeep_FP;
}
if (kwToKeep == null)
{
return;
}
for (int i = data.Count - 1; i >= 0; i--)
{
ShaderCompilerData scd = data[i];
bool neesStrip = false;
for (int j = 0; j < kwToKeep.Count; j++)
{
ShaderKeyword kw = new ShaderKeyword(kwToKeep[j]);
if (!scd.shaderKeywordSet.IsEnabled(kw))
{
neesStrip = true;
break;
}
}
if (neesStrip)
{
data.RemoveAt(i);
}
}
}
private void StripKeyword(ShaderKeyword keyword, ref IList <ShaderCompilerData> compilerDataList, ref int i, ShaderSnippetData snippet, bool condition = true)
{
if (condition && compilerDataList[i].shaderKeywordSet.IsEnabled(keyword))
{
compilerDataList.RemoveAt(i);
--i;
#if ENABLE_SHADER_STRIPPING_LOG && !ENABLE_DEEP_STRIPPING_LOG
Debug.Log("Stripped " + GetKeywordName(waterShader, keyword));
#endif
#if ENABLE_DEEP_STRIPPING_LOG
File.AppendAllText(LOG_FILEPATH, "- " + $"Stripped {GetKeywordName(waterShader, keyword)} variant from pass {snippet.passName} (stage: {snippet.shaderType})" + "\n");
#endif
}
}
void BuildBooleanKeywordField(ShaderKeyword keyword)
{
// Default field
var field = new Toggle()
{
value = keyword.value == 1
};
field.OnToggleChanged(evt =>
{
graph.owner.RegisterCompleteObjectUndo("Change property value");
keyword.value = evt.newValue ? 1 : 0;
DirtyNodes(ModificationScope.Graph);
});
AddRow("Default", field);
}
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));
}
}
/// <summary>
/// 转换成Keywords
/// </summary>
private string[] ConvertToKeywords(ShaderKeywordSet shaderKeywordSet)
{
ShaderKeyword[] shaderKeywords = shaderKeywordSet.GetShaderKeywords();
string[] keywords = new string[shaderKeywords.Length];
for (int iKeyword = 0; iKeyword < shaderKeywords.Length; iKeyword++)
{
ShaderKeyword iterKeyword = shaderKeywords[iKeyword];
keywords[iKeyword] =
#if UNITY_2019_1_OR_NEWER
ShaderKeyword.GetGlobalKeywordName(iterKeyword)
#else
m_KeywordNames[UnityEngineReflectionUtility.ShaderKeyword.GetShaderKeywordIndex(iterKeyword)]
#endif
;
}
return(keywords);
}
