Unity Shader - Built-in管线下优化变体

已于 2024-02-26 12:26:41 修改
阅读量3.5k 收藏 19
点赞数 4
分类专栏： unity-shader unity 文章标签： unity unity shader 变体 减少shader变体
于 2021-08-30 12:36:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linjf520/article/details/119994362
版权

文章目录

变体过多的缺点

为了让大家了解为何要减少变体，这里列出变体过多的缺点

  • 打包时编译变体的时间增加（如果你的变体使用 unity built-in standard shader，那么可能会有几千个变体，编译单单这个 shader 也许会需要 10 分钟）
  • 增加 运行时 shaderlab 内存，游戏与运行时使用的变体多，那么意味着 shader 的实例很多，每个 shader 实例都是需要占用内存的
  • 增加包体大小，因为 unity shader 变体多的话 编译出来 的样本就会很多，每个样本就是一个 shader 文件（如果我们自己写引擎的话，就知道这个变体是怎么回事）

项目情况

由于项目没使用 SRP，还是 built-in 管线，那么要使用 built-in 的阴影就需要使用到 #pragma multi_compile_fwdbase

#pragma multi_compile_fwdbase 和 multi_compile_fog 生存的变体（keyword）

该内置的 pragma 会生存很多不需要的 multi_compile 的 keyword，为了定制效果，让 shader 尽可能的小，那么我们可以这么整：将 #pragma multi_compile_fwdbase 和 multi_compile_fog 编译生存的 keywrod 都手动来定义需要的

如果我们只要

  • fog linear
  • lighting
  • shadow

的功能

生存的变体

如下图，会生存一堆不需要的 keyword
在这里插入图片描述

变体的数量

如下图：98 个
在这里插入图片描述

查看编译生存的各个变体的代码，并搜索 Global Keywords - 源码级别

选中 shader 文件，点击 Inspector 视图中的按钮：Compile and show code，如下图的：
在这里插入图片描述
生存的代码中搜索 Global Keywords，就可以看到各个变体的代码

查看编译生存的各个变体 - keyword 级别

在这里插入图片描述

以上两种方式都可以查看变体情况

如何优化

根据上面 搜索 Global Keywords 的方式，我们可以知道生存了很多不必要的变体代码

变体多的缺点 上面有提到

为了优化，可以这么做，上面也有提到，这里再次重新强调一下：#pragma multi_compile_fwdbase 和 multi_compile_fog 编译生存的 keywrod 都手动来定义需要的

将 #pragma multi_compile_fwdbase 和 multi_compile_fog 预生成项拆解为单个的手动定义项

如：

//#pragma multi_compile_fog
//#pragma multi_compile_fwdbase
#define FOG_LINEAR
#define DIRECTIONAL
#define SHADOWS_SCREEN

优化之后

变体的数量剧减，有原来的 98 个变成了 6 个（还有一些自定义的 multi_compile，不然只有3个，而这三个都是内置生成的 tier:1,2,3的，这个 tier: 1,2,3暂时不知道如何删除（注：后续发现可以再 IPreprocessShaders 中删除），不然的话，只有1个变体，那么这个 shader 文件就会小的可怜，打包速度、占用内存都会极小）

在这里插入图片描述

优化后的小问题、如何解决

但是这样优化后的了另一个问题：Unity Editor 下的 Prefab、Material 都无法预览正确的效果

所以我们可以写个工具，在：打包前，批量修改 shader 的 fwdbase, fog 的变体，在打包后，在恢复过来，这样，Unity Editor 下既可以正常预览 Prefab、Material 的渲染效果，也可以在打包后变体减少

public void BuildPackage()
{
	// 打包资源前，先处理一波 shader 的 fwdbase, fog 变体替换
	BeforeAndAfterBuildShadersHandler.BeforeBuildHandle();
	// 正常 building 逻辑在此
	...
	// 打包资源后，恢复 shader 文件
	BeforeAndAfterBuildShadersHandler.AfterBuldHandle();
}

编辑器 源码

#define __DATAFORM_TXT__ // 使用 文本来存 shader 数据

// jave.lin 2021/08/30
// 打包构建前、后 shader 的处理工具
// 因为使用的是 built-in 管线，基本很多光影都需要 fwdbase, fog 等 built-in 的变体
// 而这个工具是不使用 built-in 变体，改用手动的方式来定义需要的变体
// 所以会导致 unity 编辑器是对 material 的预览效果出问题
// 因为在发布程序前，可以使用会 fwdbase, fog 等 built-in 变体
// 但是在发布程序时，必须使用自己手动的方式来定义变体（可以减少很多变体的数量）
// 如果使用 SRP 的话，可以变体的把控会更容易

using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using UnityEditor;
using UnityEngine;

// jave.lin shader 文件信息
public class ShaderFileInfo
{
    public string path;
    public UnityEngine.Shader obj;

    public string lowPath;
    public string lowShaderName;
}

// jave.lin shader 在 building 处理的工具类
public class BeforeAndAfterBuildShadersEditorWindow : EditorWindow
{
    private string defaultShadersPath = "Assets/GameAssets/shaders";
    private List<ShaderFileInfo> shaderInfoList = new List<ShaderFileInfo>();
    private List<Shader> shaderList = null;

    // 根据 shader name 过滤
    private bool shadeNameFilter = true;
    private string shaderNameFilterContent = "";
    // 根据 file name 过滤
    private bool fileNameFilter = true;
    private string fileNameFilterContent = "";
    private Vector2 dragDropFileScrollViewPos;

    [MenuItem("实用工具/资源工具/打包构建前、后 shader 的处理工具")]
    public static void _Show()
    {
        var win = EditorWindow.GetWindow<BeforeAndAfterBuildShadersEditorWindow>();
        win.titleContent = new GUIContent("打包构建前、后 shader 的处理工具");
        win.Show();
    }

    private void OnGUI()
    {
#if __DATAFORM_TXT__
        if (shaderList == null)
        {
            shaderList = new List<Shader>();
            BeforeAndAfterBuildShadersHandler.LoadDataFromTxt(BeforeAndAfterBuildShadersHandler.dataPath, shaderList);
        }
#else
        if (shaderList == null)
        {
            shaderList = new List<Shader>();
            var data = AssetDatabase.LoadAssetAtPath<BeforeAndAfterBuildShadersHandleData>(BeforeAndAfterBuildShadersHandler.dataPath);
            shaderList.AddRange(data.shaders);
        }
#endif

        var src_endabled = GUI.enabled;
        if (BeforeAndAfterBuildShadersHandler.ShaderBackupCount() > 0) GUI.enabled = false;
        if (GUILayout.Button("Building前 手动 处理"))
        {
            BeforeAndAfterBuildShadersHandler.BeforeBuildHandle();
        }
        GUI.enabled = src_endabled;

        if (BeforeAndAfterBuildShadersHandler.ShaderBackupCount() == 0) GUI.enabled = false;
        if (GUILayout.Button("Building后 手动 处理"))
        {
            BeforeAndAfterBuildShadersHandler.AfterBuldHandle();
        }
        GUI.enabled = src_endabled;

        if (BeforeAndAfterBuildShadersHandler.IsMemoryBK() && GUILayout.Button("清空备份数据"))
        {
            BeforeAndAfterBuildShadersHandler.ClearBackupInfo();
        }

        if (GUILayout.Button("清理配置中不存在的shaders文件"))
        {
            BeforeAndAfterBuildShadersHandler.ClearNotExistsShaders();
        }

        DisplayCombineFileInfoList();
    }

