public static void CreateShaderVariants()
{
var shaderVariantPath = "Assets/Shaders/ShaderVariants/";
var shaderPath = "Assets/Shaders/";
if (Directory.Exists(shaderVariantPath))
{
Directory.Delete(shaderVariantPath, true);
}
var shaderList = UnityEditorHelper.GetAllObjects <Shader>("shader", shaderPath);
var matList = UnityEditorHelper.GetAllObjects <Material>("mat");
var shaderVariantDict = new Dictionary <string, HashSet <ShaderVariant> >();
foreach (var mat in matList)
{
if (!mat)
{
continue;
}
var shader = mat.shader;
if (shaderList.Contains(shader))
{
var shaderVariantCollectionName = $"{Path.GetFileNameWithoutExtension(shader.name)}_ShaderVariants";
var shaderVariantCollectionPath = $"{shaderVariantPath}{shaderVariantCollectionName}.shadervariants";
if (!shaderVariantDict.TryGetValue(shaderVariantCollectionPath, out var hashSet))
{
shaderVariantDict[shaderVariantCollectionPath] = new HashSet <ShaderVariant>();
}
var shaderVariant = new ShaderVariant
{
shader = shader,
keywords = mat.shaderKeywords
};
shaderVariantDict[shaderVariantCollectionPath].Add(shaderVariant);
}
}
foreach (var shaderVariantCollection in shaderVariantDict)
{
var path = shaderVariantCollection.Key;
if (File.Exists(path))
{
AssetDatabase.DeleteAsset(path);
AssetDatabase.Refresh();
}
var dir = path.Replace(Path.GetFileName(path), "");
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
AssetDatabase.CreateAsset(new ShaderVariantCollection(), path);
var shaderVariantCollectionAsset = AssetDatabase.LoadAssetAtPath <ShaderVariantCollection>(path);
foreach (var shaderVariant in shaderVariantCollection.Value)
{
shaderVariantCollectionAsset.Add(shaderVariant);
}
EditorUtility.SetDirty(shaderVariantCollectionAsset);
AssetDatabase.Refresh();
AssetDatabase.SaveAssets();
}
}
public static RawData GetShaderVariantEntries(Shader shader)
{
if (shader == null)
{
return(null);
}
int[] types = null;
String[] keywords = null;
object[] args = new object[] { shader, new ShaderVariantCollection(), types, keywords };
ShaderUtils.GetShaderVariantEntriesMethod.Invoke(null, args);
types = args[2] as int[];
keywords = args[3] as String[];
var result = new RawData();
for (int i = 0; i < keywords.Length; ++i)
{
var keyword = keywords[i];
var sv = new ShaderVariant(shader, ( PassType )types[i], keyword.Split(' '));
List <ShaderVariant> variants;
if (!result.TryGetValue(shader, out variants))
{
variants = new List <ShaderVariant>();
result.Add(shader, variants);
}
variants.Add(sv);
}
return(result);
}
public static ShaderVariant Factory(bool transparent, Material _material)
{
ShaderVariant sv = transparent ? (ShaderVariant) new TransparentShaderVariant() : (ShaderVariant) new OpaqueShaderVariant();
sv.material = _material;
return(sv);
}
public void BuildShaderVariant(ShaderVariant variant, Water water, WindWaves windWaves, WaterQualityLevel qualityLevel)
{
OnValidate(windWaves);
ResolveFinalSettings(qualityLevel);
variant.SetWaterKeyword("_WAVES_FFT_SLOPE", enabled && renderedMaps == MapType.Slope);
variant.SetUnityKeyword("_WAVES_ALIGN", (!water.Volume.Boundless && water.Volume.HasRenderableAdditiveVolumes && flattenMode == FlattenMode.Auto) || flattenMode == FlattenMode.ForcedOn);
variant.SetUnityKeyword("_WAVES_FFT", enabled && (renderedMaps & MapType.Displacement) != 0);
}
private void CompileVariant(Pipeline pipe, JBooth.BetterShaders.OptionOverrides overrides, string path)
{
var variant = new ShaderVariant();
variant.Pipe = pipe;
CompileVariant(overrides, path, variant);
variants.Add(variant);
}
public void BuildShaderVariant(ShaderVariant variant, Water water, WaterQualityLevel qualityLevel)
{
CreateObjects();
ResolveFinalSettings(qualityLevel);
waterWavesFFT.BuildShaderVariant(variant, water, this, qualityLevel);
waterWavesGerstner.BuildShaderVariant(variant, water, this, qualityLevel);
variant.SetWaterKeyword("_INCLUDE_SLOPE_VARIANCE", dynamicSmoothness.Enabled);
}
public void Start()
{
mInputController = FindObjectOfType <InputController>();
pointerController = FindObjectOfType <PointerController>();
deleteTool = FindObjectOfType <DeleteToolOld>();
m_MeshRenderer = GetComponent <MeshRenderer>();
m_Mat = m_MeshRenderer.material;
shaderVariant = ShaderVariant.Factory(transparent, m_Mat);
}
public void CacheShadersFromPackage(string cahced_package_name)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
PackageObject cachedPackage = GetCachedPackage(cahced_package_name);
if (cachedPackage != null)
{
AssetBundle val = cachedPackage.obj as AssetBundle;
if (val != null)
{
Shader[] array = val.LoadAllAssets <Shader>();
ShaderVariantCollection val2 = new ShaderVariantCollection();
int i = 0;
for (int num = array.Length; i < num; i++)
{
if (!array[i].get_isSupported())
{
Log.Error("no support shader : " + array[i].get_name());
}
string name = array[i].get_name();
shaderCaches.Add(name, array[i]);
if (name.StartsWith("EeL") || name.Contains("effect"))
{
ShaderVariant val3 = default(ShaderVariant);
val3.shader = array[i];
val2.Add(val3);
}
}
if (!val2.get_isWarmedUp())
{
val2.WarmUp();
}
}
}
}
private void CompileVariant(JBooth.BetterShaders.OptionOverrides overrides, string path, ShaderVariant variant)
{
var pipeline = (JBooth.BetterShaders.ShaderBuilder.RenderPipeline)variant.Pipe;
if (path.EndsWith("surfshader"))
{
variant.Code = JBooth.BetterShaders.BetterShaderImporterEditor.BuildExportShader(pipeline, overrides, path);
}
else if (path.EndsWith("stackedshader"))
{
variant.Code = JBooth.BetterShaders.StackedShaderImporterEditor.BuildExportShader(pipeline, overrides, path);
}
variant.Code = variant.Code.Replace("\n\r", "\n");
variant.Code = variant.Code.Replace("\r\n", "\n");
}
public bool Contains(ShaderVariant variant) => this.ContainsInternal(variant.shader, variant.passType, variant.keywords);
public bool Contains(ShaderVariant variant)
{
return(ContainsInternal(variant.shader, variant.passType, variant.keywords));
}
public bool Remove(ShaderVariant variant)
{
return(RemoveInternal(variant.shader, variant.passType, variant.keywords));
}
public bool Add(ShaderVariant variant)
{
return(AddInternal(variant.shader, variant.passType, variant.keywords));
}
public bool Remove(ShaderVariant variant)
{
return this.RemoveInternal(variant.shader, variant.passType, variant.keywords);
}
public bool Contains(ShaderVariant variant)
{
return this.ContainsInternal(variant.shader, variant.passType, variant.keywords);
}
public bool Add(ShaderVariant variant)
{
return this.AddInternal(variant.shader, variant.passType, variant.keywords);
}
public bool Add(ShaderVariant variant) => this.AddInternal(variant.shader, variant.passType, variant.keywords);
public bool Remove(ShaderVariant variant) => this.RemoveInternal(variant.shader, variant.passType, variant.keywords);
public void BuildShaderVariant(ShaderVariant variant, Water water, WaterQualityLevel qualityLevel)
{
OnValidate();
variant.SetWaterKeyword("_WATER_FOAM_WS", enabled && overlays == null && CheckPreresquisites());
}
public void OnProcessShader(
Shader shader,
ShaderSnippetData snippet,
IList <ShaderCompilerData> data)
{
List <ShaderVariantCollection> keepShaders = null;
foreach (var guid in AssetDatabase.FindAssets("t:ShaderStripper"))
{
string path = AssetDatabase.GUIDToAssetPath(guid);
ShaderStripper stripper = AssetDatabase.LoadAssetAtPath <ShaderStripper>(path);
if (stripper != null)
{
if (!stripper.enabled)
{
return;
}
keepShaders = stripper.keepShaders;
}
}
Debug.Assert(keepShaders != null);
if (keepShaders.Count == 0)
{
return;
}
for (int i = data.Count - 1; i >= 0; --i)
{
ShaderCompilerData variant = data[i];
List <string> keywords = new List <string>();
var variantKeywords = variant.shaderKeywordSet.GetShaderKeywords();
foreach (ShaderKeyword keyword in variantKeywords)
{
string k = keyword.GetKeywordName();
keywords.Add(k);
}
bool match = false;
try
{
ShaderVariant currentVariant = new ShaderVariant();
currentVariant.shader = shader;
currentVariant.passType = snippet.passType;
currentVariant.keywords = keywords.ToArray();
foreach (ShaderVariantCollection collection in keepShaders)
{
if (collection.Contains(currentVariant))
{
match = true;
break;
}
}
}
catch (System.ArgumentException)
{
// not valid, continue...
}
Debug.LogFormat(
"{0} shader {1} pass {2} keywords {3}",
match ? "Keep" : "Strip",
shader.name,
snippet.passType,
string.Join(" ", keywords));
if (!match)
{
data.RemoveAt(i);
}
}
}
public void BuildShaderVariant(ShaderVariant variant, Water water, WaterQualityLevel qualityLevel)
{
variant.SetWaterKeyword("_PLANAR_REFLECTIONS", enabled && (!highQuality || !qualityLevel.allowHighQualityReflections));
variant.SetWaterKeyword("_PLANAR_REFLECTIONS_HQ", enabled && highQuality && qualityLevel.allowHighQualityReflections);
}
public void BuildShaderVariant(ShaderVariant variant, Water water, WindWaves windWaves, WaterQualityLevel qualityLevel)
{
variant.SetUnityKeyword("_WAVES_GERSTNER", enabled);
}
public void BuildShaderVariant(ShaderVariant variant, Water water, WaterQualityLevel qualityLevel)
{
variant.SetWaterKeyword("_WATER_OVERLAYS", enabled);
}
