750 lines
27 KiB
C#
750 lines
27 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using NBShader;
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
|
|
namespace NBShaders2.Editor.FeatureLevel
|
|
{
|
|
public enum NBShaderBuildInfoMode
|
|
{
|
|
TierAndPass = 0,
|
|
ExactMaterialVariants = 1
|
|
}
|
|
|
|
public sealed class NBShaderBuildInfoSet
|
|
{
|
|
private readonly NBShaderMaterialBuildInfo[] m_Materials;
|
|
private readonly NBShaderVariantBuildInfo[] m_Variants;
|
|
private readonly string[] m_AllowedManagedKeywords;
|
|
private readonly string[] m_AllowedPassFeatures;
|
|
private readonly string[] m_IncludedPassNames;
|
|
|
|
public readonly NBShaderFeatureTier tier;
|
|
public readonly NBShaderBuildInfoMode mode;
|
|
|
|
public NBShaderMaterialBuildInfo[] materials { get { return (NBShaderMaterialBuildInfo[])m_Materials.Clone(); } }
|
|
public NBShaderVariantBuildInfo[] variants { get { return (NBShaderVariantBuildInfo[])m_Variants.Clone(); } }
|
|
public string[] allowedManagedKeywords { get { return (string[])m_AllowedManagedKeywords.Clone(); } }
|
|
public string[] allowedPassFeatures { get { return (string[])m_AllowedPassFeatures.Clone(); } }
|
|
public string[] includedPassNames { get { return (string[])m_IncludedPassNames.Clone(); } }
|
|
public bool hasMaterials { get { return m_Materials.Length > 0; } }
|
|
|
|
public NBShaderBuildInfoSet(
|
|
NBShaderFeatureTier tier,
|
|
NBShaderBuildInfoMode mode,
|
|
NBShaderMaterialBuildInfo[] materials,
|
|
string[] allowedManagedKeywords,
|
|
string[] allowedPassFeatures = null)
|
|
{
|
|
this.tier = tier;
|
|
this.mode = mode;
|
|
m_Materials = materials != null ? (NBShaderMaterialBuildInfo[])materials.Clone() : new NBShaderMaterialBuildInfo[0];
|
|
m_AllowedManagedKeywords = allowedManagedKeywords != null ? (string[])allowedManagedKeywords.Clone() : new string[0];
|
|
m_AllowedPassFeatures = NBShaderBuildInfoUtility.ToCatalogOrderedPassFeatures(allowedPassFeatures);
|
|
m_Variants = BuildUniqueVariants(m_Materials);
|
|
m_IncludedPassNames = BuildIncludedPassNames(m_Materials);
|
|
}
|
|
|
|
private static NBShaderVariantBuildInfo[] BuildUniqueVariants(NBShaderMaterialBuildInfo[] materials)
|
|
{
|
|
var result = new List<NBShaderVariantBuildInfo>();
|
|
var keys = new HashSet<string>(StringComparer.Ordinal);
|
|
for (var i = 0; i < materials.Length; i++)
|
|
{
|
|
var material = materials[i];
|
|
if (material == null)
|
|
continue;
|
|
|
|
var materialVariants = material.variants;
|
|
for (var v = 0; v < materialVariants.Length; v++)
|
|
{
|
|
var variant = materialVariants[v];
|
|
if (variant == null)
|
|
continue;
|
|
|
|
var key = variant.GetStableKey();
|
|
if (keys.Add(key))
|
|
result.Add(variant);
|
|
}
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
private static string[] BuildIncludedPassNames(NBShaderMaterialBuildInfo[] materials)
|
|
{
|
|
var result = new List<string>();
|
|
var set = new HashSet<string>(StringComparer.Ordinal);
|
|
for (var i = 0; i < materials.Length; i++)
|
|
{
|
|
var material = materials[i];
|
|
if (material == null)
|
|
continue;
|
|
|
|
var passNames = material.includedPassNames;
|
|
for (var p = 0; p < passNames.Length; p++)
|
|
{
|
|
var passName = passNames[p];
|
|
if (!string.IsNullOrEmpty(passName) && set.Add(passName))
|
|
result.Add(passName);
|
|
}
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
}
|
|
|
|
public sealed class NBShaderMaterialBuildInfo
|
|
{
|
|
private readonly string[] m_EffectiveKeywords;
|
|
private readonly string[] m_StrippedManagedKeywords;
|
|
private readonly string[] m_AllowedManagedKeywords;
|
|
private readonly string[] m_AllowedPassFeatures;
|
|
private readonly NBShaderPassBuildInfo[] m_Passes;
|
|
private readonly NBShaderVariantBuildInfo[] m_Variants;
|
|
private readonly string[] m_IncludedPassNames;
|
|
|
|
public readonly Material material;
|
|
public readonly Shader shader;
|
|
public readonly NBShaderFeatureTier tier;
|
|
public readonly NBShaderBuildInfoMode mode;
|
|
|
|
public string[] effectiveKeywords { get { return (string[])m_EffectiveKeywords.Clone(); } }
|
|
public string[] strippedManagedKeywords { get { return (string[])m_StrippedManagedKeywords.Clone(); } }
|
|
public string[] allowedManagedKeywords { get { return (string[])m_AllowedManagedKeywords.Clone(); } }
|
|
public string[] allowedPassFeatures { get { return (string[])m_AllowedPassFeatures.Clone(); } }
|
|
public NBShaderPassBuildInfo[] passes { get { return (NBShaderPassBuildInfo[])m_Passes.Clone(); } }
|
|
public NBShaderVariantBuildInfo[] variants { get { return (NBShaderVariantBuildInfo[])m_Variants.Clone(); } }
|
|
public string[] includedPassNames { get { return (string[])m_IncludedPassNames.Clone(); } }
|
|
|
|
public NBShaderMaterialBuildInfo(
|
|
Material material,
|
|
NBShaderFeatureTier tier,
|
|
NBShaderBuildInfoMode mode,
|
|
string[] allowedManagedKeywords,
|
|
string[] effectiveKeywords,
|
|
string[] strippedManagedKeywords,
|
|
NBShaderPassBuildInfo[] passes,
|
|
string[] allowedPassFeatures = null)
|
|
{
|
|
this.material = material;
|
|
shader = material != null ? material.shader : null;
|
|
this.tier = tier;
|
|
this.mode = mode;
|
|
m_AllowedManagedKeywords = NBShaderBuildInfoUtility.ToCatalogOrderedManagedKeywords(allowedManagedKeywords);
|
|
m_AllowedPassFeatures = NBShaderBuildInfoUtility.ToCatalogOrderedPassFeatures(allowedPassFeatures);
|
|
m_EffectiveKeywords = NBShaderBuildInfoUtility.ToCatalogOrderedManagedKeywords(effectiveKeywords);
|
|
m_StrippedManagedKeywords = NBShaderBuildInfoUtility.ToCatalogOrderedManagedKeywords(strippedManagedKeywords);
|
|
m_Passes = passes != null ? (NBShaderPassBuildInfo[])passes.Clone() : new NBShaderPassBuildInfo[0];
|
|
m_IncludedPassNames = BuildIncludedPassNames(m_Passes);
|
|
m_Variants = BuildVariants();
|
|
}
|
|
|
|
private NBShaderVariantBuildInfo[] BuildVariants()
|
|
{
|
|
if (shader == null)
|
|
return new NBShaderVariantBuildInfo[0];
|
|
|
|
var result = new List<NBShaderVariantBuildInfo>();
|
|
var materialKeywords = NBShaderBuildInfoUtility.GetCatalogExternalMaterialKeywords(material);
|
|
for (var i = 0; i < m_Passes.Length; i++)
|
|
{
|
|
var pass = m_Passes[i];
|
|
if (pass == null || !pass.included)
|
|
continue;
|
|
|
|
result.Add(new NBShaderVariantBuildInfo(
|
|
shader,
|
|
pass.passName,
|
|
pass.passType,
|
|
NBShaderBuildInfoUtility.BuildShaderVariantKeywordsForPass(
|
|
pass.passName,
|
|
pass.passType,
|
|
m_EffectiveKeywords,
|
|
materialKeywords)));
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
private static string[] BuildIncludedPassNames(NBShaderPassBuildInfo[] passes)
|
|
{
|
|
var result = new List<string>();
|
|
for (var i = 0; i < passes.Length; i++)
|
|
{
|
|
var pass = passes[i];
|
|
if (pass != null && pass.included && !string.IsNullOrEmpty(pass.passName))
|
|
result.Add(pass.passName);
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
}
|
|
|
|
public sealed class NBShaderPassBuildInfo
|
|
{
|
|
public readonly string passName;
|
|
public readonly PassType passType;
|
|
public readonly bool enabledByMaterial;
|
|
public readonly bool allowedByTier;
|
|
public readonly bool included;
|
|
public readonly string reason;
|
|
|
|
public NBShaderPassBuildInfo(
|
|
string passName,
|
|
PassType passType,
|
|
bool enabledByMaterial,
|
|
bool allowedByTier,
|
|
bool included,
|
|
string reason)
|
|
{
|
|
this.passName = passName;
|
|
this.passType = passType;
|
|
this.enabledByMaterial = enabledByMaterial;
|
|
this.allowedByTier = allowedByTier;
|
|
this.included = included;
|
|
this.reason = reason;
|
|
}
|
|
}
|
|
|
|
public sealed class NBShaderVariantBuildInfo
|
|
{
|
|
private readonly string[] m_Keywords;
|
|
|
|
public readonly Shader shader;
|
|
public readonly string passName;
|
|
public readonly PassType passType;
|
|
public string[] keywords { get { return (string[])m_Keywords.Clone(); } }
|
|
|
|
public NBShaderVariantBuildInfo(Shader shader, string passName, PassType passType, string[] keywords)
|
|
{
|
|
this.shader = shader;
|
|
this.passName = passName;
|
|
this.passType = passType;
|
|
m_Keywords = NBShaderBuildInfoUtility.ToShaderVariantOrderedKeywords(keywords);
|
|
}
|
|
|
|
public string GetStableKey()
|
|
{
|
|
string shaderName = shader != null ? shader.name : string.Empty;
|
|
return shaderName + "|" + passName + "|" + passType + "|" + string.Join(";", m_Keywords);
|
|
}
|
|
}
|
|
|
|
internal static class NBShaderBuildInfoUtility
|
|
{
|
|
public static PassType GetPassType(string passName)
|
|
{
|
|
if (passName == "SRPDefaultUnlit")
|
|
return PassType.ScriptableRenderPipelineDefaultUnlit;
|
|
if (passName == "ShadowCaster")
|
|
return PassType.ShadowCaster;
|
|
return PassType.ScriptableRenderPipeline;
|
|
}
|
|
|
|
public static string[] FilterKeywordsForPass(string passName, PassType passType, IEnumerable<string> keywords)
|
|
{
|
|
var declaredKeywords = GetDeclaredKeywords(passName, passType);
|
|
var result = new List<string>();
|
|
var source = ToCatalogOrderedManagedKeywords(keywords);
|
|
for (var i = 0; i < source.Length; i++)
|
|
{
|
|
var keyword = source[i];
|
|
if (declaredKeywords.Contains(keyword))
|
|
result.Add(keyword);
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
public static string[] BuildShaderVariantKeywordsForPass(
|
|
string passName,
|
|
PassType passType,
|
|
IEnumerable<string> managedKeywords,
|
|
IEnumerable<string> externalKeywords)
|
|
{
|
|
var declaredKeywords = GetDeclaredShaderVariantKeywords(passName, passType);
|
|
var source = new HashSet<string>(StringComparer.Ordinal);
|
|
|
|
var managed = ToCatalogOrderedManagedKeywords(managedKeywords);
|
|
for (var i = 0; i < managed.Length; i++)
|
|
{
|
|
var keyword = managed[i];
|
|
source.Add(keyword);
|
|
if (string.Equals(keyword, "_FX_LIGHT_MODE_SIX_WAY", StringComparison.Ordinal))
|
|
source.Add("EVALUATE_SH_VERTEX");
|
|
}
|
|
|
|
if (externalKeywords != null)
|
|
{
|
|
foreach (var keyword in externalKeywords)
|
|
{
|
|
if (IsCatalogExternalShaderKeyword(keyword))
|
|
source.Add(keyword);
|
|
}
|
|
}
|
|
|
|
var result = new List<string>();
|
|
for (var i = 0; i < NBShaderFeatureCatalog.RawKeywords.Length; i++)
|
|
{
|
|
var keyword = NBShaderFeatureCatalog.RawKeywords[i];
|
|
if (source.Contains(keyword) && declaredKeywords.Contains(keyword))
|
|
result.Add(keyword);
|
|
}
|
|
|
|
for (var i = 0; i < CatalogExternalShaderKeywordOrder.Length; i++)
|
|
{
|
|
var keyword = CatalogExternalShaderKeywordOrder[i];
|
|
if (source.Contains(keyword) && declaredKeywords.Contains(keyword))
|
|
result.Add(keyword);
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
public static string[] GetCatalogExternalMaterialKeywords(Material material)
|
|
{
|
|
if (material == null || material.shaderKeywords == null || material.shaderKeywords.Length == 0)
|
|
return new string[0];
|
|
|
|
var result = new List<string>();
|
|
var source = new HashSet<string>(material.shaderKeywords, StringComparer.Ordinal);
|
|
for (var i = 0; i < CatalogExternalShaderKeywordOrder.Length; i++)
|
|
{
|
|
var keyword = CatalogExternalShaderKeywordOrder[i];
|
|
if (source.Contains(keyword))
|
|
result.Add(keyword);
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
public static string[] ToCatalogOrderedManagedKeywords(IEnumerable<string> keywords)
|
|
{
|
|
var set = new HashSet<string>(StringComparer.Ordinal);
|
|
if (keywords != null)
|
|
{
|
|
foreach (var keyword in keywords)
|
|
{
|
|
if (NBShaderFeatureCatalog.IsManagedKeyword(keyword))
|
|
set.Add(keyword);
|
|
}
|
|
}
|
|
|
|
if (set.Count == 0)
|
|
return new string[0];
|
|
|
|
var result = new List<string>();
|
|
for (var i = 0; i < NBShaderFeatureCatalog.RawKeywords.Length; i++)
|
|
{
|
|
var keyword = NBShaderFeatureCatalog.RawKeywords[i];
|
|
if (set.Contains(keyword))
|
|
result.Add(keyword);
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
public static string[] ToShaderVariantOrderedKeywords(IEnumerable<string> keywords)
|
|
{
|
|
var set = new HashSet<string>(StringComparer.Ordinal);
|
|
if (keywords != null)
|
|
{
|
|
foreach (var keyword in keywords)
|
|
{
|
|
if (NBShaderFeatureCatalog.IsManagedKeyword(keyword) ||
|
|
IsCatalogExternalShaderKeyword(keyword))
|
|
{
|
|
set.Add(keyword);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (set.Count == 0)
|
|
return new string[0];
|
|
|
|
var result = new List<string>();
|
|
for (var i = 0; i < NBShaderFeatureCatalog.RawKeywords.Length; i++)
|
|
{
|
|
var keyword = NBShaderFeatureCatalog.RawKeywords[i];
|
|
if (set.Contains(keyword))
|
|
result.Add(keyword);
|
|
}
|
|
|
|
for (var i = 0; i < CatalogExternalShaderKeywordOrder.Length; i++)
|
|
{
|
|
var keyword = CatalogExternalShaderKeywordOrder[i];
|
|
if (set.Contains(keyword))
|
|
result.Add(keyword);
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
public static string[] ToCatalogOrderedPassFeatures(IEnumerable<string> passFeatures)
|
|
{
|
|
var set = new HashSet<string>(StringComparer.Ordinal);
|
|
if (passFeatures != null)
|
|
{
|
|
foreach (var passFeature in passFeatures)
|
|
{
|
|
if (NBShaderPassFeatureCatalog.IsManagedPassFeature(passFeature))
|
|
set.Add(passFeature);
|
|
}
|
|
}
|
|
|
|
if (set.Count == 0)
|
|
return new string[0];
|
|
|
|
var result = new List<string>();
|
|
for (var i = 0; i < NBShaderPassFeatureCatalog.RawPassFeatureIds.Length; i++)
|
|
{
|
|
var passFeature = NBShaderPassFeatureCatalog.RawPassFeatureIds[i];
|
|
if (set.Contains(passFeature))
|
|
result.Add(passFeature);
|
|
}
|
|
|
|
return result.ToArray();
|
|
}
|
|
|
|
public static bool ContainsPassName(string[] passNames, string passName)
|
|
{
|
|
if (passNames == null || string.IsNullOrEmpty(passName))
|
|
return false;
|
|
|
|
for (var i = 0; i < passNames.Length; i++)
|
|
{
|
|
if (string.Equals(passNames[i], passName, StringComparison.Ordinal))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static bool IsSubsetOf(string[] subset, string[] superset)
|
|
{
|
|
var set = new HashSet<string>(superset ?? new string[0], StringComparer.Ordinal);
|
|
if (subset == null)
|
|
return true;
|
|
|
|
for (var i = 0; i < subset.Length; i++)
|
|
{
|
|
if (!set.Contains(subset[i]))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static bool AreKeywordSetsEqual(string[] a, string[] b)
|
|
{
|
|
var normalizedA = ToCatalogOrderedManagedKeywords(a);
|
|
var normalizedB = ToCatalogOrderedManagedKeywords(b);
|
|
if (normalizedA.Length != normalizedB.Length)
|
|
return false;
|
|
|
|
for (var i = 0; i < normalizedA.Length; i++)
|
|
{
|
|
if (!string.Equals(normalizedA[i], normalizedB[i], StringComparison.Ordinal))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private static HashSet<string> GetDeclaredKeywords(string passName, PassType passType)
|
|
{
|
|
if (passType == PassType.ShadowCaster)
|
|
return DeclaredDepthShadowKeywords;
|
|
|
|
if (string.Equals(passName, "DepthOnly", StringComparison.Ordinal))
|
|
return DeclaredDepthShadowKeywords;
|
|
|
|
if (string.Equals(passName, "NBCameraOpaqueDistortPass", StringComparison.Ordinal) ||
|
|
string.Equals(passName, "NBDeferredDistortPass", StringComparison.Ordinal))
|
|
{
|
|
return DeclaredDistortKeywords;
|
|
}
|
|
|
|
if (string.Equals(passName, "Universal2D", StringComparison.Ordinal))
|
|
return DeclaredUniversal2DKeywords;
|
|
|
|
return DeclaredForwardKeywords;
|
|
}
|
|
|
|
private static HashSet<string> GetDeclaredShaderVariantKeywords(string passName, PassType passType)
|
|
{
|
|
if (passType == PassType.ShadowCaster)
|
|
return DeclaredShadowCasterShaderVariantKeywords;
|
|
|
|
if (string.Equals(passName, "DepthOnly", StringComparison.Ordinal))
|
|
return DeclaredDepthOnlyShaderVariantKeywords;
|
|
|
|
if (string.Equals(passName, "NBCameraOpaqueDistortPass", StringComparison.Ordinal) ||
|
|
string.Equals(passName, "NBDeferredDistortPass", StringComparison.Ordinal))
|
|
{
|
|
return DeclaredDistortShaderVariantKeywords;
|
|
}
|
|
|
|
if (string.Equals(passName, "Universal2D", StringComparison.Ordinal))
|
|
return DeclaredUniversal2DShaderVariantKeywords;
|
|
|
|
return DeclaredForwardShaderVariantKeywords;
|
|
}
|
|
|
|
private static bool IsCatalogExternalShaderKeyword(string keyword)
|
|
{
|
|
return !string.IsNullOrEmpty(keyword) && CatalogExternalShaderKeywordSet.Contains(keyword);
|
|
}
|
|
|
|
private static readonly string[] CatalogExternalShaderKeywordOrder =
|
|
{
|
|
"EVALUATE_SH_VERTEX",
|
|
"EVALUATE_SH_MIXED",
|
|
"SOFT_UI_FRAME",
|
|
"UNITY_UI_CLIP_RECT",
|
|
"_ADDITIONAL_LIGHTS_VERTEX",
|
|
"_ADDITIONAL_LIGHTS",
|
|
"_CASTING_PUNCTUAL_LIGHT_SHADOW"
|
|
};
|
|
|
|
private static readonly HashSet<string> CatalogExternalShaderKeywordSet =
|
|
new HashSet<string>(CatalogExternalShaderKeywordOrder, StringComparer.Ordinal);
|
|
|
|
private static readonly HashSet<string> DeclaredForwardKeywords = BuildDeclaredKeywordSet(
|
|
"NB_DEBUG_DISSOLVE",
|
|
"NB_DEBUG_DISTORT",
|
|
"NB_DEBUG_FRESNEL",
|
|
"NB_DEBUG_MASK",
|
|
"NB_DEBUG_PNOISE",
|
|
"NB_DEBUG_VERTEX_OFFSET",
|
|
"VFX_SIX_WAY_ABSORPTION",
|
|
"_ALPHAMODULATE_ON",
|
|
"_ALPHAPREMULTIPLY_ON",
|
|
"_ALPHATEST_ON",
|
|
"_CHROMATIC_ABERRATION",
|
|
"_COLORMAPBLEND",
|
|
"_COLOR_RAMP",
|
|
"_COLOR_RAMP_MAP",
|
|
"_DEPTH_DECAL",
|
|
"_DEPTH_OUTLINE",
|
|
"_DISSOLVE",
|
|
"_DISSOLVE_MASK",
|
|
"_DISSOLVE_RAMP",
|
|
"_DISSOLVE_RAMP_MAP",
|
|
"_DISTANCE_FADE",
|
|
"_DISTORT_REFRACTION",
|
|
"_EMISSION",
|
|
"_FLIPBOOKBLENDING_ON",
|
|
"_FRESNEL",
|
|
"_FX_LIGHT_MODE_BLINN_PHONG",
|
|
"_FX_LIGHT_MODE_HALF_LAMBERT",
|
|
"_FX_LIGHT_MODE_PBR",
|
|
"_FX_LIGHT_MODE_SIX_WAY",
|
|
"_FX_LIGHT_MODE_UNLIT",
|
|
"_HOUDINI_VAT_DYNAMIC_REMESH",
|
|
"_HOUDINI_VAT_PARTICLE_SPRITE",
|
|
"_HOUDINI_VAT_RIGIDBODY",
|
|
"_HOUDINI_VAT_SOFTBODY",
|
|
"_MASKMAP_ON",
|
|
"_MASKMAP2_ON",
|
|
"_MASKMAP3_ON",
|
|
"_MATCAP",
|
|
"_NOISEMAP",
|
|
"_NOISE_MASKMAP",
|
|
"_NORMALMAP",
|
|
"_OVERRIDE_Z",
|
|
"_PARALLAX_MAPPING",
|
|
"_PROGRAM_NOISE",
|
|
"_PROGRAM_NOISE_SIMPLE",
|
|
"_PROGRAM_NOISE_VORONOI",
|
|
"_SCRIPTABLETIME",
|
|
"_SHARED_UV",
|
|
"_SOFTPARTICLES_ON",
|
|
"_SPECULAR_COLOR",
|
|
"_STENCIL_WITHOUT_PLAYER",
|
|
"_TYFLOW_VAT_ABSOLUTE",
|
|
"_TYFLOW_VAT_RELATIVE",
|
|
"_TYFLOW_VAT_SKIN_PR",
|
|
"_TYFLOW_VAT_SKIN_PRSAVE",
|
|
"_TYFLOW_VAT_SKIN_PRSXYZ",
|
|
"_TYFLOW_VAT_SKIN_R",
|
|
"_UNSCALETIME",
|
|
"_VAT",
|
|
"_VAT_HOUDINI",
|
|
"_VAT_TYFLOW",
|
|
"_VERTEX_OFFSET",
|
|
"_VERTEX_OFFSET_MASKMAP");
|
|
|
|
private static readonly HashSet<string> DeclaredDistortKeywords = BuildDeclaredKeywordSet(
|
|
"_ALPHAMODULATE_ON",
|
|
"_ALPHAPREMULTIPLY_ON",
|
|
"_ALPHATEST_ON",
|
|
"_CHROMATIC_ABERRATION",
|
|
"_DEPTH_DECAL",
|
|
"_DEPTH_OUTLINE",
|
|
"_DISSOLVE",
|
|
"_DISSOLVE_MASK",
|
|
"_DISSOLVE_RAMP",
|
|
"_DISSOLVE_RAMP_MAP",
|
|
"_DISTANCE_FADE",
|
|
"_DISTORT_REFRACTION",
|
|
"_FLIPBOOKBLENDING_ON",
|
|
"_FRESNEL",
|
|
"_FX_LIGHT_MODE_UNLIT",
|
|
"_MASKMAP_ON",
|
|
"_MASKMAP2_ON",
|
|
"_MASKMAP3_ON",
|
|
"_NOISEMAP",
|
|
"_NOISE_MASKMAP",
|
|
"_NORMALMAP",
|
|
"_PROGRAM_NOISE",
|
|
"_PROGRAM_NOISE_SIMPLE",
|
|
"_PROGRAM_NOISE_VORONOI",
|
|
"_SCRIPTABLETIME",
|
|
"_SHARED_UV",
|
|
"_SOFTPARTICLES_ON",
|
|
"_STENCIL_WITHOUT_PLAYER",
|
|
"_UNSCALETIME",
|
|
"_VERTEX_OFFSET",
|
|
"_VERTEX_OFFSET_MASKMAP");
|
|
|
|
private static readonly HashSet<string> DeclaredDepthShadowKeywords = BuildDeclaredKeywordSet(
|
|
"_ALPHATEST_ON",
|
|
"_DISSOLVE",
|
|
"_DISSOLVE_MASK",
|
|
"_FLIPBOOKBLENDING_ON",
|
|
"_HOUDINI_VAT_DYNAMIC_REMESH",
|
|
"_HOUDINI_VAT_PARTICLE_SPRITE",
|
|
"_HOUDINI_VAT_RIGIDBODY",
|
|
"_HOUDINI_VAT_SOFTBODY",
|
|
"_MASKMAP_ON",
|
|
"_MASKMAP2_ON",
|
|
"_MASKMAP3_ON",
|
|
"_NOISEMAP",
|
|
"_NOISE_MASKMAP",
|
|
"_PROGRAM_NOISE",
|
|
"_PROGRAM_NOISE_SIMPLE",
|
|
"_PROGRAM_NOISE_VORONOI",
|
|
"_SCRIPTABLETIME",
|
|
"_SHARED_UV",
|
|
"_TYFLOW_VAT_ABSOLUTE",
|
|
"_TYFLOW_VAT_RELATIVE",
|
|
"_TYFLOW_VAT_SKIN_PR",
|
|
"_TYFLOW_VAT_SKIN_PRSAVE",
|
|
"_TYFLOW_VAT_SKIN_PRSXYZ",
|
|
"_TYFLOW_VAT_SKIN_R",
|
|
"_UNSCALETIME",
|
|
"_VAT",
|
|
"_VAT_HOUDINI",
|
|
"_VAT_TYFLOW",
|
|
"_VERTEX_OFFSET",
|
|
"_VERTEX_OFFSET_MASKMAP");
|
|
|
|
private static readonly HashSet<string> DeclaredUniversal2DKeywords = BuildDeclaredKeywordSet(
|
|
"_ALPHAMODULATE_ON",
|
|
"_ALPHAPREMULTIPLY_ON",
|
|
"_ALPHATEST_ON",
|
|
"_CHROMATIC_ABERRATION",
|
|
"_COLORMAPBLEND",
|
|
"_COLOR_RAMP",
|
|
"_COLOR_RAMP_MAP",
|
|
"_DISSOLVE",
|
|
"_DISSOLVE_MASK",
|
|
"_DISSOLVE_RAMP",
|
|
"_DISSOLVE_RAMP_MAP",
|
|
"_EMISSION",
|
|
"_FLIPBOOKBLENDING_ON",
|
|
"_FRESNEL",
|
|
"_FX_LIGHT_MODE_UNLIT",
|
|
"_MASKMAP_ON",
|
|
"_MASKMAP2_ON",
|
|
"_MASKMAP3_ON",
|
|
"_NOISEMAP",
|
|
"_NOISE_MASKMAP",
|
|
"_NORMALMAP",
|
|
"_PARCUSTOMDATA_ON",
|
|
"_PROGRAM_NOISE",
|
|
"_PROGRAM_NOISE_SIMPLE",
|
|
"_PROGRAM_NOISE_VORONOI",
|
|
"_SCREEN_DISTORT_MODE",
|
|
"_SCRIPTABLETIME",
|
|
"_SHARED_UV",
|
|
"_STENCIL_WITHOUT_PLAYER",
|
|
"_UNSCALETIME",
|
|
"_VERTEX_OFFSET",
|
|
"_VERTEX_OFFSET_MASKMAP");
|
|
|
|
private static readonly HashSet<string> DeclaredForwardShaderVariantKeywords =
|
|
BuildDeclaredShaderVariantKeywordSet(
|
|
DeclaredForwardKeywords,
|
|
"SOFT_UI_FRAME",
|
|
"EVALUATE_SH_MIXED",
|
|
"EVALUATE_SH_VERTEX",
|
|
"UNITY_UI_CLIP_RECT",
|
|
"_ADDITIONAL_LIGHTS_VERTEX",
|
|
"_ADDITIONAL_LIGHTS");
|
|
|
|
private static readonly HashSet<string> DeclaredDistortShaderVariantKeywords =
|
|
BuildDeclaredShaderVariantKeywordSet(
|
|
DeclaredDistortKeywords,
|
|
"SOFT_UI_FRAME",
|
|
"EVALUATE_SH_MIXED",
|
|
"EVALUATE_SH_VERTEX");
|
|
|
|
private static readonly HashSet<string> DeclaredDepthOnlyShaderVariantKeywords =
|
|
BuildDeclaredShaderVariantKeywordSet(
|
|
DeclaredDepthShadowKeywords);
|
|
|
|
private static readonly HashSet<string> DeclaredShadowCasterShaderVariantKeywords =
|
|
BuildDeclaredShaderVariantKeywordSet(
|
|
DeclaredDepthShadowKeywords,
|
|
"_CASTING_PUNCTUAL_LIGHT_SHADOW");
|
|
|
|
private static readonly HashSet<string> DeclaredUniversal2DShaderVariantKeywords =
|
|
BuildDeclaredShaderVariantKeywordSet(
|
|
DeclaredUniversal2DKeywords,
|
|
"SOFT_UI_FRAME",
|
|
"EVALUATE_SH_MIXED",
|
|
"EVALUATE_SH_VERTEX",
|
|
"UNITY_UI_CLIP_RECT",
|
|
"_ADDITIONAL_LIGHTS_VERTEX",
|
|
"_ADDITIONAL_LIGHTS");
|
|
|
|
private static HashSet<string> BuildDeclaredKeywordSet(params string[] keywords)
|
|
{
|
|
var result = new HashSet<string>(StringComparer.Ordinal);
|
|
if (keywords == null)
|
|
return result;
|
|
|
|
for (var i = 0; i < keywords.Length; i++)
|
|
{
|
|
var keyword = keywords[i];
|
|
if (NBShaderFeatureCatalog.IsManagedKeyword(keyword))
|
|
result.Add(keyword);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private static HashSet<string> BuildDeclaredShaderVariantKeywordSet(
|
|
HashSet<string> managedKeywords,
|
|
params string[] externalKeywords)
|
|
{
|
|
var result = new HashSet<string>(managedKeywords ?? new HashSet<string>(), StringComparer.Ordinal);
|
|
if (externalKeywords == null)
|
|
return result;
|
|
|
|
for (var i = 0; i < externalKeywords.Length; i++)
|
|
{
|
|
var keyword = externalKeywords[i];
|
|
if (IsCatalogExternalShaderKeyword(keyword))
|
|
result.Add(keyword);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
}
|