    private void DisplayCombineFileInfoList()
    {
        EditorGUILayout.Space();

        var srcCol = GUI.contentColor;
        GUI.contentColor = Color.gray;
        EditorGUILayout.LabelField("================================================ Data List ================================================");
        GUI.contentColor = srcCol;

        EditorGUILayout.BeginHorizontal();
        if (GUILayout.Button("Clear"))
        {
            shaderInfoList.Clear();
        }
        if (GUILayout.Button("Reload"))
        {
            RefreshFileListInfo();
        }
        if (GUILayout.Button("Save"))
        {
            SaveDataAsset();
        }
        if (GUILayout.Button("Select"))
        {
            SelectAssetList();
        }
        if (GUILayout.Button("LoadShadersFolder"))
        {
            LoadShadersFolder();
        }
        EditorGUILayout.EndHorizontal();

        GUI.contentColor = Color.green;
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField($"Shader Name Filter : ", GUILayout.Width(150));
        shadeNameFilter = EditorGUILayout.Toggle(shadeNameFilter, GUILayout.Width(20));
        shaderNameFilterContent = EditorGUILayout.TextField(shaderNameFilterContent);
        EditorGUILayout.EndHorizontal();
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.LabelField($"File Name Filter : ", GUILayout.Width(150));
        fileNameFilter = EditorGUILayout.Toggle(fileNameFilter, GUILayout.Width(20));
        fileNameFilterContent = EditorGUILayout.TextField(fileNameFilterContent);
        EditorGUILayout.EndHorizontal();
        GUI.contentColor = srcCol;

        var lowShaderNameFilterContent = shaderNameFilterContent.ToLower();
        var lowFileNameFilterContent = fileNameFilterContent.ToLower();

        dragDropFileScrollViewPos = EditorGUILayout.BeginScrollView(dragDropFileScrollViewPos/*, GUILayout.Width(300), GUILayout.Width(300)*/);

        for (int i = 0; i < shaderInfoList.Count; i++)
        {
            var remove = false;
            var info = shaderInfoList[i];

            if (shadeNameFilter && !string.IsNullOrEmpty(lowShaderNameFilterContent))
            {
                if (!info.lowShaderName.Contains(lowShaderNameFilterContent))
                {
                    continue;
                }
            }

            if (fileNameFilter && !string.IsNullOrEmpty(lowFileNameFilterContent))
            {
                if (!info.lowPath.Contains(lowFileNameFilterContent))
                {
                    continue;
                }
            }

            EditorGUILayout.BeginHorizontal(GUIStyle.none);
            remove = GUILayout.Button("X", GUILayout.Width(20));
            EditorGUILayout.ObjectField(info.obj, typeof(UnityEngine.Object), false, GUILayout.Width(200));
            EditorGUILayout.TextField(info.path);
            EditorGUILayout.EndHorizontal();
            if (remove)
            {
                shaderInfoList.RemoveAt(i);
                --i;
            }
        }
        EditorGUILayout.EndScrollView();
    }

    private void RefreshFileListInfo(List<string> addList = null)
    {
        shaderInfoList.Clear();
        foreach (var shader in shaderList)
        {
            var path = AssetDatabase.GetAssetPath(shader);
            shaderInfoList.Add(new ShaderFileInfo
            {
                path = path,
                obj = shader,
                lowPath = path.ToLower(),
                lowShaderName = shader.name.ToLower(),
            });
        }
        if (shaderInfoList.Count > 1)
        {
            SortDataList();
        }
    }

    private void SortDataList()
    {
        shaderInfoList.Sort((a, b) => { return string.Compare(a.path, b.path); });
    }

    private void SaveDataAsset()
    {
        if (shaderList != null)
        {
            shaderList.Clear();
            foreach (var info in shaderInfoList)
            {
                if (info.obj == null)
                {
                    // 中途被删除
                    continue;
                }
                shaderList.Add(info.obj);
            }
            BeforeAndAfterBuildShadersHandler.SaveAsset(shaderList);
        }
    }

    private void SelectAssetList()
    {
        // jave.lin : method0, Selection.gameObjects Read Only
        //var arr = new GameObject[combineFileInfoList.Count];
        //for (int i = 0; i < arr.Length; i++)
        //{
        //    arr[i] = combineFileInfoList[i].obj as GameObject;
        //}
        //Selection.gameObjects = arr; // read only

        // jave.lin : method1 : reflection, 但是获取不了 add 方法
        //var addFunc = typeof(Selection).GetMethod(
        //    "Add", 
        //    new Type[]
        //    { 
        //        typeof(UnityEngine.Object) 
        //    },
        //    new ParameterModifier[] { new ParameterModifier(1) }
        //    );
        //Debug.Log($"PrefabCombinerEditorWindow.SelectPrefabList addFunc : {addFunc}");

        // jave.lin : method2 : Selection.objects, 后来发现此 API 可以 setter
        var arr = new UnityEngine.Object[shaderInfoList.Count];
        for (int i = 0; i < arr.Length; i++)
        {
            arr[i] = shaderInfoList[i].obj;
        }
        Selection.objects = arr;
    }

    private void LoadShadersFolder()
    {
        shaderInfoList.Clear();
        var shaderGUIDs = AssetDatabase.FindAssets("t:Shader", new string[] { defaultShadersPath });
        foreach (var guid in shaderGUIDs)
        {
            var path = AssetDatabase.GUIDToAssetPath(guid);
            var shader = AssetDatabase.LoadAssetAtPath<Shader>(path);
            shaderInfoList.Add(new ShaderFileInfo
            {
                path = path,
                obj = shader,
                lowPath = path.ToLower(),
                lowShaderName = shader.name.ToLower(),
            });
        }
    }
}

// jave.lin 文件恢复方式
public enum eFileRevertType
{
    MEMORY,
    SVN,
    GIT,
}

// jave.lin shader 的内存备份数据
public struct ShaderBackupInfo
{
    public string path;
    public string source;
}

// jave.lin building 前后的处理器
public class BeforeAndAfterBuildShadersHandler
{
    // 数据路径
#if __DATAFORM_TXT__
    public static string dataPath = "Assets/Editor/Shaders/BeforeAndAfterBuildShadersHandleTextData.txt";
#else
    public static string dataPath = "Assets/Editor/Shaders/BeforeAndAfterBuildShadersHandleData.asset";
#endif
    // shader 内存的备份数据
    private static List<ShaderBackupInfo> shaderBackInfoList = new List<ShaderBackupInfo>();
    // jave.lin : 使用 svn 还是 git
    private static eFileRevertType eFileRevertType = eFileRevertType.MEMORY;
    // jave.lin : 替换并获取缩进组
    private static Regex fogReplaceRegex = new Regex("\\n(\\s+)#pragma multi_compile_fog", RegexOptions.Compiled);
    private static Regex fwdbaseReplaceRegex = new Regex("\\n(\\s+)#pragma multi_compile_fwdbase", RegexOptions.Compiled);
    // jave.lin : 读写文件时 encoding 是否带 BOM
    private static bool readAndWriteWithBOM = false;
    // jave.lin : 换行是否 CRLF
    private static bool endLineFlagWithCRLF = true;

    private static List<Shader> shaderList = new List<Shader>();

    public static int ShaderBackupCount() => shaderBackInfoList != null ? shaderBackInfoList.Count : 0;

    // statics
    public static string GetFullPath(string assetPath)
    {
        return $"{Application.dataPath.Replace("Assets", "")}/{assetPath}".Replace("//", "/");
    }

    public static bool IsMemoryBK()=> eFileRevertType == eFileRevertType.MEMORY;

    public static void ClearBackupInfo()
    {
        shaderBackInfoList.Clear();
    }

    public static void LoadData(string assetPath, List<Shader> ret)
    {
#if __DATAFORM_TXT__
        LoadDataFromTxt(assetPath, ret);
#else
        LoadDataFromAsset(assetPath, ret);
#endif
    }

    public static void LoadDataFromAsset(string assetPath, List<Shader> ret)
    {
        var data = AssetDatabase.LoadAssetAtPath<BeforeAndAfterBuildShadersHandleData>(assetPath);
        if (data == null) return;
        ret.AddRange(data.shaders);
    }

    public static void LoadDataFromTxt(string txtPath, List<Shader> ret)
    {
        string txtContent;
        if (File.Exists(txtPath))
        {
            txtContent = File.ReadAllText(txtPath);
        }
        else
        {
            var fullPath = GetFullPath(txtPath);
            if (!File.Exists(fullPath))
            {
                return;
            }
            txtContent = File.ReadAllText(fullPath);
        }
        if (string.IsNullOrEmpty(txtContent))
        {
            return;
        }
        var paths = txtContent.Split(new string[] { "\n" }, System.StringSplitOptions.RemoveEmptyEntries);
        foreach (var path in paths)
        {
            var shader = AssetDatabase.LoadAssetAtPath<Shader>(path);
            if (shader == null) continue;
            ret.Add(shader);
        }
    }

    public static void SaveAsset(List<Shader> shaders)
    {
#if __DATAFORM_TXT__
        var content = "";
        foreach (var shader in shaders)
        {
            var shaderPath = AssetDatabase.GetAssetPath(shader);
            content += $"{shaderPath}\n";
        }
        var fullPath = GetFullPath(dataPath);
        File.WriteAllText(fullPath, content);
        AssetDatabase.Refresh();
#else
        var isNew = false;
        var data = AssetDatabase.LoadAssetAtPath<BeforeAndAfterBuildShadersHandleData>(dataPath);
        if (data == null)
        {
            data = ScriptableObject.CreateInstance<BeforeAndAfterBuildShadersHandleData>();
            isNew = true;
        }
        var saveList = new List<Shader>();
        foreach (var shader in shaders)
        {
            if (shader == null) continue; // 中途被删除
            saveList.Add(shader);
        }

        data.shaders.Clear();
        data.shaders.AddRange(saveList);

        if (!isNew) data = data.Clone();

        AssetDatabase.CreateAsset(data, dataPath);
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
#endif
    }

