public void WarmUpShader()
{
if (!ConstantData.EnableAssetBundle)
{
return;
}
if (m_hasWarm)
{
return;
}
m_hasWarm = true;
LoadBundle("shader", (data) => {
AssetBundle ab = data as AssetBundle;
if (ab == null)
{
return;
}
ShaderVariantCollection variant = ab.LoadAsset <ShaderVariantCollection>("warmshader");
if (variant != null)
{
variant.WarmUp();
}
});
}
public ShaderVariantCollectionInfoGUI(ShaderVariantCollection collection)
{
variantCollection = collection;
serializedObject = new SerializedObject(collection);
ConstructShaderList();
}
/// <summary>
/// Collect shader variants from shader files which are under the given path.
/// </summary>
public void CollectShaderVariants()
{
if (folders.Length <= 0)
{
string msg = "Empty folders.\nSpecify folder where shader files are.\nNote the path should start with 'Assets/'.";
EditorUtility.DisplayDialog("Error", msg, "OK");
return;
}
var collection = new ShaderVariantCollection();
var shaders = AssetDatabase.FindAssets("t:Shader", folders);
try
{
foreach (var guid in shaders)
{
var path = AssetDatabase.GUIDToAssetPath(guid);
var shader = AssetDatabase.LoadAssetAtPath <Shader>(path);
var variant = new ShaderVariantCollection.ShaderVariant(shader, passType, keywords);
collection.Add(variant);
}
}
catch (Exception e)
{
// Throw an ArgumentException if shader is null,
// pass type does not exist or variant with the passed keywords is not found.
EditorUtility.DisplayDialog("Error", e.Message, "OK");
}
// save as asset.
string assetPath = Path.Combine(outputPath, assetFileName + assetFileExt);
AssetDatabase.CreateAsset(collection, assetPath);
}
public IEnumerable Init()
{
while (_IsLoading)
{
yield return(null);
}
if (_AssetBundle != null)
{
if (EntryPoint.Instance.GameCustomConfigParams.ShaderWarmUp)
{
ShaderVariantCollection shaderCollection = _AssetBundle.LoadAsset <ShaderVariantCollection>("svc");
yield return(null);
if (null != shaderCollection)
{
shaderCollection.WarmUp();
yield return(null);
}
}
var shaderListPath = "Assets/Outputs/Shader/ShaderList.prefab";
var shaderListObj = _AssetBundle.LoadAsset(shaderListPath) as GameObject;
yield return(null);
BuildShaderList(shaderListObj);
_MobileCamtransOpaqueShader = FindShader("TERA/Environment/MobileCamtransOpaque");
_MobileCamtransShader = FindShader("TERA/Environment/MobileCamtrans");
yield return(null);
}
}
/// <summary>
/// 搜集keywords
/// </summary>
public ShaderVariantCollection CollectionKeywords(string[] matPaths, ShaderVariantCollection excludeCollection)
{
var shaderCollection = new ShaderVariantCollection();
//遍历所有mat的KeyWords
foreach (var path in matPaths)
{
//Material;
var material = AssetDatabase.LoadAssetAtPath <Material>(path);
//shader数据
var ret = shaderDataMap.TryGetValue(material.shader, out var shaderData);
if (!ret)
{
shaderData = ShaderUtilImpl.GetShaderVariantEntriesFilteredInternal(material.shader, 256, new string[] { }, excludeCollection);
shaderDataMap[material.shader] = shaderData;
}
//收集shaderVaraint
var passTypes = shaderData.passTypes.Distinct();
foreach (var pt in passTypes)
{
var shaderVaraint = AddVariantOfPassTypeToCollection((PassType)pt, material);
shaderCollection.Add(shaderVaraint);
}
//SRP的搜集
// AddVariantOfPassTypeToCollection(PassType.ScriptableRenderPipeline, material);
// //ShadiwCast的keyword
// if (material.FindPass("ShadowCaster") != -1)
// {
// AddVariantOfPassTypeToCollection(PassType.ShadowCaster, material);
// }
}
return(shaderCollection);
}
void BuildShaders()
{
ShaderVariantCollection collection = new ShaderVariantCollection();
AssetDatabase.CreateAsset(collection, "Assets/Plugins/HxVolumetricLighting/Resources/HxUsedShaderVariantCollection.shadervariants");
collection.Clear();
Shader pointShader = Shader.Find("Hidden/HxVolumetricPointLight");
Shader directionalShader = Shader.Find("Hidden/HxVolumetricDirectionalLight");
Shader spotShader = Shader.Find("Hidden/HxVolumetricSpotLight");
Shader projectorShader = Shader.Find("Hidden/HxVolumetricProjector");
for (int i = 0; i < 128; i++)
{
this.CheckShaderVariant(collection, pointShader, i, true);
this.CheckShaderVariant(collection, directionalShader, i, false);
this.CheckShaderVariant(collection, spotShader, i, false);
this.CheckShaderVariant(collection, projectorShader, i, false, true);
}
// AssetDatabase.ImportAsset()
EditorUtility.SetDirty(collection);
EditorUtility.SetDirty(this);
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(this));
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(collection));
AssetDatabase.SaveAssets();
}
private void DisplayAddVariantsWindow(Shader shader, ShaderVariantCollection collection)
{
AddShaderVariantWindow.PopupData popupData = new AddShaderVariantWindow.PopupData();
popupData.shader = shader;
popupData.collection = collection;
string[] array;
ShaderUtil.GetShaderVariantEntries(shader, collection, out popupData.types, out array);
if (array.Length == 0)
{
EditorApplication.Beep();
}
else
{
popupData.keywords = new string[array.Length][];
for (int i = 0; i < array.Length; i++)
{
popupData.keywords[i] = array[i].Split(new char[]
{
' '
});
}
AddShaderVariantWindow.ShowAddVariantWindow(popupData);
GUIUtility.ExitGUI();
}
}
void AddKeywords(
ShaderVariantCollection collection,
Shader shader,
PassType pass,
string[] keywordList)
{
if (CheckKeywords(shader, pass, keywordList))
{
List <string> keywords = new List <string>(keywordList);
// special case overrides
if (shader.name != "Hidden/VideoDecodeAndroid" &&
shader.name != "Oculus/Texture2D Blit" &&
!keywords.Contains("SHADOWS_DEPTH"))
{
keywords.Add("STEREO_MULTIVIEW_ON");
}
ShaderVariantCollection.ShaderVariant variant =
new ShaderVariantCollection.ShaderVariant();
variant.shader = shader;
variant.passType = pass;
variant.keywords = keywords.ToArray();
collection.Add(variant);
}
}
public void Pack(ShaderVariantCollection svc = null)
{
Object[] selectObs = new Object[] { svc };
if (null != selectObs && selectObs.Length > 0)
{
AssetBundleBuild[] abb = new AssetBundleBuild[selectObs.Length];
for (int i = 0; i < selectObs.Length; i++)
{
Object selectOb = selectObs[i];
string path = AssetDatabase.GetAssetPath(selectOb);
string[] files = new string[1] {
path
};
string abName = selectOb.name;
AssetBundleBuild tmp = new AssetBundleBuild()
{
assetNames = files, assetBundleName = abName
};
abb[i] = tmp;
}
if (!Directory.Exists(OutputDir))
{
Directory.CreateDirectory(OutputDir);
}
BuildPipeline.BuildAssetBundles(OutputDir, abb, BuildAssetBundleOptions.ChunkBasedCompression, EditorUserBuildSettings.activeBuildTarget);
}
}
public static void ProcessFormalSVC(Shader shader, ShaderSnippetData snippet, IList <ShaderCompilerData> data)
{
// 这里用于全局剔除不要的特殊pass编译
if (snippet.passType == PassType.LightPrePassBase ||
snippet.passType == PassType.LightPrePassFinal ||
snippet.passType == PassType.Deferred)
{
data.Clear();
return;
}
if (m_allshaderVariantDict == null)
{
m_allshaderVariantDict = new Dictionary <string, ShaderVariantCollectionItem>();
shaderVariantCollection = AssetDatabase.LoadAssetAtPath <ShaderVariantCollection>(ShaderVariantCollectionPath);
if (shaderVariantCollection == null)
{
return;
}
GetShaderVariantList(shaderVariantCollection, m_allshaderVariantDict);
}
ShaderVariantCollectionItem shaderVariantList;
if (!m_allshaderVariantDict.TryGetValue(shader.name, out shaderVariantList))
{
return;
}
for (int i = data.Count - 1; i >= 0; i--)
{
if (!shaderVariantList.IsContain(snippet.passType, data[i]))
{
data.RemoveAt(i);
}
}
}
private static void CreateShaderVariantCollection(SerializedProperty shaderVariantProperty, string folderPath)
{
Shader shader = (Shader)shaderVariantProperty.FindPropertyRelative("first").objectReferenceValue;
SerializedProperty variantsProperty = shaderVariantProperty.FindPropertyRelative("second.variants");
if (shader == null || variantsProperty == null)
{
return;
}
var variantCollectionName = shader.name.Replace('/', '-');
ShaderVariantCollection collection = new ShaderVariantCollection();
collection.name = variantCollectionName;
for (int i = 0; i < variantsProperty.arraySize; i++)
{
SerializedProperty variantProperty = variantsProperty.GetArrayElementAtIndex(i);
string keywords = variantProperty.FindPropertyRelative("keywords").stringValue;
PassType passType = (PassType)variantProperty.FindPropertyRelative("passType").intValue;
collection.Add(new ShaderVariantCollection.ShaderVariant(shader, passType, keywords.Split(' ')));
}
var filePath = folderPath + variantCollectionName + ".shadervariants";
CreateOrReplaceAsset(collection, filePath);
}
private bool ContainsShaderVariant(ShaderVariantCollection collection, Shader shader, ShaderSnippetData snippet, ShaderCompilerData data)
{
if (collection == null)
{
return(false);
}
return(collection.Contains(new ShaderVariantCollection.ShaderVariant(shader, snippet.passType, ToKeywordArray(shader, data.shaderKeywordSet))));
}
public ShaderVariantInfoUI(ShaderVariantCollection collection, string date)
{
this.variantCollection = collection;
this.dateStr = date;
ConstructShaderList();
this.InitUI();
}
private void CSVToSVC(ShaderVariantCollection _svc, string csvPath)
{
//CSVから要素を取り出す
var svList = MakeShaderVariantListFromPath(csvPath, shaderKeywordColumn, shaderNameColumn);
//CSVからの要素をShaderVariantCollectionに追加
AddShaderVariantFromShaderList(_svc, svList);
}
public ShaderVariantStripper()
{
_shaderVariantCollection = AssetDatabase.LoadAssetAtPath(ShaderVariantCollectionAssetPath,
typeof(ShaderVariantCollection)
) as ShaderVariantCollection;
_compilerKeywords = new List <string>();
}
private void AddShaderVariantFromDict(ShaderVariantCollection shaderVariantCollection)
{
foreach (var variantInfo in this.variantDict.Values)
{
var list = variantInfo.CreateShaderVariantList(this.variantFlags);
AddShaderVariantList(shaderVariantCollection, list);
}
}
private void OnGUIShaderVariant()
{
this.currentVariantCollection = EditorGUILayout.ObjectField(this.currentVariantCollection, typeof(ShaderVariantCollection), false) as ShaderVariantCollection;
this.variantFlag = (ShaderVariantCollectionCreator.EFlag)EditorGUILayout.EnumFlagsField(this.variantFlag);
if (GUILayout.Button("Add"))
{
ExecuteAddShaderVariantCollection();
}
}
public static IEnumerable <ShaderVariant> GetAllVariants(this ShaderVariantCollection collection)
{
if (collection == null)
{
return(new List <ShaderVariant>());
}
return(collection.GetProxy().AllVariants);
}
public static List <string> ShaderGetAllKeywords(Shader shader)
{
int[] passTypes;
string[] keywordLists;
ShaderVariantCollection svc = new ShaderVariantCollection();
GetShaderVariantEntries(shader, svc, out passTypes, out keywordLists);
return(KeywordCombine_GetKeywords(keywordLists));
}
// Show window to select shader variants
void DisplayAddVariantsWindow(Shader shader, ShaderVariantCollection collection)
{
var data = new AddShaderVariantWindow.PopupData();
data.shader = shader;
data.collection = collection;
AddShaderVariantWindow.ShowAddVariantWindow(data);
GUIUtility.ExitGUI();
}
public ShaderVariantStripBuildProcessor()
{
string filePath = "Assets/ResourcesAb/shader/";
string custiomSVCFile = filePath + "CustomShaderVariants.shadervariants";
string exportSVCFile = filePath + "allshader.shadervariants";
//ShaderVariantsCollection.Collect(exportSVCFile);
keepCustomVariants = AssetDatabase.LoadAssetAtPath <ShaderVariantCollection>(custiomSVCFile);
keepExportVariants = AssetDatabase.LoadAssetAtPath <ShaderVariantCollection>(exportSVCFile);
}
public ShaderVariantCollection LoadShaderVarCollection(string fileName, ResourceCacheType cacheType)
{
ShaderVariantCollection ret = mAssetLoader.LoadShaderVarCollection(fileName, cacheType);
if (ret != null)
{
return(ret);
}
return(mResLoader.LoadShaderVarCollection(fileName, cacheType));
}
private void AddShaderVariants(ShaderVariantCollection variantCollection)
{
if (variantCollection == null)
{
return;
}
assetBundleVariants.Add(variantCollection);
assetBundleShaderVariantsFold.Add(variantCollection, false);
shaderVariantInfoGUI.Add(variantCollection, new ShaderVariantCollectionInfoGUI(variantCollection));
}
/// <summary>
///
/// </summary>
/// <param name="shaderVariantCollectionName"></param>
/// <remarks>todo:貌似预加载preload后会自动 warmup</remarks>
public void WarmupShaderVariablesCollection(string shaderVariantCollectionName)
{
if (this.m_shaderVariantCollectionDict.ContainsKey(shaderVariantCollectionName))
{
ShaderVariantCollection shaderCollection = this.m_shaderVariantCollectionDict[shaderVariantCollectionName];
if (!shaderCollection.isWarmedUp)
{
shaderCollection.WarmUp();
}
}
}
public override void Setup()
{
base.Setup();
m_SegmentationShader = Shader.Find(k_SegmentationPassShaderName);
var shaderVariantCollection = new ShaderVariantCollection();
shaderVariantCollection.Add(new ShaderVariantCollection.ShaderVariant(m_SegmentationShader, PassType.ScriptableRenderPipeline));
shaderVariantCollection.WarmUp();
m_OverrideMaterial = new Material(m_SegmentationShader);
}
void LoadShadervariantCompleted(int iHandle, UnityEngine.Object obj)
{
ShaderVariantCollection shader = obj as ShaderVariantCollection;
if (shader != null)
{
Debug.Log(shader.shaderCount);
Debug.Log(shader.variantCount);
shader.WarmUp();
}
}
public void AddRemoveSvc(ShaderVariantCollection svc, bool addRemove)
{
if (addRemove)
{
svcs.Add(svc);
}
else
{
svcs.Remove(svc);
}
}
public void AddShaderVariablesCollections(ShaderVariantCollection shaderVariantCollection, bool warmup = false)
{
if (!this.m_shaderVariantCollectionDict.ContainsKey(shaderVariantCollection.name))
{
this.m_shaderVariantCollectionDict.Add(shaderVariantCollection.name, shaderVariantCollection);
if (warmup)
{
shaderVariantCollection.WarmUp();
}
}
}
private void LoadSVC(string svcFileName)
{
if (m_ab != null)
{
ShaderVariantCollection svc = m_ab.LoadAsset <ShaderVariantCollection>(svcFileName);
if (svc != null)
{
svc.WarmUp();
}
}
}
private void AddShaderVariantFromShaderList(ShaderVariantCollection _svc, List <ShaderVariantCollection.ShaderVariant> svList)
{
foreach (var sv in svList)
{
if (!_svc.Contains(sv))
{
//存在しないので追加
_svc.Add(sv);
}
}
}