    // 读取 *.asset 配置的数据
    public static void BeforeBuildHandle()
    {
        // jave.lin : 遍历里面的 *.shader 逐一处理
        /*
            - 如果是shader代码使用内存恢复先备份到内存
            - 如果是shader代码使用文件恢复先备份到临时文件
            - 如果是shader代码使用svn/git的版本控制，不需要我们手动备份，恢复时直接使用svn/git来恢复即可
            - #pragma multi_compile_fog 替换为：
                - #define FOG_LINEAR
            - #pragma multi_compile_fwdbase 替换为：
                - #define DIRECTIONAL
                - #define SHADOWS_SCREEN
            - 将对应的 *.shader 文件标记为：EditorUtility.SetDirty(shaderObj);
            - 然后 AssetsDatabase.SaveAssets(); AssetsDatabase.Refresh();
         */
        shaderBackInfoList.Clear();

        shaderList.Clear();
        LoadData(dataPath, shaderList);

        if (shaderList.Count > 0)
        {
            var encoding = new System.Text.UTF8Encoding(readAndWriteWithBOM);
            var endLineStr = endLineFlagWithCRLF ? "\r\n" : "\n"; // Environment.NewLine;
            var fogReplacmentStr = $"{endLineStr}$1#define FOG_LINEAR";
            var fwdbaseReplacmentStr = $"{endLineStr}$1#define DIRECTIONAL{endLineStr}$1#define SHADOWS_SCREEN";
            foreach (var shader in shaderList)
            {
                if (shader == null) continue;
                var path = AssetDatabase.GetAssetPath(shader);
                var fullPath = GetFullPath(path);
                if (!File.Exists(fullPath)) continue;
                try
                {
                    var txt = File.ReadAllText(fullPath, encoding);
                    shaderBackInfoList.Add(new ShaderBackupInfo { path = fullPath, source = txt });
                    // jave.lin : 普通替换，缩进很难看
                    //txt = txt.Replace("#pragma multi_compile_fog", "#define FOG_LINEAR");
                    //txt = txt.Replace("#pragma multi_compile_fwdbase", "#define DIRECTIONAL\n#define SHADOWS_SCREEN");
                    // jave.lin : 使用正则来替换，缩进就可以还原来的
                    txt = fogReplaceRegex.Replace(txt, fogReplacmentStr);
                    txt = fwdbaseReplaceRegex.Replace(txt, fwdbaseReplacmentStr);
                    File.WriteAllText(fullPath, txt);
                }
                catch(System.Exception er)
                {
                    Debug.LogError(er);
                }
            }
        }
    }

    public static void AfterBuldHandle()
    {
        // jave.lin : 遍历里面的 *.shader 逐一处理
        /*
         // method 0:
            - 使用从内存中恢复shader代码（如果shader代码过多，可以考虑先backup 到 disk，然后再从 disk 恢复

         // method 1:
            - #define FOG_LINEAR 替换为：
                - #pragma multi_compile_fog
            - #define DIRECTIONAL、#define SHADOWS_SCREEN 替换为：
                - #pragma multi_compile_fwdbase
            - 将对应的 *.shader 文件标记为：EditorUtility.SetDirty(shaderObj);
            - 然后 AssetsDatabase.SaveAssets(); AssetsDatabase.Refresh();

         // method 2:（更方便的方式）
            - 使用 svn/git 命令行来还原打包后的 shaders 文件
         */
        if (shaderBackInfoList.Count == 0)
        {
            return;
        }
        if (eFileRevertType == eFileRevertType.MEMORY)
        {
            var encoding = new System.Text.UTF8Encoding(readAndWriteWithBOM);
            foreach (var info in shaderBackInfoList)
            {
                try
                {
                    File.WriteAllText(info.path, info.source, encoding);
                }
                catch (System.Exception er)
                {
                    Debug.LogError(er);
                }
            }
        }
        else
        {
            var revertFiles = new List<string>();
            foreach (var info in shaderBackInfoList)
            {
                revertFiles.Add(info.path);
            }
            try
            {
                RevertFiles(revertFiles);
            }
            catch(System.Exception er)
            {
                Debug.LogError(er);
            }
        }
        shaderBackInfoList.Clear();
    }

    public static void ClearNotExistsShaders()
    {
        shaderList.Clear();
        LoadData(dataPath, shaderList);
        if (shaderList.Count > 0)
        {
            for (int i = shaderList.Count - 1; i > -1; i--)
            {
                var shader = shaderList[i];
                if (shader == null) continue;
                var path = AssetDatabase.GetAssetPath(shader);
                var fullPath = GetFullPath(path);
                if (!File.Exists(fullPath))
                {
                    shaderList.RemoveAt(i);
                }
            }
        }
        SaveAsset(shaderList);
    }

    private static void RevertFiles(List<string> files)
    {
        // TortoiseProc.exe /command:log /path:"H:\WorkFiles\ProjectArt\Assets\Art\(Temporary).meta" /closeonend:1
        var revision = eFileRevertType.ToString().ToLower();
        System.Diagnostics.ProcessStartInfo info = new System.Diagnostics.ProcessStartInfo(revision);
        var revertFiles = string.Join<string>(" ", files);

        if (eFileRevertType == eFileRevertType.SVN)
        {
            // 需要确保安装了 小乌龟 svn 命令行工具，可参考：https://blog.csdn.net/linjf520/article/details/119617076
            // e.g.: svn revert "C:\\test1.txt" "C:\\test2.txt"
            Debug.Log($"svn revert {revertFiles}");
            info.Arguments = $" revert {revertFiles}";
        }
        else if (eFileRevertType == eFileRevertType.GIT)
        {
            // 需要确保安装了 git，使用 git checkout <file1> <file2> ... <fileN
            // e.g.: git checkout "C:\\test1.txt" "C:\\test2.txt"
            Debug.Log($"git checkout {revertFiles}");
            info.Arguments = $" checkout {revertFiles}";
        }
        else if (eFileRevertType == eFileRevertType.MEMORY)
        {
            // nops
        }
        else
        {
            Debug.LogError($"unimplements eRevesionApp : {eFileRevertType} revert handle.");
            return;
        }
        info.CreateNoWindow = false;
        info.ErrorDialog = true;
        info.UseShellExecute = true;

        if (info.UseShellExecute)
        {
            info.RedirectStandardOutput = false;
            info.RedirectStandardError = false;
            info.RedirectStandardInput = false;
        }
        else
        {
            info.RedirectStandardOutput = true;
            info.RedirectStandardError = true;
            info.RedirectStandardInput = true;
            info.StandardOutputEncoding = System.Text.UTF8Encoding.UTF8;
            info.StandardErrorEncoding = System.Text.UTF8Encoding.UTF8;
        }

        System.Diagnostics.Process process = System.Diagnostics.Process.Start(info);

        if (!info.UseShellExecute)
        {
            Debug.Log(process.StandardOutput);
            Debug.Log(process.StandardError);
        }

        process.WaitForExit();
        process.Close();
    }
}

// jave.lin building 前后需要特殊处理的 shader
[CreateAssetMenu(menuName = "Tools/Create BeforeAndAfterBuildShadersHandleData ")]
public class BeforeAndAfterBuildShadersHandleData : ScriptableObject
{
    public List<Shader> shaders;

    public BeforeAndAfterBuildShadersHandleData Clone()
    {
        var ret = ScriptableObject.CreateInstance<BeforeAndAfterBuildShadersHandleData>();
        ret.shaders = new List<Shader>(this.shaders);
        return ret;
    }
}

操作界面

可以 GUI，也可以 Script 脚本化调用
在这里插入图片描述

另外，PlayerSettings/Other Settings/Rendering/Graphics API 去掉勾，只保留要发布的单个目标平台（切换到切他平台，再切到对应平台即可）

这个 shader 变体也可以减少

示例

另外，如果是 surface shader 的话，很多的变体，可以通过 一些 surface shader 指令来删除，参考文档：Writing Surface Shaders - 搜索：Code generation options 部分

下面是 surface shader 中的 各种 noxxx 的删除变体、skip_variants 删除变体的示例：

//jave.lin - 测试删除 surface shader 的变体
#pragma surface surf Lambert fullforwardshadows addshadow alphatest:_Cutoff nodynlightmap nodirlightmap noforwardadd nolppv nofog noambient novertexlights
#pragma skip_variants SHADOWS_SCREEN LIGHTPROBE_SH VERTEXLIGHT_ON FOG_LINEAR DIRECTIONAL_COOKIE
#pragma skip_variants SPOT POINT POINT_COOKIE SHADOWS_CUBE SHADOWS_DEPTH FOG_EXP FOG_EXP2
#pragma skip_variants INSTANCING_ON DIRLIGHTMAP_COMBINED DYNAMICLIGHTMAP_ON
#pragma skip_variants UNITY_HDR_ON EDITOR_VISUALIZATION
#pragma skip_variants SHADOWS_CUBE 
#pragma fragmentoption ARB_precision_hint_fastest

multi_compile 的一些 built-in 快件方式包含的 keyword

Declaring and using shader keywords in HLSL - 查看：multi_compile shortcuts 部分

直接抄过来吧：

Unity provides several “shortcut” notations for declaring shader keywords.

The following shortcuts relate to light, shadow and lightmapping in the Built-in Render Pipeline:

  • multi_compile_fwdbase adds this set of keywords: DIRECTIONAL LIGHTMAP_ON DIRLIGHTMAP_COMBINED DYNAMICLIGHTMAP_ON SHADOWS_SCREEN SHADOWS_SHADOWMASK LIGHTMAP_SHADOW_MIXING LIGHTPROBE_SH. These variants are needed by PassType.ForwardBase.
  • multi_compile_fwdbasealpha adds this set of keywords: DIRECTIONAL LIGHTMAP_ON DIRLIGHTMAP_COMBINED DYNAMICLIGHTMAP_ON LIGHTMAP_SHADOW_MIXING VERTEXLIGHT_ON LIGHTPROBE_SH. These variants are needed by PassType.ForwardBase.
  • multi_compile_fwdadd adds this set of keywords: POINT DIRECTIONAL SPOT POINT_COOKIE DIRECTIONAL_COOKIE. These variants are needed by PassType.ForwardAdd.
  • multi_compile_fwdadd_fullshadows adds this set of keywords: POINT DIRECTIONAL SPOT POINT_COOKIE DIRECTIONAL_COOKIE SHADOWS_DEPTH SHADOWS_SCREEN SHADOWS_CUBE SHADOWS_SOFT SHADOWS_SHADOWMASK LIGHTMAP_SHADOW_MIXING. This is the same as multi_compile_fwdadd, but this adds the ability for the lights to have real-time shadows.
  • multi_compile_lightpass adds this set of keywords: POINT DIRECTIONAL SPOT POINT_COOKIE DIRECTIONAL_COOKIE SHADOWS_DEPTH SHADOWS_SCREEN SHADOWS_CUBE SHADOWS_SOFT SHADOWS_SHADOWMASK LIGHTMAP_SHADOW_MIXING. This is effectively a catch-all shortcut for all functionality related to real-time light and shadows, other than Light Probes.
  • multi_compile_shadowcaster adds this set of keywords: SHADOWS_DEPTH SHADOWS_CUBE. These variants are needed by PassType.ShadowCaster.
  • multi_compile_shadowcollector adds this set of keywords: SHADOWS_SPLIT_SPHERES SHADOWS_SINGLE_CASCADE. It also compiles variants without any of these keywords. These variants are needed for screen-space shadows.
  • multi_compile_prepassfinal adds this set of keywords: LIGHTMAP_ON DIRLIGHTMAP_COMBINED DYNAMICLIGHTMAP_ON UNITY_HDR_ON SHADOWS_SHADOWMASK LIGHTPROBE_SH. It also compiles variants without any of these keywords. These variants are needed by PassType.LightPrePassFinal and PassType.Deferred.

The following shortcuts relate to other settings:

  • multi_compile_particles adds this keyword relating to the Built-in particle system : SOFTPARTICLES_ON. It also compiles variants without this keyword. For more information, see Built-in Particle System.
  • multi_compile_fog adds this set of keywords relating to fog: FOG_LINEAR, FOG_EXP, FOG_EXP2. It also compiles variants without any of these keywords. You can control this behavior in the Graphics settings window.
  • multi_compile_instancing adds keywords relating to instancing. If the shader uses procedural instancing, it adds this set of keywords: INSTANCING_ON PROCEDURAL_ON. Otherwise, it adds this keyword: INSTANCING_ON. It also compiles variants without any of these keywords. You can control this behavior in the Graphics settings window.

ShaderFinderTool.cs

便于对需要的 shader 查找
或是 shader 变体的统计都可以使用下面自己写的工具来辅助加速分析

在这里插入图片描述

比如，我们可以 Write All Shader Variant Info Logs 后，会生成一份 csv ，然后使用 excel 打开，对 变体数量那列降序排序即可发现那个 shader 变体过多，但是这个 shader variant count 的统计感觉不太对，和 unity build asset bundle 后的变体数量差异有点大，应该是 unity API 的 BUG

在这里插入图片描述

// jave.lin 2022/12/19 shader 查找器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using UnityEditor;
using UnityEngine;

public class ShaderFinderTools : EditorWindow
{
    enum eConditionType
    {
        Single,
        MultiAnd,
        MultiOr,
    }
    enum eShaderFindType
    {
        ShaderName,
        ShaderAssetName,
        ShaderVariantCount,
    }
    enum eShaderVariantCountCompare
    {
        Equal,
        Less,
        LessEqual,
        Greater,
        GreaterEqual,
        NotEqual,
    }

    [MenuItem("实用工具/Shader/Shader Finder")]
    private static void _Show()
    {
        var win = EditorWindow.GetWindow<ShaderFinderTools>();
        win.titleContent = new GUIContent("Shader Finder");
        win.Init();
        win.Show();
    }
    private void Init()
    {

    }

    private eConditionType conditionType;
    private eShaderFindType findType;
    private string shader_name;
    private string shader_asset_name;
    private UInt64 shader_variant_count;
    private eShaderVariantCountCompare variantCountCompare;
    private bool usedBySceneOnly;
    private string logsPath = "ShaderVariantInfoLogs.csv";
    private Vector2 shaderVariantRectPos;
    private bool showAllRet;
    private int pageSize;
    private int pageIndex;

    private List<Shader> shader_filter_list_helper1 = new List<Shader>();
    private List<Shader> shader_filter_list_helper2 = new List<Shader>();

    private void OnGUI()
    {
        if (shader_filter_list_helper1 == null) shader_filter_list_helper1 = new List<Shader>();
        if (shader_filter_list_helper2 == null) shader_filter_list_helper2 = new List<Shader>();

        conditionType = (eConditionType)EditorGUILayout.EnumPopup("Condition Type", conditionType);

        if (conditionType == eConditionType.Single)
        {
            findType = (eShaderFindType)EditorGUILayout.EnumPopup("Find Type", findType);

            switch (findType)
            {
                case eShaderFindType.ShaderName:
                    shader_name = EditorGUILayout.TextField("Shader Name", shader_name);
                    break;
                case eShaderFindType.ShaderAssetName:
                    shader_asset_name = EditorGUILayout.TextField("Shader Asset Name", shader_asset_name);
                    break;
                case eShaderFindType.ShaderVariantCount:
                    shader_variant_count = (UInt64)EditorGUILayout.IntField("Shader Variant Count", (int)shader_variant_count);
                    variantCountCompare = (eShaderVariantCountCompare)EditorGUILayout.EnumPopup("Variant Count Compare", variantCountCompare);
                    usedBySceneOnly = EditorGUILayout.Toggle("Used By Scene Only", usedBySceneOnly);
                    break;
                default:
                    break;
            }
        }
        else
        {
            shader_name = EditorGUILayout.TextField("Shader Name", shader_name);
            shader_asset_name = EditorGUILayout.TextField("Shader Asset Name", shader_asset_name);
            shader_variant_count = (UInt64)EditorGUILayout.IntField("Shader Variant Count", (int)shader_variant_count);
            variantCountCompare = (eShaderVariantCountCompare)EditorGUILayout.EnumPopup("Variant Count Compare", variantCountCompare);
            usedBySceneOnly = EditorGUILayout.Toggle("Used By Scene Only", usedBySceneOnly);
        }

        if (GUILayout.Button("Find"))
        {
            shader_filter_list_helper1.Clear();
            if (conditionType == eConditionType.Single)
            {
                switch (findType)
                {
                    case eShaderFindType.ShaderName:
                        FilterByShaderName(shader_name, shader_filter_list_helper1);
                        break;
                    case eShaderFindType.ShaderAssetName:
                        FilterByShaderAssetName(shader_asset_name, shader_filter_list_helper1);
                        break;
                    case eShaderFindType.ShaderVariantCount:
                        FilterByShaderVariantCount(shader_variant_count, usedBySceneOnly, variantCountCompare, shader_filter_list_helper1);
                        break;
                    default:
                        break;
                }
            }
            else if (conditionType == eConditionType.MultiOr)
            {
                FilterByShaderName(shader_name, shader_filter_list_helper1);
                FilterByShaderAssetName(shader_asset_name, shader_filter_list_helper1);
                FilterByShaderVariantCount(shader_variant_count, usedBySceneOnly, variantCountCompare, shader_filter_list_helper1);
            }
            else
            {
                FilterByMultiAnd(
                    shader_name,
                    shader_asset_name,
                    shader_variant_count, usedBySceneOnly, variantCountCompare,
                    shader_filter_list_helper1
                    );
            }

            shader_filter_list_helper2.Clear();
            shader_filter_list_helper2.AddRange(shader_filter_list_helper1.Distinct());
        }
        EditorGUILayout.LabelField(new string('-', 200));
        if (GUILayout.Button("Write All Shader Variant Info Logs"))
        {
            WriteAllShaderVariantInfoLogs();
        }
        if (GUILayout.Button("Open Shader Variant Info Logs Path"))
        {
            OpenAllShaderVariantInfoLogsPath();
        }
        EditorGUILayout.LabelField(new string('-', 200));

        {
            var srcEnabled = GUI.enabled;
            GUI.enabled = false;
            EditorGUILayout.LabelField($"Result Count : {shader_filter_list_helper2.Count}");
            GUI.enabled = srcEnabled;

            showAllRet = EditorGUILayout.Toggle("Show All", showAllRet);

            if (!showAllRet)
            {
                pageSize = EditorGUILayout.IntSlider("Page Size", pageSize, 2, 100);

                var pageTotal = (int)Mathf.Ceil((float)shader_filter_list_helper2.Count / pageSize);
                if (pageTotal == 1)
                {
                    GUI.enabled = false;
                }
                EditorGUILayout.BeginHorizontal();
                if (GUILayout.Button("<", GUILayout.Width(30))) pageIndex--;
                var textField_style = EditorStyles.textField;
                var textField_style_srcAlign = textField_style.alignment;
                textField_style.alignment = TextAnchor.MiddleCenter;
                EditorGUILayout.TextField(pageIndex.ToString(), EditorStyles.textField, GUILayout.Width(40));
                textField_style.alignment = textField_style_srcAlign;
                if (GUILayout.Button(">", GUILayout.Width(30))) pageIndex++;
                EditorGUILayout.EndHorizontal();
                pageIndex = (int)Mathf.Clamp(pageIndex, 0, pageTotal);

                pageIndex = EditorGUILayout.IntSlider("Page Index", pageIndex, 0, pageTotal);
                GUI.enabled = srcEnabled;
            }
        }

        {
            EditorGUILayout.LabelField(new string('-', 200));
            shaderVariantRectPos = EditorGUILayout.BeginScrollView(shaderVariantRectPos);

            if (showAllRet)
            {
                for (int i = 0; i < shader_filter_list_helper2.Count; i++)
                {
                    EditorGUILayout.ObjectField("Shader:", shader_filter_list_helper2[i], typeof(Shader), false);
                }
            }
            else
            {
                var start = pageIndex * pageSize;
                var end = (int)(Mathf.Min(start + pageSize, shader_filter_list_helper2.Count));
                for (int i = start; i < end; i++)
                {
                    EditorGUILayout.ObjectField("Shader:", shader_filter_list_helper2[i], typeof(Shader), false);
                }
            }
            EditorGUILayout.EndScrollView();
        }
    }

    private List<string> FilterAllShaderGUIDs()
    {
        var ret = new List<string>();
        var guids = AssetDatabase.FindAssets("t:shader");
        //var guids1 = AssetDatabase.FindAssets("t:shader", new string[] { "Assets" });
         jave.lin : Referring to package paths : "Packages/<package-name>/..."
         jave.lin : ref : https://docs.unity3d.com/Manual/upm-assets.html
        //var guids2 = AssetDatabase.FindAssets("t:shader", new string[] { "Packges/com.unity.postprocessing" });
        //ret.AddRange(guids1);
        //ret.AddRange(guids2);
        ret.AddRange(guids);
        return ret;
    }

    private void FilterByMultiAnd(
        string target_shader_name, 
        string target_shader_asset_name,
        UInt64 count, bool usedBySceneOnly, eShaderVariantCountCompare variantCountCompare,
        List<Shader> shader_filter_list)
    {
        var method = typeof(ShaderUtil).GetMethod("GetVariantCount", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

        target_shader_name = target_shader_name.ToLower();
        target_shader_asset_name = target_shader_asset_name.ToLower();
        var guidlist = FilterAllShaderGUIDs();
        foreach (var guid in guidlist)
        {
            var shaderPath = AssetDatabase.GUIDToAssetPath(guid);
            var shader = AssetDatabase.LoadAssetAtPath<Shader>(shaderPath);
            if (shader.name.ToLower().Contains(target_shader_name) &&
                shaderPath.ToLower().Contains(target_shader_asset_name)
                )
            {
                var variantCount = (UInt64)method.Invoke(null, new System.Object[] { shader, true });

                var add = false;

                switch (variantCountCompare)
                {
                    case eShaderVariantCountCompare.Equal:
                        add = variantCount == count;
                        break;
                    case eShaderVariantCountCompare.Less:
                        add = variantCount < count;
                        break;
                    case eShaderVariantCountCompare.LessEqual:
                        add = variantCount <= count;
                        break;
                    case eShaderVariantCountCompare.Greater:
                        add = variantCount > count;
                        break;
                    case eShaderVariantCountCompare.GreaterEqual:
                        add = variantCount >= count;
                        break;
                    case eShaderVariantCountCompare.NotEqual:
                        add = variantCount != count;
                        break;
                    default:
                        break;
                }
                if (add)
                {
                    shader_filter_list.Add(shader);
                }
            }
        }
    }

    private void FilterByShaderName(string target_shader_name, List<Shader> shader_filter_list)
    {
        target_shader_name = target_shader_name.ToLower();
        var guidlist = FilterAllShaderGUIDs();
        foreach (var guid in guidlist)
        {
            var shaderPath = AssetDatabase.GUIDToAssetPath(guid);
            var shader = AssetDatabase.LoadAssetAtPath<Shader>(shaderPath);
            if (shader.name.ToLower().Contains(target_shader_name))
            {
                shader_filter_list.Add(shader);
            }
        }
    }

    private void FilterByShaderAssetName(string target_shader_asset_name, List<Shader> shader_filter_list)
    {
        target_shader_asset_name = target_shader_asset_name.ToLower();
        var guidlist = FilterAllShaderGUIDs();
        foreach (var guid in guidlist)
        {
            var shaderPath = AssetDatabase.GUIDToAssetPath(guid);
            if (shaderPath.ToLower().Contains(target_shader_asset_name))
            {
                shader_filter_list.Add(AssetDatabase.LoadAssetAtPath<Shader>(shaderPath));
            }
        }
    }

    private void FilterByShaderVariantCount(UInt64 count, bool usedBySceneOnly, eShaderVariantCountCompare variantCountCompare, List<Shader> shader_filter_list)
    {
        var method = typeof(ShaderUtil).GetMethod("GetVariantCount", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

        var guidlist = FilterAllShaderGUIDs();
        foreach (var guid in guidlist)
        {
            var shaderPath = AssetDatabase.GUIDToAssetPath(guid);
            var shader = AssetDatabase.LoadAssetAtPath<Shader>(shaderPath);
            var variantCount = (UInt64)method.Invoke(null, new System.Object[] { shader, true });

            var add = false;

            switch (variantCountCompare)
            {
                case eShaderVariantCountCompare.Equal:
                    add = variantCount == count;
                    break;
                case eShaderVariantCountCompare.Less:
                    add = variantCount < count;
                    break;
                case eShaderVariantCountCompare.LessEqual:
                    add = variantCount <= count;
                    break;
                case eShaderVariantCountCompare.Greater:
                    add = variantCount > count;
                    break;
                case eShaderVariantCountCompare.GreaterEqual:
                    add = variantCount >= count;
                    break;
                case eShaderVariantCountCompare.NotEqual:
                    add = variantCount != count;
                    break;
                default:
                    break;
            }
            if (add)
            {
                shader_filter_list.Add(shader);
            }
        }
    }

    private void WriteAllShaderVariantInfoLogs()
    {
        //logsPath
        var method = typeof(ShaderUtil).GetMethod("GetVariantCount", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

        var sb = new StringBuilder();

        var guidlist = FilterAllShaderGUIDs();
        foreach (var guid in guidlist)
        {
            var shaderPath = AssetDatabase.GUIDToAssetPath(guid);
            var shader = AssetDatabase.LoadAssetAtPath<Shader>(shaderPath);
            var variantCount = (UInt64)method.Invoke(null, new System.Object[] { shader, true });

            sb.AppendLine($"shaderPath:{shaderPath},shaderName:{shader.name},variantCount:{variantCount}");
        }

        System.IO.File.WriteAllText(logsPath, sb.ToString());
    }

    private void OpenAllShaderVariantInfoLogsPath()
    {
		var selectPath = logsPath.Replace("/", "\\");
        System.Diagnostics.Process.Start("explorer.exe", $"/select,{selectPath}");
    }
}

其他优化方式 shader_feature_local 加上 shader + ref material 打包的方式

这种方式不用 shader variant collection 的方式来收集，因为 shader variant collection 不容易维护
然后多增加变体或是漏了变体
所以我在项目中使用的这种方式：

  • 遍历项目中所有使用到对应 shader 的材质
  • 将这些 材质 copy 到 ref_mat 目录
  • 将 shader 和 ref_mat 的 ab 名字设置同一个（即：shader 和 ref_mat 打进同一个AB包，这样变体不多也不少）

具体工具代码如下：

// jave.lni 2022/12/28 T2M shader 变体识别包打包工具

using System.Collections.Generic;
using UnityEditor;
using UnityEngine;

public class T2M_Shader_Variant_PackerTools : EditorWindow
{
    [MenuItem("实用工具/Shader/T2M shader 变体识别包打包工具")]
    private static void _Show()
    {
        var win = EditorWindow.GetWindow<T2M_Shader_Variant_PackerTools>();
        win.titleContent = new GUIContent("T2M shader 变体识别包打包工具");
        win.Init();
        win.Show();
    }

    private void Init()
    {

    }

    private void OnGUI()
    {
        if (GUILayout.Button("打包T2M识别包"))
        {
            Shader_Variant_Analysic_Pack_Handle();
        }
        if (GUILayout.Button("清理Ref_Mats纹理"))
        {
            ClearRefMatsTexs();
        }
    }

    private void TexIfExsitPushToList(Material mat, string tex_name, HashSet<string> ret)
    {
        var tex = mat.HasProperty(tex_name) ? mat.GetTexture(tex_name) : null;
        if (tex != null)
        {
            var tex_asset_path = AssetDatabase.GetAssetPath(tex);
            if (!ret.Contains(tex_asset_path)) ret.Add(tex_asset_path);
        }
    }

    private void TexIfExsitClear(Material mat, string tex_name)
    {
        if (mat.HasProperty(tex_name))
        {
            mat.SetTexture(tex_name, null);
        }
    }

    private void Shader_Variant_Analysic_Pack_Handle()
    {
        var shader_name_hashset = new HashSet<string>();
        var shader_asset_path_list = new List<string>();
        var shader_tex_name_list = new List<string>();

        // 参考生成变体的 material 路径
        const string ref_mat_path = "Assets/Art/Shaders/T2M_Ref_Mats";

        // variant 包名
        const string variant_ab_name = "t2m_variant";

        // shader 名字集合
        shader_name_hashset.Add("Amazing Assets/Terrain To Mesh/Splatmap");

        // shader 文件集合
        shader_asset_path_list.Add("Assets/Amazing Assets/Terrain To Mesh/Shaders/Splatmap/Splatmap.shader");

        // shader texture name 集合
        shader_tex_name_list.Add("_T2M_SplatMap_0");
        shader_tex_name_list.Add("_T2M_Layer_0_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_0_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_0_Mask");
        shader_tex_name_list.Add("_T2M_Layer_1_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_1_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_1_Mask");
        shader_tex_name_list.Add("_T2M_Layer_2_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_2_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_2_Mask");
        shader_tex_name_list.Add("_T2M_Layer_3_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_3_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_3_Mask");
        shader_tex_name_list.Add("_T2M_SplatMap_1");
        shader_tex_name_list.Add("_T2M_Layer_4_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_4_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_4_Mask");
        shader_tex_name_list.Add("_T2M_Layer_5_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_5_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_5_Mask");
        shader_tex_name_list.Add("_T2M_Layer_6_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_6_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_6_Mask");
        shader_tex_name_list.Add("_T2M_Layer_7_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_7_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_7_Mask");
        shader_tex_name_list.Add("_T2M_SplatMap_2");
        shader_tex_name_list.Add("_T2M_Layer_8_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_8_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_8_Mask");
        shader_tex_name_list.Add("_T2M_Layer_9_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_9_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_9_Mask");
        shader_tex_name_list.Add("_T2M_Layer_10_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_10_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_10_Mask");
        shader_tex_name_list.Add("_T2M_Layer_11_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_11_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_11_Mask");
        shader_tex_name_list.Add("_T2M_SplatMap_3");
        shader_tex_name_list.Add("_T2M_Layer_12_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_12_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_12_Mask");
        shader_tex_name_list.Add("_T2M_Layer_13_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_13_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_13_Mask");
        shader_tex_name_list.Add("_T2M_Layer_14_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_14_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_14_Mask");
        shader_tex_name_list.Add("_T2M_Layer_15_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_15_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_15_Mask");
        shader_tex_name_list.Add("_T2M_SplatMaps2DArray");
        shader_tex_name_list.Add("_T2M_DiffuseMaps2DArray");
        shader_tex_name_list.Add("_T2M_NormalMaps2DArray");
        shader_tex_name_list.Add("_T2M_MaskMaps2DArray");
        shader_tex_name_list.Add("_T2M_HolesMap");
        shader_tex_name_list.Add("_MainTex");
        shader_tex_name_list.Add("_BumpMap");

        var tex_asset_path_hashset = new HashSet<string>();

        var mat_counter = 0;
        var all_mat_guids = AssetDatabase.FindAssets("t:material", new string[] { "Assets" });
        var sn = 0;

        if (!System.IO.Directory.Exists(ref_mat_path))
        {
            System.IO.Directory.CreateDirectory(ref_mat_path);
        }

        try
        {
            foreach (var mat_guid in all_mat_guids)
            {
                var mat_asset_path = AssetDatabase.GUIDToAssetPath(mat_guid);
                if (mat_asset_path.Contains("Editor") ||
                    mat_asset_path.StartsWith("Assets/Test/") ||
                    mat_asset_path.Contains("Ref_Mats")
                    )
                {
                    continue;
                }
                var mat = AssetDatabase.LoadAssetAtPath<Material>(mat_asset_path);

                // 过滤 shader
                if (mat != null && shader_name_hashset.Contains(mat.shader.name))
                {
                    var new_mat_asset_path = $"{ref_mat_path}/ref_mat_{sn++}.mat";
                    var new_mat = AssetDatabase.LoadAssetAtPath<Material>(new_mat_asset_path);

                    if (new_mat != null)
                    {
                        System.IO.File.Copy(mat_asset_path, new_mat_asset_path, true);
                    }
                    else
                    {
                        if (!AssetDatabase.CopyAsset(mat_asset_path, new_mat_asset_path))
                        {
                            System.IO.File.Copy(mat_asset_path, new_mat_asset_path, true);
                        }
                        new_mat = AssetDatabase.LoadAssetAtPath<Material>(new_mat_asset_path);
                    }

                    var src_ai = AssetImporter.GetAtPath(mat_asset_path);
                    var new_ai = AssetImporter.GetAtPath(new_mat_asset_path);
                    // 设置 src, new 材质 pbr_variant ab
                    //src_ai.assetBundleName = string.Empty;
                    new_ai.assetBundleName = variant_ab_name;
                    mat_counter++;
                }
            }
        }
        catch
        {

        }
        Debug.Log($"variant sn : {sn}");

        // 清理 材质中的纹理
        all_mat_guids = AssetDatabase.FindAssets("t:material", new string[] { ref_mat_path });
        foreach (var mat_guid in all_mat_guids)
        {
            var mat_asset_path = AssetDatabase.GUIDToAssetPath(mat_guid);
            var mat = AssetDatabase.LoadAssetAtPath<Material>(mat_asset_path);
            foreach (var tex_name in shader_tex_name_list)
            {
                TexIfExsitClear(mat, tex_name);
                //TexIfExsitPushToList(new_mat, tex_name, tex_asset_path_hashset);
            }
        }

        // 设置 shader pbr_variant ab
        {
            foreach (var item in shader_asset_path_list)
            {
                var ai = AssetImporter.GetAtPath(item);
                if (ai != null) ai.assetBundleName = variant_ab_name;
            }
        }

        //ScalableBufferManager
        //QualitySettings.resolutionScalingFixedDPIFactor
        //GraphicsSettings.reso


        // jave.lin : 先取消掉之前的纹理的 ab 信息
         设置 每个 pbr 材质使用到的纹理的 ab
        //foreach (var tex_asset_path in tex_asset_path_hashset)
        //{
        //    var ai = AssetImporter.GetAtPath(tex_asset_path);
        //    if (ai != null)
        //    {
        //        //ai.assetBundleName = tex_asset_path.ToLower().Replace("Assets/", "");
        //        //ai.assetBundleName = tex_asset_path.Substring(tex_asset_path.IndexOf("/") + 1);
        //        ai.assetBundleName = string.Empty;
        //        //ai.assetBundleName = tex_asset_path;
        //    }
        //}

        AssetDatabase.Refresh();
        AssetDatabase.SaveAssets();

        Debug.Log($"Variant AB识别包，已处理， shader : {shader_asset_path_list.Count}个, mat : {mat_counter}个, tex : {tex_asset_path_hashset.Count}个");
    }

    private void ClearRefMatsTexs()
    {

        var shader_asset_path_list = new List<string>();
        var shader_tex_name_list = new List<string>();

        // 参考生成变体的 material 路径
        const string ref_mat_path = "Assets/Art/Shaders/T2M_Ref_Mats";

        // shader texture name 集合
        shader_tex_name_list.Add("_T2M_SplatMap_0");
        shader_tex_name_list.Add("_T2M_Layer_0_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_0_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_0_Mask");
        shader_tex_name_list.Add("_T2M_Layer_1_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_1_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_1_Mask");
        shader_tex_name_list.Add("_T2M_Layer_2_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_2_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_2_Mask");
        shader_tex_name_list.Add("_T2M_Layer_3_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_3_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_3_Mask");
        shader_tex_name_list.Add("_T2M_SplatMap_1");
        shader_tex_name_list.Add("_T2M_Layer_4_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_4_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_4_Mask");
        shader_tex_name_list.Add("_T2M_Layer_5_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_5_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_5_Mask");
        shader_tex_name_list.Add("_T2M_Layer_6_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_6_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_6_Mask");
        shader_tex_name_list.Add("_T2M_Layer_7_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_7_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_7_Mask");
        shader_tex_name_list.Add("_T2M_SplatMap_2");
        shader_tex_name_list.Add("_T2M_Layer_8_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_8_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_8_Mask");
        shader_tex_name_list.Add("_T2M_Layer_9_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_9_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_9_Mask");
        shader_tex_name_list.Add("_T2M_Layer_10_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_10_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_10_Mask");
        shader_tex_name_list.Add("_T2M_Layer_11_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_11_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_11_Mask");
        shader_tex_name_list.Add("_T2M_SplatMap_3");
        shader_tex_name_list.Add("_T2M_Layer_12_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_12_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_12_Mask");
        shader_tex_name_list.Add("_T2M_Layer_13_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_13_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_13_Mask");
        shader_tex_name_list.Add("_T2M_Layer_14_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_14_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_14_Mask");
        shader_tex_name_list.Add("_T2M_Layer_15_Diffuse");
        shader_tex_name_list.Add("_T2M_Layer_15_NormalMap");
        shader_tex_name_list.Add("_T2M_Layer_15_Mask");
        shader_tex_name_list.Add("_T2M_SplatMaps2DArray");
        shader_tex_name_list.Add("_T2M_DiffuseMaps2DArray");
        shader_tex_name_list.Add("_T2M_NormalMaps2DArray");
        shader_tex_name_list.Add("_T2M_MaskMaps2DArray");
        shader_tex_name_list.Add("_T2M_HolesMap");
        shader_tex_name_list.Add("_MainTex");
        shader_tex_name_list.Add("_BumpMap");

        var all_mat_guids = AssetDatabase.FindAssets("t:material", new string[] { ref_mat_path });
        foreach (var mat_guid in all_mat_guids)
        {
            var mat_asset_path = AssetDatabase.GUIDToAssetPath(mat_guid);
            var mat = AssetDatabase.LoadAssetAtPath<Material>(mat_asset_path);
            foreach (var tex_name in shader_tex_name_list)
            {
                TexIfExsitClear(mat, tex_name);
                //TexIfExsitPushToList(new_mat, tex_name, tex_asset_path_hashset);
            }
        }

        AssetDatabase.Refresh();
        AssetDatabase.SaveAssets();
    }
}

IPreprocessShaders - 在shader AB 构建处理时，删除对应的变体

// jave.lin ref : https://blog.unity.com/technology/stripping-scriptable-shader-variants

using System.Collections.Generic;
using UnityEditor.Build;
using UnityEditor.Rendering;
using UnityEditor;
using UnityEngine;
using UnityEngine.Rendering;
using static UnityEditor.Progress;

//public static class TestBuildAB
//{
//    [MenuItem("Assets/BuildABs")]
//    public static void _TestBuild()
//    {
//        var path = "Assets/StreamingAssets/game_assets";
//        if (!System.IO.Directory.Exists(path))
//        {
//            System.IO.Directory.CreateDirectory(path);
//        }
//        BuildPipeline.BuildAssetBundles(path, BuildAssetBundleOptions.ChunkBasedCompression, BuildTarget.Android);
//    }
//}

// Simple example of stripping of a debug build configuration
class ShaderBuildProcessor : IPreprocessShaders
{
    private ShaderKeyword[] skipArr = new ShaderKeyword[]
    {
        new ShaderKeyword("DYNAMICLIGHTMAP_ON"),
        //new ShaderKeyword("DIRLIGHTMAP_COMBINED"), // javelin : indirect.diffuse 有使用到
        //new ShaderKeyword("LIGHTPROBE_SH"), // jave.lin : reflection sh 需要
        //new ShaderKeyword("LIGHTMAP_SHADOW_MIXING"), // jave.lin : distance shadow mask 会使用到

        new ShaderKeyword("FOG_EXP"),
        new ShaderKeyword("FOG_EXP2"), //new ShaderKeyword("SHADOWS_DEPTH"), 
        new ShaderKeyword("DEBUG"),
        //new ShaderKeyword("SHADOWS_DEPTH"), // jave.lin : 主城水体的效果需要
        new ShaderKeyword("SHADOWS_CUBE"),

        new ShaderKeyword("SPOT"),
        //new ShaderKeyword("POINT"), // jave.lin : 角色实时补光需要使用到
        new ShaderKeyword("DIRECTIONAL_COOKIE"),
        new ShaderKeyword("POINT_COOKIE"),
    };

    public ShaderBuildProcessor()
    {
    }

    // Multiple callback may be implemented.
    // The first one executed is the one where callbackOrder is returning the smallest number.
    public int callbackOrder { get { return 0; } }

    private bool ShouldSkipVariant(Shader shader, ShaderCompilerData data)
    {
        foreach (var item in skipArr)
        {
            if (data.shaderKeywordSet.IsEnabled(item))
            {
                //Debug.Log($"shader.name : {shader.name} skip variant:{ShaderKeyword.GetGlobalKeywordName(item)}");
                return true;
            }
        }

        if (data.graphicsTier == GraphicsTier.Tier2)
        {
            //Debug.Log($"shader.name : {shader.name} skip tier 2");
            return true;
        }

        if (data.graphicsTier == GraphicsTier.Tier3)
        {
            //Debug.Log($"shader.name : {shader.name} skip tier 3");
            return true;
        }

        return false;
    }

    public void OnProcessShader(
        Shader shader, ShaderSnippetData snippet, IList<ShaderCompilerData> shaderCompilerData)
    {
         In development, don't strip debug variants
        //if (EditorUserBuildSettings.development)
        //    return;

        for (int i = 0; i < shaderCompilerData.Count; ++i)
        {
            if (ShouldSkipVariant(shader, shaderCompilerData[i]))
            {
                shaderCompilerData.RemoveAt(i);
                --i;
            }
        }
    }
}

UBer Shader 拆分为 #define + 少量 #multi_compile 的多份 shader 优化实践结果

优化前 - Shader - 298.5 MB

角色展示界面内存：1.3GB
其中比较大块的是：

  • Shader - 298.5 MB
  • RenderTexture - 400 MB
  • Texture2D - 339.7 MB
    在这里插入图片描述

优化后 - Shader - 20.2 MB

角色展示界面内存：398.4 MB
其中比较大块的是：

  • Shader - 20.2 MB
  • RenderTexture - 50.7 MB
  • Texture2D - 111.1 MB
    在这里插入图片描述

特别明显的是 PBR Uber Shader 和 T2M shader 的优化前后

优化前
在这里插入图片描述

优化后
在这里插入图片描述
在这里插入图片描述

优化思路

就是之前说的：UBer Shader 拆分为 #define + 少量 #multi_compile 的多份 shader 优化实践结果
比如 Uber Shader 中的某个 Pass

优化前
在这里插入图片描述

优化后
在这里插入图片描述

如果在 unity editor 下让美术直接使用这个优化过的 shader ，那么会导致美术所见即所得很不方便，比如：要烘焙后，才能显示正常

因此我们的解决方法是： 美术在平时开发的时候，仍然是使用 UBer Shader
然后在 游戏发布 AssetBundle （AB资源）前，我们将所有的使用 UBer Shader 的材质，判断变体开关情况、目录情况，替换为对应的 拆分的变体，这样，让 2^N 的变体指数增长的变体复杂度大大减低

比如：

BeforeBuildMatShaderHandleTools.ReplaceAllMatShader(); // jave.lin : build ab 前材质的替换
ClearUpMatPropKWTools.ClearAllMat(); // jave.lin : 强制执行一下所有材质瘦身
BuildPipeline.BuildAssetBundles(xxxxx); // jave.lin : build ab

优点

shader 内存将：基本上原来 190 MB 的 UBer ，直接降到： 2~4 MB

缺点

容易导致 Unity Editor 下 的渲染和发布后的效果不同，比如：真机上可能需要 Shader.globalMaximumLOD 去切换一下值，才能正常显示 （下面有些解决方法，UNITY 的 BUG 吗？他就不会自动 fallback 到可以低级别的 lod shader 吗？），部分计算会多余浪费掉，比如：强制#define FOG_LINEAR 的shader 比如让 场景的 fog 开启线性雾，否则会有雾效显示异常的情况

比如，出现真机上的这些 BUG：

  • GLSL link error: The number of fragment samplers (17) is greater than the maximum number allowed (16).
  • Note: Creation of internal variant of shader 'Amazing Assets/Terrain To Mesh/Splatmap_layertex_5' failed.

在这里插入图片描述

这类问题解决方法也简单，将 sampler （纹理采样单元） 数量降低即可解决 （修改 shader，或是有一些效果，该删的删）

这也是为何之前说的 Shader.globalMaximumLOD 切换一下就好了，因为低级别一些的 LOD，使用的 sampler 是没有超出 16 个的

阴影变体兼容性缺点要慎重处理

后续补充的踩坑敬仰：Unity - 记一次非正规变体优化带来的兼容性导致部分手机卡死的问题

其他优化方案 - 目前最靠谱的方式

shader

注意尾部我们增加了一些 CUSTOM_SKIP_START(xxx) … CUSTOM_SKIP_END 注释来方便剔除的

Shader "xxx"
{
	Properties {}
	XXXPROGRAM
	...
	#pragma multi_compile _ A
	#pragma multi_compile _ B
	#pragma multi_compile _ C
	ENDXXX
}

// jave.lin :
// completely_match_group : 完全吻合的变体，就是不多也不少的匹配规则
// CUSTOM_SKIP_START(completely_match_group)
A C
// CUSTOM_SKIP_END(xxx)

// jave.in :
// any_match_group : 只要变体中 同时存在 A B 的
// CUSTOM_SKIP_START(any_match_group)
A B
// CUSTOM_SKIP_END(xxx)

// jave.lin :
// 其他的规则可以自行添加
// 如果是想要剔除 多个变体，只要包含，就剔除，可以使用unity shaderlab自带的： #pragma skip_variants xxx1 xxx2 xxx3

csharp

在 IPreprocessShaders 接口实现中，我们要对 shader 的 CUSTOM_SKIP_START(xxx) … CUSTOM_SKIP_END 提取
然后这个 shader 变体是否需要剔除

这里的代码我就不写了

References

Unity Shader变体优化与故障排除技巧
unityofficial的博客
08-14 1962
在 Unity 中编写着色器时，我们可以方便地在一个源文件中包含多个特性、通道和分支逻辑。在构建时，着色器源文件会被编译成着色器程序，这些程序包含一个或多个变体。变体是该着色器在满足一组条件后生成的版本，这通常会导致线性执行路径，而没有静态分支条件。我们使用变体而不是将所有分支路径保留在一个着色器中的原因是，GPU 在并行处理可预测的代码时表现出色，且始终遵循相同路径的，从而实现更高的吞吐量。
Unity Shader - sahder变体剔除
Jave.Lin 的学习笔记
02-26 1168
已经能确定的是，这个问题，100% 必现。从上周就出现，到现在，就是比我不再使用 XSDN。打开CSDN首页里面的连接，是秒开的，到底怎么回事，看来准备博客搬家。等了差不多 30S~60S，就出现： 操作超时请重试。接口实现中，我们要对 shader 的。，编辑后，无法保存，一直提示：操作超时。然后这个 shader 变体是否需要剔除。注意尾部我们增加了一些。
Unity3D Built-in Shader详解一
热门推荐
cloud_zero的专栏
12-29 3万+
      Unity3D内置了很多Shader,文档很详细,自己翻一下.便于加深印象.      首先先解释下Unity3D的Shader.Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的.FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader 还是使用标准的Cg/HLSL 编程语言编写的。（因此Unity文档里面的Shader，都是指用ShaderLab编写的代码）      然后我们来看下Unity3D自带的60
Unity渲染管线详解：从Built-in到URP/HDRP的全面解析
最新发布
weixin_42216813的博客
04-21 1359
渲染管线是将3D场景数据转换为2D屏幕图像的一系列处理流程。剔除(Culling)：确定哪些对象在视野内渲染(Rendering)：将几何体绘制到屏幕后处理(Post-processing)：应用屏幕空间效果// 自定义渲染逻辑Unity渲染管线的演进为开发者提供了从移动端到3A大作的完整解决方案。根据目标硬件选择合适的管线优化渲染性能与画面质量的平衡有效规划项目技术路线随着实时渲染技术的快速发展，建议开发者持续关注Unity官方文档和图形技术社区，掌握最新的渲染管线技术与最佳实践。
Unity中Shader变体优化
楠溪泽岸的博客
11-29 3687
在Shader中，一般有两个方面的优化：一方面是内存优化（即变体优化）；一方面是渲染优化（即Shader中计算的优化）。我们这篇文章来了解一下Shader变体的优化。
Unity Shader 变体优化：提升性能的关键技巧
Unity打怪升级
07-28 946
在 Unity 开发中，Shader 变体的管理和优化是提升游戏性能的重要环节。不合理的 Shader 变体可能导致性能下降、内存占用增加以及构建时间延长等问题。本文将深入探讨 Unity Shader 变体优化的方法和技巧。
Unity内置着色器源码 版本：builtin_shaders-4.7.2.zip
10-07
Unity内置着色器源码 版本：builtin_shaders-4.7.2.zip
Unity 重内置 Built-in 到 可编程 URP 函数对应整理.docx
01-05
Unity Built-in 到 URP 函数对应整理 Unity 的可编程渲染管线（Scriptable Render Pipeline）代表了 Unity 处理图形方式的一大进步，为用户提供了更多定制管线的能力。然而， Built-in 到 URP 的示例仍然较少，这...
Unity3d URP 渲染管线和 Built in 渲染管线中 shader 的区别
菰城茧的博客
10-20 4420
URP使用HLSL语言；BIPR使用CG语言 URP 的SubShader的Tags中需要添加"RenderPipeline" = “UniversalPipeline” URP使用单一的forward通道，多个光照通过数组形式传入；BIPR每一个光照跑一个pass 合批流程不同，URP给每个不同的材质球建立持久化数据在gpu中，每一个shader变体一次合批，无论多少材质球；URP每一个材质球一次合批（下图）CBUFFER_START， CBUFFER_END URP需要定义取样器S..
Unity 重内置 Built-in 到 可编程 URP 函数对应整理
02-09
Unity的可编程渲染管线（Scriptable Render Pipeline, 简称SRP）是Unity引擎在图形渲染方面的一个重大改进，它允许开发者自定义渲染流程，从而实现更高效、更优化的画面效果。Universal Render Pipeline（URP）是SRP...
Unity Built-in Shader详解三
cloud_zero的专栏
12-29 9503
<br />      上次讲的是Transparent Shader Family，他们是绘制半透明的对象使用的，但他们并不能满足我们全部的要求。<br />      Transparent Cutout Shader Family是对半透明对象Shader的一类补充，与Transparent Shader Family有所区别的是：Cutout Shader Faimily中的Shaders不允许绘制部分透明的区域。就是说，使用这种Shader绘制出来的对象，要么是全透明，要么是半透明。使用这个家族S
Unity内置着色器源码(builtin_shaders-5.3.7f1)
06-07
Unity5.3.7内置着色器源码
Unity内置着色器源码 builtin_shaders-4.0.1.zip
10-07
Unity内置着色器源码 版本： builtin_shaders-4.0.1.zip
Unity内置着色器源码 builtin_shaders-4.1.5.zip
10-07
Unity内置着色器源码 版本：builtin_shaders-4.1.5.zip
unity builtin_shaders - unity自带shader源码
02-11
unity builtin_shaders - unity自带shader源码 Transparent的是alpha开头的
Unity Built-in Shader详解二
cloud_zero的专栏
12-29 9517
<br />       这次主要讨论Unity自带的Shader中Transparent Shader Family<br />       这个家族的Shader一共7种，原理和类型与Normal中的上差不多，只不过这些Shader是用在半透明或者全透明的物体上面的。他们的主纹理接受RGBA4个通道。如果你的模型一部分是半透明，一部分是不透明的。请分开使用两张材质，半透明的材质这个家族的Shader。这个家族的Shader的内容和Normal中同名的几乎一样，只是添加了半透明效果，因此不再做重复介绍。<
Unity Shader 变体
欢迎来到《技术探索》，这是一个专注于游戏开发技术的博客。在这里，我们将深入探讨游戏引擎、图形渲染、人工智能、物理模拟等领域的最新技术和最佳实践。无论您是初学者还是经验丰富的开发者，我们都希望为您提供有价值的见解和实用的技巧。
10-31 1608
Shader 变体是 Unity 中一个重要的概念，它允许开发者根据不同的条件创建多个 Shader 版本，以实现灵活的视觉效果和性能优化。通过合理使用 Shader 变体，开发者可以在保证视觉质量的同时，提高游戏的性能和用户体验。Shader 变体的生成是 Unity 中一个重要的概念，它允许开发者根据不同的条件创建多个 Shader 版本。通过合理使用和指令，结合 Shader Variant Collection 和优化策略，开发者可以有效管理和优化 Shader 变体，提升游戏性能和用户体验。
unity shader变体优化
啊哈的专栏
02-02 844
shader变体优化
【Unity Shader】Shader变体(#pragma 指令解析)
qq_22849251的博客
05-29 452
shader
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值