├── Editor.meta
├── Editor
    ├── Resources.meta
    ├── Resources
    │   ├── ShaderVariantTool_Main.uxml
    │   ├── ShaderVariantTool_Main.uxml.meta
    │   ├── ShaderVariantTool_ShaderTable.uxml
    │   ├── ShaderVariantTool_ShaderTable.uxml.meta
    │   ├── ShaderVariantTool_Style.uss
    │   ├── ShaderVariantTool_Style.uss.meta
    │   ├── ShaderVariantTool_VariantTable.uxml
    │   └── ShaderVariantTool_VariantTable.uxml.meta
    ├── ShaderVariantTool.cs
    ├── ShaderVariantTool.cs.meta
    ├── ShaderVariantTool_BuildProcess.cs
    ├── ShaderVariantTool_BuildProcess.cs.meta
    ├── ShaderVariantTool_ComputeProcess.cs
    ├── ShaderVariantTool_ComputeProcess.cs.meta
    ├── ShaderVariantTool_Data.cs
    ├── ShaderVariantTool_Data.cs.meta
    ├── ShaderVariantTool_Helper.cs
    ├── ShaderVariantTool_Helper.cs.meta
    ├── ShaderVariantTool_LogReader.cs
    ├── ShaderVariantTool_LogReader.cs.meta
    ├── ShaderVariantTool_ShaderProcess.cs
    └── ShaderVariantTool_ShaderProcess.cs.meta
├── LICENSE
├── LICENSE.meta
├── README.md
├── README.md.meta
├── README01.jpg
├── README01.jpg.meta
├── package.json
└── package.json.meta


/Editor.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: f091c40a6948364489bb93e99eeb18c3
3 | folderAsset: yes
4 | DefaultImporter:
5 |   externalObjects: {}
6 |   userData: 
7 |   assetBundleName: 
8 |   assetBundleVariant: 
9 | 


--------------------------------------------------------------------------------
/Editor/Resources.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 732c98c7d204e894c85b5d8a5fc38d42
3 | folderAsset: yes
4 | DefaultImporter:
5 |   externalObjects: {}
6 |   userData: 
7 |   assetBundleName: 
8 |   assetBundleVariant: 
9 | 


--------------------------------------------------------------------------------
/Editor/Resources/ShaderVariantTool_Main.uxml:
--------------------------------------------------------------------------------
 1 | <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xmlns="UnityEngine.UIElements" editor-extension-mode="False">
 2 |     <Style src="ShaderVariantTool_Style.uss" />
 3 |     <ui:ScrollView name="scrollView">
 4 |         <ui:VisualElement class="master-content-container">
 5 |             
 6 |             <!-- Logging Toggle -->
 7 |             <ui:Toggle name="LogToggle" label="Log next build" index="0" />
 8 |             
 9 |             <!-- Culture setting -->
10 |             <ui:DropdownField name="CultureField" label="culture" index="0" />
11 | 
12 |             <!-- Refresh CSV button -->
13 |             <ui:Button name="RefreshCSVButton" text="Refresh CSV File List" display-tooltip-when-elided="true" class="csv-buttons" />
14 | 
15 |             <ui:VisualElement name="HideIfNoCSV">
16 |                 <!-- CSV buttons -->
17 |                 <ui:DropdownField name="CSVDropDown" label="Select CSV File" index="0" />
18 |                 <ui:Button name="ShowInExplorerButton" text="Show in explorer" display-tooltip-when-elided="true"  class="csv-buttons" />
19 |                 
20 |                 <!-- Build summary numbers -->
21 |                     <ui:Label name="OpenedFile" class="message-label" tabindex="-1" text="Opened CSV file:" display-tooltip-when-elided="true" />
22 |                     <ui:Label tabindex="-1" text="" display-tooltip-when-elided="false" />
23 |                     <ui:VisualElement name="BuildSummary" class="section-spacing">
24 |                         <ui:Label class="summary-label-content" tabindex="-1" text="Label1" display-tooltip-when-elided="true" />
25 |                     </ui:VisualElement>
26 |     
27 |                 <!-- Shader table title -->
28 |                 <ui:Label text="Variant count numbers. Click to see variant keyword table of that shader." class="message-label" />
29 |     
30 |                 <!-- Shader table -->
31 |                 <ui:VisualElement class="multicolumn-container shader-table" />
32 |             </ui:VisualElement>
33 |         
34 |         </ui:VisualElement>
35 |     </ui:ScrollView>
36 | </ui:UXML>


--------------------------------------------------------------------------------
/Editor/Resources/ShaderVariantTool_Main.uxml.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 84788b029710bec4fb1ca418d727b2ba
 3 | ScriptedImporter:
 4 |   internalIDToNameTable: []
 5 |   externalObjects: {}
 6 |   serializedVersion: 2
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 |   script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
11 | 


--------------------------------------------------------------------------------
/Editor/Resources/ShaderVariantTool_ShaderTable.uxml:
--------------------------------------------------------------------------------
 1 | <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xmlns="UnityEngine.UIElements" editor-extension-mode="False">
 2 |     <Style src="ShaderVariantTool_Style.uss" />
 3 |     <ui:VisualElement class="ShaderTableTemplate">
 4 | 
 5 |         <!-- Shader table -->
 6 |         <ui:MultiColumnTreeView name="ShaderTable" virtualization-method="DynamicHeight" show-border="true" sorting-enabled="true" show-alternating-row-backgrounds="ContentOnly"  selection-type="Single">
 7 |             <ui:Columns name="ShaderColumns" reorderable="false">
 8 |                 <ui:Column name="ShaderName" title="Shader Name" width="400" />
 9 |                 <ui:Column name="Original" title="Original" width="200" />
10 |                 <ui:Column name="AfterPrefiltering" title="After Prefiltering" width="200" />
11 |                 <ui:Column name="AfterBuiltinStripping" title="After Builtin-Stripping" width="200" />
12 |                 <ui:Column name="AfterScriptableStripping" title="After Scriptable-Stripping" width="200" />
13 |                 <ui:Column name="DynamicBranch" title="Dynamic Branch" width="200" />
14 |             </ui:Columns>
15 |         </ui:MultiColumnTreeView>
16 | 
17 |     </ui:VisualElement>
18 | </ui:UXML>
19 | 


--------------------------------------------------------------------------------
/Editor/Resources/ShaderVariantTool_ShaderTable.uxml.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 914c95f50a483e9458a967b993e8a185
 3 | ScriptedImporter:
 4 |   internalIDToNameTable: []
 5 |   externalObjects: {}
 6 |   serializedVersion: 2
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 |   script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
11 | 


--------------------------------------------------------------------------------
/Editor/Resources/ShaderVariantTool_Style.uss:
--------------------------------------------------------------------------------
  1 | .section-spacing
  2 | {
  3 |     padding-bottom: 30px;
  4 | }
  5 | 
  6 | .initial-message
  7 | {
  8 |     padding: 10px;
  9 | }
 10 | 
 11 | .message-label, .initial-message
 12 | {
 13 |     padding-left: 10px;
 14 |     -unity-font-style: bold;
 15 |     color: aqua;
 16 | }
 17 | 
 18 | /* Culture setting styles ============================================== */
 19 | 
 20 | #CultureField
 21 | {
 22 |     width: 300px;
 23 |     padding-bottom: 10px;
 24 | }
 25 | 
 26 | /* CSV button styles ============================================== */
 27 | 
 28 | .csv-buttons
 29 | {
 30 |     width: 200px;
 31 | }
 32 | 
 33 | /* summary label styles ============================================== */
 34 | 
 35 | .summary-label-content
 36 | {
 37 |     padding-left: 10px;
 38 |     -unity-font-definition: resource("Fonts/RobotoMono/RobotoMono-Regular.ttf");
 39 |     width: 90%;
 40 | }
 41 | 
 42 | /*
 43 | .summary-label-content:hover 
 44 | {
 45 |     color: aqua;
 46 |     background-color: rgb(40,40,40);
 47 | }
 48 | */
 49 | 
 50 | /* common table styles ============================================== */
 51 | 
 52 | .unity-multi-column-header__column-container
 53 | {
 54 |     -unity-font-style: bold;
 55 |     -unity-text-align: middle-left;
 56 | }
 57 | 
 58 | .unity-multi-column-header__column-container Label
 59 | {
 60 |    white-space: normal;
 61 | }
 62 | 
 63 | 
 64 | .table-label
 65 | {
 66 |     padding: 2px;
 67 |     padding-left: 10px;
 68 | }
 69 | 
 70 | .expanded-row-template
 71 | {
 72 |     width: 100%;
 73 |     min-width: 100%;
 74 |     background-color: rgb(46,46,46);
 75 | 
 76 |     border-width: 2px;
 77 |     border-color: rgb(40,40,40);
 78 | }
 79 | 
 80 | #CollectionSize
 81 | {
 82 |     background-color: rgb(46,46,46);
 83 | }
 84 | 
 85 | .shader-table .shader-table-selected
 86 | {
 87 |     /* background-color: var(--unity-colors-alternated_rows-background); */
 88 |     background-color: rgb(40,60,60);
 89 |     color: aqua;
 90 |     -unity-font-style: bold;
 91 | }
 92 | 
 93 | /* shader table styles ============================================== */
 94 | 
 95 | .shader-table
 96 | {
 97 |     width: 100%;
 98 | }
 99 | 
100 | .shader-table, .variant-table
101 | {
102 |     border-width: 10px;
103 | }
104 | 
105 | .shader-table #unity-checkmark
106 | {
107 |     display: none;
108 | }
109 | 
110 | .shader-table #unity-content-container
111 | {
112 |     align-items: stretch;
113 | }
114 | 
115 | .shader-table #unity-content-viewport
116 | {
117 |     align-self: flex-start;
118 | }
119 | 
120 | MultiColumnTreeView, MultiColumnListView
121 | {
122 |     max-height: none;
123 | }
124 | 
125 | 
126 | /* variant table styles ============================================== */
127 | 
128 | .variant-table
129 | {
130 |     border-color: rgb(46,46,46);
131 |     background-color: rgb(55,55,55);
132 | }
133 | 
134 | 
135 | 


--------------------------------------------------------------------------------
/Editor/Resources/ShaderVariantTool_Style.uss.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 8fed4256d2671f94fab4735c26e66652
 3 | ScriptedImporter:
 4 |   internalIDToNameTable: []
 5 |   externalObjects: {}
 6 |   serializedVersion: 2
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 |   script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
11 |   disableValidation: 0
12 | 


--------------------------------------------------------------------------------
/Editor/Resources/ShaderVariantTool_VariantTable.uxml:
--------------------------------------------------------------------------------
 1 | <ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xmlns="UnityEngine.UIElements" editor-extension-mode="False">
 2 |     <Style src="ShaderVariantTool_Style.uss" />
 3 |     <ui:VisualElement class="VariantTemplate">
 4 | 
 5 |         <!-- Shader summary numbers -->
 6 |         <ui:VisualElement name="ShaderSummary">
 7 |             <ui:Label text="" />
 8 |             <ui:Label class="summary-label-content" tabindex="-1" text="Label1" display-tooltip-when-elided="true" />
 9 |         </ui:VisualElement>
10 | 
11 |         <!-- Variant table -->
12 |         <ui:VisualElement class="multicolumn-container variant-table">
13 |             <ui:Label name="CollectionSize" text="Number of items" />
14 |             <ui:MultiColumnListView name="VariantTable" virtualization-method="DynamicHeight" show-border="true" sorting-enabled="false" show-alternating-row-backgrounds="ContentOnly" selection-type="None">
15 |                 <ui:Columns name="VariantColumns" reorderable="false">
16 |                     <ui:Column name="ShaderName" title="Shader Name" width="130px" />
17 |                     <ui:Column name="CompiledCountBefore" title="Compiled Count Before Scriptable Stripping" width="130px" />
18 |                     <ui:Column name="CompiledCountAfter" title="Compiled Count After Scriptable Stripping" width="130px" />
19 |                     <ui:Column name="KeywordName" title="Keyword Name" width="300px" />
20 |                     <ui:Column name="DeclareType" title="Declare Type" width="200px" />
21 |                     <ui:Column name="PassName" title="Pass Name" width="150px" />
22 |                     <ui:Column name="ShaderType" title="Shader Type" width="100px" />
23 |                     <ui:Column name="PassType" title="Pass Type" width="150px" />
24 |                     <ui:Column name="KernelName" title="Kernel Name" width="150px" />
25 |                     <ui:Column name="GfxTier" title="Gfx Tier" width="50px" />
26 |                     <ui:Column name="BuildTarget" title="Build Target" width="150px" />
27 |                     <ui:Column name="CompilerPlatform" title="Compiler Platform" width="80px" />
28 |                     <ui:Column name="PlatformKeywords" title="Platform Keywords" width="150px" />
29 |                     <ui:Column name="KeywordType" title="Keyword Type" width="120px" />
30 |                 </ui:Columns>
31 |             </ui:MultiColumnListView>
32 |         </ui:VisualElement>
33 | 
34 |     </ui:VisualElement>
35 | </ui:UXML>
36 | 


--------------------------------------------------------------------------------
/Editor/Resources/ShaderVariantTool_VariantTable.uxml.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 56949825b95d81046a7503a15fc9cd29
 3 | ScriptedImporter:
 4 |   internalIDToNameTable: []
 5 |   externalObjects: {}
 6 |   serializedVersion: 2
 7 |   userData: 
 8 |   assetBundleName: 
 9 |   assetBundleVariant: 
10 |   script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
11 | 


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections.Generic;
  2 | using System.Linq;
  3 | using UnityEditor;
  4 | using UnityEngine;
  5 | using UnityEngine.UIElements;
  6 | using System;
  7 | using System.IO;
  8 | using System.Text;
  9 | 
 10 | namespace GfxQA.ShaderVariantTool
 11 | {
 12 |     public class ShaderVariantTool : EditorWindow
 13 |     {
 14 |         private VisualElement root;
 15 |         private ScrollView mainScrollView;
 16 |         private Toggle logToggle;
 17 | 
 18 |         [MenuItem("Window/ShaderVariantTool")]
 19 |         public static void ShowWindow()
 20 |         {
 21 |             //ShaderVariantTool wnd = GetWindow<ShaderVariantTool>();
 22 |             ShaderVariantTool wnd = CreateWindow<ShaderVariantTool>(); //Allow to create more instances
 23 |             wnd.titleContent = new GUIContent("ShaderVariantTool");
 24 |             wnd.minSize = new Vector2(800, 700);
 25 |             
 26 |             //initiate log toggle value
 27 |             Helper.shouldUpdateLogNextBuildGUI = true;
 28 |         }
 29 | 
 30 |         public void OnGUI()
 31 |         {
 32 |             //Update log toggle
 33 |             Helper.InitiateLogNextBuild();
 34 |             logToggle.value = SVL.logNextBuild;
 35 |         }
 36 | 
 37 |         public void CreateGUI()
 38 |         {
 39 |             root = rootVisualElement;
 40 |             
 41 |             //Getting main layout
 42 |             VisualTreeAsset rootVisualTree = Resources.Load<VisualTreeAsset>("ShaderVariantTool_Main");
 43 |             rootVisualTree.CloneTree(root);
 44 |             mainScrollView = root.Q<ScrollView>();
 45 |             
 46 |             //Log toggle ==================================================================
 47 |             logToggle = root.Q<Toggle>(name:"LogToggle");
 48 |             logToggle.RegisterValueChangedCallback(v =>
 49 |             {
 50 |                 Helper.SetLogNextBuild(v.newValue);
 51 |             });
 52 |             
 53 |             //Culture Setting ==================================================================
 54 | 
 55 |             //Read culture pref
 56 |             Helper.SetupCultureInfo();
 57 | 
 58 |             //DropdownList
 59 |             DropdownField cultureDropdown = root.Q<DropdownField>(name:"CultureField");
 60 |             cultureDropdown.choices.Clear();
 61 |             foreach(var cinfo in Helper.cinfo)
 62 |             {
 63 |                 cultureDropdown.choices.Add(cinfo.DisplayName);
 64 |             }
 65 |             cultureDropdown.index = Array.IndexOf(Helper.cinfo,Helper.culture);
 66 |             cultureDropdown.RegisterValueChangedCallback(v =>
 67 |             {
 68 |                 Helper.UpdateCultureInfo(v.newValue);
 69 |             });
 70 |             
 71 |             //Message when no CSV found ==================================================================
 72 | 
 73 |             //If there is no CSV file available, show an message to hint people to make a build first
 74 |             if(CSVFileNames == null) GetCSVFileNames();
 75 |             if(CSVFileNames.Count == 0)
 76 |             {
 77 |                 //Hide CSV UI
 78 |                 root.Q("HideIfNoCSV").style.display = DisplayStyle.None;
 79 |                 
 80 |                 //Show the message only
 81 |                 root.styleSheets.Add(Resources.Load<StyleSheet>("ShaderVariantTool_Style"));
 82 |                 Label initialMessage = new Label("No ShaderVariantTool CSV found. Build the player and reopen this tool or click refresh CSV list above.");
 83 |                 initialMessage.AddToClassList("initial-message");
 84 |                 root.Add(initialMessage);
 85 |                 
 86 |                 return;
 87 |             }
 88 | 
 89 |             //CSV buttons ==================================================================
 90 | 
 91 |             //Refresh CSV button
 92 |             Button refreshCSVButton = root.Q<Button>(name:"RefreshCSVButton");
 93 |             refreshCSVButton.RegisterCallback<PointerUpEvent>(e =>
 94 |             {
 95 |                 GetCSVFileNames();
 96 |                 csvDropDown.choices = CSVFileNames;
 97 |             });
 98 | 
 99 |             //CSV drop down list
100 |             csvDropDown = root.Q<DropdownField>(name:"CSVDropDown");
101 |             csvDropDown.choices = CSVFileNames;
102 |             if(csvDropDown.index < 0)
103 |             {
104 |                 csvDropDown.index = 0;
105 |                 selectedCSVFile = csvDropDown.value;
106 |                 UpdateCSVDataForGUI();
107 |                 prevSelectedCSVFile = selectedCSVFile;
108 |             }
109 |             csvDropDown.RegisterValueChangedCallback(v =>
110 |             {
111 |                 selectedCSVFile = v.newValue;
112 |                 if(prevSelectedCSVFile != selectedCSVFile)
113 |                 {
114 |                     UpdateCSVDataForGUI();
115 |                     RefreshUI();
116 |                     prevSelectedCSVFile = selectedCSVFile;
117 |                 }
118 |             });
119 | 
120 |             //Show in explorer button
121 |             Button showInExplorerButton = root.Q<Button>(name:"ShowInExplorerButton");
122 |             showInExplorerButton.RegisterCallback<PointerUpEvent>(e =>
123 |             {
124 |                 string path = selectedCSVFile;
125 |                 path = path.Replace(@"\", @"/");
126 |                 EditorUtility.RevealInFinder(path);
127 |             });
128 | 
129 |             //Build summary ================================================================
130 | 
131 |             openedFileLabel = root.Q<Label>(name:"OpenedFile");
132 |             build_label_summary = root.Q<Label>(className:"summary-label-content");
133 |             MakeLabelCopyable(build_label_summary);
134 | 
135 |             //Shader table ===================================================================
136 | 
137 |             shaderTableAsset = Resources.Load<VisualTreeAsset>("ShaderVariantTool_ShaderTable");
138 |             shaderTableParent = root.Q<VisualElement>(className:"shader-table");
139 | 
140 |             //Fill the UI data ================================================================
141 |             RefreshUI();
142 |         }
143 | 
144 |         private void RefreshUI()
145 |         {
146 |             //Print the opened file name
147 |             openedFileLabel.text = String.Concat("Opened CSV file:" , selectedCSVFile);
148 | 
149 |             //Fill the build summary rows
150 |             StringBuilder combinedBuildRowsText = new StringBuilder();
151 |             for(int i=0; i<buildRows.Count; i++)
152 |             {
153 |                 //Add some spaces
154 |                 if( buildRows[i][0] =="Shader Count" || buildRows[i][0] =="ComputeShader Count" || buildRows[i][0].Contains("Shader Program Count") )
155 |                 {
156 |                     combinedBuildRowsText.Append("\n");
157 |                 }
158 | 
159 |                 //Fill the table
160 |                 if( buildRows[i][0] !="Build Path" )//Do not show build path
161 |                 {
162 |                     combinedBuildRowsText.Append(String.Format( format, buildRows[i][0], Helper.NumberSeperator(buildRows[i][1]) ));
163 |                     combinedBuildRowsText.Append("\n");
164 |                 }
165 |             }
166 |             build_label_summary.text = combinedBuildRowsText.ToString();
167 | 
168 |             //Collapse shader table
169 |             //shaderTable.CollapseAll();
170 | 
171 |             //Recreate ShaderTable ==========================================================
172 |             if(shaderTable != null) shaderTableParent.Remove(shaderTable);
173 |             shaderTableTemplate = shaderTableAsset.Instantiate();
174 |             shaderTable = shaderTableTemplate.Q<MultiColumnTreeView>(name:"ShaderTable");
175 |             shaderTableParent.Add(shaderTable);
176 | 
177 |             foreach(string col in shaderRowsHeaderFromCSV)
178 |             {
179 |                 if(col.Contains("Program Count "))
180 |                 {
181 |                     //Add more columns
182 |                     Column newColumn = new Column();
183 |                     newColumn.name = col;
184 |                     newColumn.title = col;
185 |                     newColumn.width = 200;
186 |                     shaderTable.columns.Add(newColumn);
187 |                 }
188 |             }
189 | 
190 |             /* To avoid mouse wheel conflict
191 |             */
192 |             ScrollView shaderTableScrollView = shaderTable.Q<ScrollView>();
193 |             shaderTableScrollView.mode = ScrollViewMode.Vertical;
194 |             shaderTableScrollView.verticalScrollerVisibility = ScrollerVisibility.Hidden;
195 |             
196 |             //Register sorting event
197 |             shaderTable.columnSortingChanged += OnShaderSortingChanged;
198 |             
199 |             //For show/hide variant table
200 |             shaderTable.RegisterCallback<PointerUpEvent>(ShowHideVariantTable);
201 | 
202 |             //Refresh shader table
203 |             SetDefaultSortingState(); //Set default sorting state
204 |             OnShaderSortingChanged();
205 |             shaderTable.Rebuild();
206 | 
207 |             //Refresh variant tables
208 |             ResetExpandedVariantElementsList();
209 | 
210 |             SetShaderTableSelection();
211 |         }
212 | 
213 |         private void MakeLabelCopyable(Label label)
214 |         {
215 |             ContextualMenuManipulator m = new ContextualMenuManipulator((ContextualMenuPopulateEvent evt) =>
216 |             {
217 |                 //Make sure it's right click
218 |                 #if UNITY_2023_1_OR_NEWER
219 |                     if(evt.triggerEvent.imguiEvent.keyCode == KeyCode.Mouse1)
220 |                     {
221 |                         evt.menu.AppendAction("Copy", (x) => EditorGUIUtility.systemCopyBuffer = label.text, DropdownMenuAction.AlwaysEnabled);
222 |                     }
223 |                 #else
224 |                     if(evt.triggerEvent.imguiEvent.isMouse && evt.triggerEvent.imguiEvent.button == 1)
225 |                     {
226 |                         evt.menu.AppendAction("Copy", (x) => EditorGUIUtility.systemCopyBuffer = label.text, DropdownMenuAction.AlwaysEnabled);
227 |                     }
228 |                 #endif
229 |             });
230 |             m.target = label;
231 |         }
232 |     
233 | #region CSV file reading functions
234 |     
235 |         private List<string> CSVFileNames;
236 |         private string selectedCSVFile = "";
237 |         private string prevSelectedCSVFile = "";
238 |         private DropdownField csvDropDown;
239 | 
240 |         private Label openedFileLabel;
241 | 
242 |         private void GetCSVFileNames()
243 |         {
244 |             if(CSVFileNames == null)
245 |             {
246 |                 CSVFileNames = new List<string>();
247 |             }
248 |             else
249 |             {
250 |                 CSVFileNames.Clear();
251 |             }
252 | 
253 |             var info = new DirectoryInfo(Helper.GetCSVFolderPath());
254 |             var fileInfo = info.GetFiles();
255 |             foreach(FileInfo file in fileInfo)
256 |             {
257 |                 if(file.Name.Contains("ShaderVariants_") && file.FullName.Contains(".csv"))
258 |                 {
259 |                     string path = file.FullName;
260 |                     path = path.Replace(@"/", @"\");
261 |                     CSVFileNames.Add(path);
262 |                 }
263 |             }
264 | 
265 |             //sort file names, top is newest
266 |             CSVFileNames.Sort((x, y) => y.CompareTo(x)); //Decending order
267 |         }
268 | 
269 |         private string[] ReadCSVFile()
270 |         {
271 |             string path = selectedCSVFile;
272 |             path = path.Replace(@"\", @"/");
273 |             string fileData  = System.IO.File.ReadAllText(path);
274 |             string[] lines = fileData.Split("\n"[0]);
275 |             return lines;
276 |         }
277 | 
278 |         private string[] GetLineCells(string[] lines, int lineID)
279 |         {
280 |             return lines[lineID].Trim().Split(","[0]);
281 |         }
282 | 
283 |         void UpdateCSVDataForGUI()
284 |         {
285 |             //Read the CSV file lines
286 |             string[] lines = ReadCSVFile();
287 |             if(lines.Length <= 0)
288 |             {
289 |                 //TODO some error messages when there is no line to read
290 |             }
291 |             else
292 |             {
293 |                 int lineID = 0;
294 |                 string[] lineData = GetLineCells(lines,lineID);
295 | 
296 |                 //Load build summary data
297 |                 if(buildRows == null) buildRows = new List<string[]>();
298 |                 buildRows.Clear();
299 |                 while(lineData[0]!="")
300 |                 {
301 |                     buildRows.Add(lineData);
302 | 
303 |                     //Next line
304 |                     lineID++;
305 |                     lineData = GetLineCells(lines,lineID);
306 |                 }
307 | 
308 |                 //Next line
309 |                 lineID++;
310 |                 lineData = GetLineCells(lines,lineID);
311 | 
312 |                 //Shader list header
313 |                 shaderRowsHeaderFromCSV = lineData;
314 |                 
315 |                 //Next line
316 |                 lineID++;
317 |                 lineData = GetLineCells(lines,lineID);
318 | 
319 |                 //Collect shader summary rows
320 |                 if(shaderRows == null) shaderRows = new List<string[]>();
321 |                 shaderRows.Clear();
322 |                 while(lineData[0]!="")
323 |                 {
324 |                     shaderRows.Add(lineData);
325 | 
326 |                     //Next line
327 |                     lineID++;
328 |                     lineData = GetLineCells(lines,lineID);
329 |                 }
330 | 
331 |                 //Sort shader rows for initial state
332 |                 if(shaderTable != null)
333 |                 {
334 |                     SetDefaultSortingState();
335 |                 }
336 | 
337 |                 //Next line
338 |                 lineID++;
339 |                 lineData = GetLineCells(lines,lineID);
340 | 
341 |                 //Variant list header
342 |                 //TODO: error check to see if uxml column matches CSV
343 | 
344 |                 //Next line
345 |                 lineID++;
346 |                 lineData = GetLineCells(lines,lineID);
347 | 
348 |                 //Collect variant rows
349 |                 if(variantRows == null) variantRows = new List<string[]>();
350 |                 variantRows.Clear();
351 |                 while(lineData[0]!="")
352 |                 {
353 |                     variantRows.Add(lineData);
354 | 
355 |                     //Next line
356 |                     lineID++;
357 |                     lineData = GetLineCells(lines,lineID);
358 |                 }
359 | 
360 |                 //Sort variant list by compile count
361 |                 //variantRows = variantRows.OrderByDescending(o=>int.Parse(o[defaultVariantSortColumn])).ToList();
362 |                 variantRows = variantRows.OrderByDescending(o=>int.Parse(o[defaultVariantSortColumn])).ThenBy(o=>o[3]).ToList();
363 | 
364 |                 Debug.Log(String.Concat("ShaderVariantTool - successfully loaded ",selectedCSVFile));
365 |             }
366 |         }
367 | 
368 | #endregion
369 | #region Build summary variables
370 | 
371 |         private List<string[]> buildRows;
372 |         //private string combinedBuildRowsText = "";
373 |         private string format = "{0, -50}{1, 35}";
374 |         private Label build_label_summary;
375 | 
376 | #endregion
377 | #region Shader table functions
378 | 
379 |         private MultiColumnTreeView shaderTable;
380 |         private List<TreeViewItemData<string[]>> shaderRoots;
381 |         private List<string[]> shaderRows;
382 |         private string[] shaderRowsHeaderFromCSV;
383 |         private int defaultSortColumn = 4; //Sorting default is no. variant after stripping (i.e. variant in build)
384 |         private VisualTreeAsset shaderTableAsset;
385 |         private VisualElement shaderTableParent;
386 |         private TemplateContainer shaderTableTemplate;
387 | 
388 |         private VisualElement CreateShaderTableCellLabel()
389 |         {
390 |             VisualElement el = new VisualElement();
391 | 
392 |             Label l = new Label();
393 |             l.AddToClassList("table-label");
394 |             MakeLabelCopyable(l);
395 | 
396 |             el.Add(l);
397 | 
398 |             return el;
399 |         }
400 | 
401 |         //Add to list for setting selection state, so that it clears selection for collapsed items, otherwise table color is quite messy
402 |         private void SetShaderTableSelection()
403 |         {   
404 |             var rootIds = shaderTable.GetRootIds();
405 |             VisualElement shaderRowElement = shaderTable.GetRootElementForId(rootIds.ElementAt(0));
406 |             if(shaderRowElement == null) return;
407 |             var rows = shaderRowElement.parent.Children();
408 |             var listOfExpandedItems = new List<int>();
409 |             for(int i=0; i<rows.Count(); i++)
410 |             {
411 |                 int rowId = shaderTable.GetIdForIndex(i);
412 | 
413 |                 bool rowIsRoot = rootIds.Contains(rowId);
414 |                 if(rowIsRoot && shaderTable.IsExpanded(rowId))
415 |                 {
416 |                     rows.ElementAt(i).AddToClassList("shader-table-selected");
417 |                     listOfExpandedItems.Add(i);
418 |                 }
419 |                 else
420 |                 {
421 |                     rows.ElementAt(i).RemoveFromClassList("shader-table-selected");
422 |                 }
423 |             }
424 |             shaderTable.SetSelectionWithoutNotify(listOfExpandedItems);
425 |         }
426 | 
427 |         private void SetShaderRootItems()
428 |         {
429 |             if(shaderRoots == null) shaderRoots = new List<TreeViewItemData<string[]>>(shaderRows.Count);
430 |             shaderRoots.Clear();          
431 | 
432 |             int id = 0;
433 |             for(int i=0; i<shaderRows.Count; i++)
434 |             {
435 |                 //Add a dummy child to the shader, serve as a space for the variant table
436 |                 var dummyListTree = new List<TreeViewItemData<string[]>>(1);
437 |                 string[] dum = new string[shaderTable.columns.Count];
438 |                 for(int j = 0; j< shaderTable.columns.Count; j++)
439 |                 {
440 |                     //using shaderName+dummy as identifer to recognise if the cell is variant table
441 |                     string shaderName = "";
442 |                     if(j==0)
443 |                     {
444 |                         shaderName = shaderRows[i][j];
445 |                     }
446 |                     dum[j] = String.Concat(shaderName," dummy",j);
447 |                 }
448 |                 dummyListTree.Add(new TreeViewItemData<string[]>(id++,dum));
449 |                 
450 |                 //Add shader cell contents
451 |                 string[] shaderRowCells = new string[shaderTable.columns.Count];
452 |                 for(int k=0; k<shaderRowCells.Length; k++)
453 |                 {
454 |                     Column col = shaderTable.columns[k];
455 |                     int CSVColumnId = Array.FindIndex(shaderRowsHeaderFromCSV, e => e == col.title);
456 |                     
457 |                     shaderRowCells[k] = shaderRows[i][CSVColumnId];
458 |                 }
459 |                 shaderRoots.Add(new TreeViewItemData<string[]>(id++, shaderRowCells, dummyListTree));
460 |             }
461 |             shaderTable.SetRootItems(shaderRoots);
462 | 
463 |             //Bind cell data to column
464 |             Columns shaderTableColumns = shaderTable.columns;
465 |             int colid = 0; //cannot use i inside bindCell as it is always = column count. colid will be increment to columnCount * shaderRowsCount
466 |             for(int i=0; i<shaderTableColumns.Count; i++)
467 |             {
468 |                 shaderTable.columns[i].makeCell = () => CreateShaderTableCellLabel();
469 |                 shaderTable.columns[i].bindCell = (VisualElement element, int index) =>
470 |                 {
471 |                     int actualcolumn = colid % shaderTableColumns.Count;
472 |                     string content = shaderTable.GetItemDataForIndex<string[]>(index)[actualcolumn];
473 |                     Label titleLable = element.Q<Label>(className:"table-label");
474 |                     titleLable.text = Helper.NumberSeperator(content);
475 |                     colid++;
476 | 
477 |                     //Remove the variant tables as they need to get refreshed
478 |                     VisualElement variantTemplateEL = element.Q(className:"VariantTemplate");
479 |                     if(variantTemplateEL != null)
480 |                     {
481 |                         VisualElement templateContainer = variantTemplateEL.parent;
482 |                         templateContainer.style.display = DisplayStyle.None;
483 |                         templateContainer.RemoveFromHierarchy();
484 |                     }
485 | 
486 |                     //Show the variant table
487 |                     if(content.Contains("dummy0"))
488 |                     {
489 |                         //Get and show the variant table
490 |                         string shaderName = content.Replace(String.Concat(" dummy",actualcolumn),"");
491 |                         VisualElement variantTable = GetVariantTable(shaderName);
492 |                         variantTable.style.display = DisplayStyle.Flex;
493 |                         element.Add(variantTable);
494 | 
495 |                         element.style.display = DisplayStyle.Flex;
496 |                         titleLable.style.display = DisplayStyle.None; //dummy label
497 | 
498 |                         element.parent.parent.style.display = DisplayStyle.Flex;
499 |                         element.parent.parent.AddToClassList("expanded-row-template");
500 |                     }
501 |                     //Hide the variant table and the dummy cells
502 |                     else if(content.Contains("dummy"))
503 |                     {
504 |                         element.style.display = DisplayStyle.None;
505 |                         titleLable.style.display = DisplayStyle.None; //dummy label
506 | 
507 |                         element.parent.parent.style.display = DisplayStyle.None;
508 |                         element.parent.parent.RemoveFromClassList("expanded-row-template");
509 |                     }
510 |                     //Show the shader root row
511 |                     else
512 |                     {
513 |                         element.style.display = DisplayStyle.Flex;
514 |                         titleLable.style.display = DisplayStyle.Flex;
515 | 
516 |                         element.parent.parent.style.display = DisplayStyle.Flex;
517 |                         element.parent.parent.RemoveFromClassList("expanded-row-template");
518 |                     }
519 |                 };
520 |             }
521 |         }
522 | 
523 |         private void SetDefaultSortingState()
524 |         {
525 |             var sort = shaderTable.sortColumnDescriptions;
526 | 
527 |             if(sort.Count == 0)
528 |             {
529 |                 SortColumnDescription defaultDesc = new SortColumnDescription(defaultSortColumn,SortDirection.Descending);
530 |                 sort.Add(defaultDesc);
531 | 
532 |                 OnShaderSortingChanged();
533 |             }
534 |         }
535 | 
536 |         private void OnShaderSortingChanged()
537 |         {
538 |             shaderTable.CollapseAll();
539 | 
540 |             var sort = shaderTable.sortColumnDescriptions;
541 | 
542 |             //Sort based on sorting state
543 |             for(int i=0; i<sort.Count; i++)
544 |             {
545 |                 int columnId = shaderTable.columns.IndexOf(sort[i].column);
546 | 
547 |                 if(columnId > 0) //First column is shader name, so sort by Alphabetical
548 |                 {
549 |                     //sort numbers
550 |                     if(sort[i].direction == SortDirection.Ascending)
551 |                     {
552 |                         shaderRows.Sort((x, y) => float.Parse(x[columnId]).CompareTo( float.Parse(y[columnId]))); //Ascending order
553 |                     }
554 |                     else
555 |                     {
556 |                         shaderRows.Sort((x, y) => float.Parse(y[columnId]).CompareTo(float.Parse(x[columnId]))); //Descending order
557 |                     }
558 |                 }
559 |                 else if(columnId >= 0) //avoid columnId = -1
560 |                 {
561 |                     //sort string Alphabetical Order
562 |                     if(sort[i].direction == SortDirection.Ascending)
563 |                     {
564 |                         shaderRows.Sort((x, y) => x[columnId].CompareTo( y[columnId])); //Ascending order
565 |                     }
566 |                     else
567 |                     {
568 |                         shaderRows.Sort((x, y) => y[columnId].CompareTo( x[columnId])); //Descending order
569 |                     }
570 |                 }
571 |             }
572 | 
573 |             SetShaderRootItems();
574 |             shaderTable.Rebuild();
575 |             SetShaderTableSelection();
576 |         }
577 | 
578 | #endregion
579 | #region Variant table variables
580 | 
581 |         private List<string[]> variantRows;
582 |         private int defaultVariantSortColumn = 2; //Sorting default is no. variant after stripping (i.e. variant in build)
583 |         private List<VisualElement> expandedVariantElements;
584 |         private VisualTreeAsset variantTableAsset;
585 | 
586 |         private Label CreateVariantTableCellLabel()
587 |         {
588 |             Label l = new Label();
589 |             l.AddToClassList("table-label");
590 |             MakeLabelCopyable(l);
591 |             return l;
592 |         }
593 | 
594 |         private void ResetExpandedVariantElementsList()
595 |         {
596 |             if(expandedVariantElements != null) expandedVariantElements.Clear();
597 |             expandedVariantElements = new List<VisualElement>(shaderRows.Count);
598 |             for(int i=0; i<shaderRows.Count; i++)
599 |             {
600 |                 expandedVariantElements.Add(null);
601 |             }
602 |         }
603 | 
604 |         private void ShowHideVariantTable(PointerUpEvent e)
605 |         {
606 |             //Check if it is left click
607 |             #if UNITY_2023_1_OR_NEWER
608 |                 if(e.imguiEvent.keyCode != KeyCode.Mouse0)
609 |                 {
610 |                     return;
611 |                 }
612 |             #else
613 |                 if(e.imguiEvent.isMouse && e.imguiEvent.button != 0)
614 |                 {
615 |                     return;
616 |                 }
617 |             #endif
618 | 
619 |             //Check if it's shader row
620 |             int selectedIndex = shaderTable.selectedIndex;
621 |             int selectedId = shaderTable.GetIdForIndex(selectedIndex);
622 |             var rootIds = shaderTable.GetRootIds();
623 |             bool isRootRow = rootIds.Contains(selectedId);
624 |             if(isRootRow)
625 |             {
626 |                 //toggle expand or collapse
627 |                 bool expanded = shaderTable.IsExpanded(selectedId);
628 |                 if(!expanded)
629 |                 {
630 |                     //Expand
631 |                     shaderTable.ExpandItem(selectedId);
632 |                 }
633 |                 else
634 |                 {
635 |                     //Collapse
636 |                     shaderTable.CollapseItem(selectedId);
637 |                 }
638 |             }
639 | 
640 |             SetShaderTableSelection();
641 |         }
642 | 
643 |         private VisualElement GetVariantTable(string shaderName)//int shaderId)
644 |         {
645 |             //string shaderName = shaderTable.GetItemDataForId<string[]>(shaderId)[0];
646 |             int shaderRowsId = shaderRows.FindIndex(x => x[0] == shaderName);
647 | 
648 |             //Try to find the existing expanded Variant of that shader
649 |             int matchingExpandedIndex = expandedVariantElements.FindIndex(x => x != null && x.name == shaderName);
650 | 
651 |             //There is no existing expanded Variant of that shader, so create a new one
652 |             if(matchingExpandedIndex < 0 || expandedVariantElements[matchingExpandedIndex] == null)
653 |             {
654 |                 //Create variant table for that shader
655 |                 if(variantTableAsset==null) variantTableAsset = Resources.Load<VisualTreeAsset>("ShaderVariantTool_VariantTable");
656 |                 TemplateContainer variantTableTemplate = variantTableAsset.Instantiate();
657 | 
658 |                 //Show the shader summary numbers
659 |                 VisualElement shaderSummaryElement = variantTableTemplate.Q<VisualElement>(name:"ShaderSummary");
660 |                 Columns shaderTableColumns = shaderTable.columns;
661 |                 StringBuilder combinedShaderSummaryText = new StringBuilder();
662 |                 combinedShaderSummaryText.Append(String.Concat(shaderName , "\n"));
663 |                 for(int j=1;j<shaderTableColumns.Count;j++)
664 |                 {
665 |                     int CSVColumnId = Array.FindIndex(shaderRowsHeaderFromCSV, e => e == shaderTableColumns[j].title);
666 |                     bool addPrefix = !shaderTableColumns[j].title.Contains("Program Count");
667 |                     combinedShaderSummaryText.Append(String.Concat(String.Format( format, (addPrefix? "Variant Count " : "" ) , shaderTableColumns[j].title, Helper.NumberSeperator(shaderRows[shaderRowsId][CSVColumnId]) )));
668 |                     combinedShaderSummaryText.Append("\n");
669 |                 }
670 |                 Label label_summary = shaderSummaryElement.Q<Label>(className:"summary-label-content");
671 |                 label_summary.text = combinedShaderSummaryText.ToString();
672 |                 MakeLabelCopyable(label_summary);
673 | 
674 |                 //Fill variant table
675 |                 {
676 |                     MultiColumnListView variantTable = variantTableTemplate.Q<MultiColumnListView>(name: "VariantTable");
677 | 
678 |                     //Hide some columns based on shader type
679 |                     string isComputeShader = shaderRows[shaderRowsId][10]; //get num from BuildProcess
680 |                     List<string> columnsToHide = new List<string>();
681 |                     if(isComputeShader == "True")
682 |                     {
683 |                         columnsToHide.Add("ShaderName");
684 |                         columnsToHide.Add("PassName");
685 |                         columnsToHide.Add("PassType");
686 |                         columnsToHide.Add("ShaderType");
687 |                     }
688 |                     else
689 |                     {
690 |                         columnsToHide.Add("ShaderName");
691 |                         columnsToHide.Add("KernelName");
692 |                     }
693 | 
694 |                     //Find all the variants belongs to this shader
695 |                     var variantRoots = new List<string[]>();
696 |                     for(int k=0; k<variantRows.Count; k++)
697 |                     {
698 |                         if(variantRows[k][0] == shaderName)
699 |                         {
700 |                             //Skip the column data we want to hide
701 |                             List<string> data = new List<string>();
702 |                             for (int j=0; j<variantRows[k].Length; j++)
703 |                             {
704 |                                 string colName = variantTable.columns[j].name;
705 |                                 if( !columnsToHide.Contains(colName) )
706 |                                 {
707 |                                     data.Add(variantRows[k][j]);
708 |                                 }
709 |                             }
710 |                             variantRoots.Add(data.ToArray());
711 |                         }
712 |                     }
713 |                     variantTable.itemsSource = variantRoots;
714 | 
715 |                     //Hide some columns based on shader type
716 |                     foreach(string col in columnsToHide)
717 |                     {
718 |                         variantTable.columns.Remove(variantTable.columns.First(o => o.name == col));
719 |                     }
720 | 
721 |                     //Collection size of variant table
722 |                     Label numOfItems = variantTableTemplate.Q<Label>(name: "CollectionSize");
723 |                     numOfItems.text = String.Concat("No. of items: ", variantRoots.Count);
724 |                     
725 | 
726 |                     //Bind cell data to column
727 |                     Columns variantTableColumns = variantTable.columns;
728 |                     int colid = 0;
729 |                     for(int i=0; i<variantTableColumns.Count; i++)
730 |                     {
731 |                         variantTable.columns[i].makeCell = () => CreateVariantTableCellLabel();
732 |                         variantTable.columns[i].bindCell = (VisualElement element, int index) =>
733 |                         {
734 |                             int actualcolumn = colid % variantTableColumns.Count;
735 |                             string content = variantRoots[index][actualcolumn];
736 |                             (element as Label).text = Helper.NumberSeperator(content);
737 |                             colid++;
738 |                         };
739 |                     }
740 | 
741 |                     //Set default sorting state
742 |                     // var sort = variantTable.sortColumnDescriptions;
743 |                     // if(sort.Count == 0)
744 |                     // {
745 |                     //     SortColumnDescription defaultDesc = new SortColumnDescription(defaultVariantSortColumn,SortDirection.Descending);
746 |                     //     sort.Add(defaultDesc);
747 | 
748 |                     //     OnVariantSortingChanged(variantTable);
749 |                     // }
750 | 
751 |                     //Register sorting event
752 |                     //variantTable.columnSortingChanged += () => OnVariantSortingChanged(variantTable);
753 |                 }
754 | 
755 |                 //Add to list
756 |                 variantTableTemplate.name = shaderName;
757 |                 if(matchingExpandedIndex < 0) matchingExpandedIndex = shaderRowsId;
758 |                 expandedVariantElements[matchingExpandedIndex] = variantTableTemplate;
759 |             }
760 | 
761 |             //Make the table visible
762 |             expandedVariantElements[matchingExpandedIndex].style.display = DisplayStyle.Flex;
763 | 
764 |             return expandedVariantElements[matchingExpandedIndex];        
765 |         }
766 |         
767 |         /*
768 |         private void OnVariantSortingChanged(MultiColumnListView variantTable)
769 |         {
770 |             var sort = variantTable.sortColumnDescriptions;
771 | 
772 |             VisualElement container = variantTable.Q("unity-content-container");
773 |             
774 |             for(int i=0; i<sort.Count; i++)
775 |             {
776 |                 int columnId = variantTable.columns.IndexOf(sort[i].column);
777 |                 container.Sort(delegate (VisualElement e1, VisualElement e2)
778 |                 {
779 |                     VisualElement e1ColumnCell = e1.Children().ElementAt(columnId);
780 |                     Label e1Label = e1.Q<Label>();
781 | 
782 |                     VisualElement e2ColumnCell = e2.Children().ElementAt(columnId);
783 |                     Label e2Label = e2.Q<Label>();
784 | 
785 |                     if(sort[i].direction == SortDirection.Ascending)
786 |                     {
787 |                         return e1Label.text.CompareTo(e2Label.text);
788 |                     }
789 |                     else
790 |                     {
791 |                         return e2Label.text.CompareTo(e1Label.text);
792 |                     }
793 |                 });
794 |             }
795 | 
796 | 
797 |             //variantTable.MarkDirtyRepaint();//.Rebuild();
798 | 
799 |             // //Sort based on sorting state
800 |             // for(int i=0; i<sort.Count; i++)
801 |             // {
802 |             //     int columnId = variantTable.columns.IndexOf(sort[i].column);
803 | 
804 |             //     if(columnId > 0) //First column is shader name, so sort by Alphabetical
805 |             //     {
806 |             //         //sort numbers
807 |             //         if(sort[i].direction == SortDirection.Ascending)
808 |             //         {
809 |             //             shaderRows = shaderRows.OrderBy(o=>float.Parse(o[columnId])).ToList();
810 |             //         }
811 |             //         else
812 |             //         {
813 |             //             shaderRows = shaderRows.OrderByDescending(o=>float.Parse(o[columnId])).ToList();
814 |             //         }
815 |             //     }
816 |             //     else
817 |             //     {
818 |             //         //sort string Alphabetical Order
819 |             //         if(sort[i].direction == SortDirection.Ascending)
820 |             //         {
821 |             //             shaderRows = shaderRows.OrderBy(o=>o[columnId]).ToList();
822 |             //         }
823 |             //         else
824 |             //         {
825 |             //             shaderRows = shaderRows.OrderByDescending(o=>o[columnId]).ToList();
826 |             //         }
827 |             //     }
828 | 
829 |             // }
830 |             
831 |             // SetShaderRootItems();
832 |         }
833 |         */
834 | 
835 | #endregion
836 |     
837 |     }
838 | 
839 |     //===================================================================================================
840 |     public static class SVL
841 |     {
842 |         public static bool logNextBuild = true;
843 |         
844 |         
845 |         //build process indicators
846 |         public static string buildProcessIDTitleStart = "ShaderVariantTool_Start:";
847 |         public static string buildProcessIDTitleEnd = "ShaderVariantTool_End:";
848 |         public static string buildProcessID = ""; //For recognising position in EditorLog
849 |         public static bool buildProcessStarted = false;
850 | 
851 |         //the big total
852 |         public static double buildTime = 0;
853 |         public static double timeSpentByTool = 0;
854 |         public const string timeSpentByToolTitle = "Spent by this tool";
855 |         
856 |         //data
857 |         public static List<ShaderItem> shaderlist = new List<ShaderItem>();
858 |         public static string[] columns;
859 |         
860 |         public static void ReadUXMLForColumns()
861 |         {
862 |             //Get columns from UXML
863 |             if(columns == null)
864 |             {
865 |                 VisualTreeAsset rootVisualTree = Resources.Load<VisualTreeAsset>("ShaderVariantTool_VariantTable");
866 |                 TemplateContainer variantTemplate = rootVisualTree.Instantiate();
867 |                 MultiColumnListView variantTable = variantTemplate.Q<MultiColumnListView>(name: "VariantTable");
868 |                 Columns variantTableColumns = variantTable.columns;
869 |                 columns = new string[variantTableColumns.Count];
870 |                 for(int i=0; i<columns.Length; i++)
871 |                 {
872 |                     columns[i] = variantTableColumns[i].title;
873 |                 }
874 |             }
875 |         }
876 | 
877 |         public static void ResetBuildList()
878 |         {
879 |             if(!buildProcessStarted)
880 |             {
881 |                 ReadUXMLForColumns();
882 | 
883 |                 shaderlist.Clear();
884 |                 buildTime = 0;
885 |                 timeSpentByTool = 0;
886 | 
887 |                 //For reading EditorLog, we can extract the contents
888 |                 buildProcessID = System.DateTime.Now.ToString("yyyyMMdd_HH-mm-ss");
889 |                 Debug.LogFormat(LogType.Log, LogOption.NoStacktrace, null, String.Concat(buildProcessIDTitleStart,buildProcessID));
890 |                 
891 |                 buildTime = EditorApplication.timeSinceStartup;
892 |                 buildProcessStarted = true;
893 |             }
894 |         }
895 |     }
896 | }
897 | 
898 | 


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 1120d4105bb20794c8c61361090aa0b6
 3 | MonoImporter:
 4 |   externalObjects: {}
 5 |   serializedVersion: 2
 6 |   defaultReferences: []
 7 |   executionOrder: 0
 8 |   icon: {instanceID: 0}
 9 |   userData: 
10 |   assetBundleName: 
11 |   assetBundleVariant: 
12 | 


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_BuildProcess.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.IO;
  4 | using System.Text;
  5 | using UnityEditor;
  6 | using UnityEditor.Build;
  7 | using UnityEditor.Build.Reporting;
  8 | using UnityEditorInternal;
  9 | using UnityEngine;
 10 | 
 11 | namespace GfxQA.ShaderVariantTool
 12 | {
 13 |     // BEFORE BUILD
 14 |     class ShaderVariantTool_BuildPreprocess : IPreprocessBuildWithReport
 15 |     {
 16 |         public int callbackOrder { get { return 10; } }
 17 | 
 18 |         //Because of the new incremental build changes, 
 19 |         //Development build won't trigger OnShaderProcess - 1338940
 20 |         public static bool deletePlayerCacheBeforeBuild = true;
 21 |         public void DeletePlayerCacheBeforeBuild()
 22 |         {
 23 |             if(deletePlayerCacheBeforeBuild)
 24 |             {
 25 |                 string path = String.Concat(Application.dataPath.Replace("Assets",""),"Library/PlayerDataCache");
 26 |                 if( Directory.Exists(path) )
 27 |                 {
 28 |                     Directory.Delete(path,true);
 29 |                 }
 30 |             }
 31 |         }
 32 | 
 33 |         public void OnPreprocessBuild(BuildReport report)
 34 |         {
 35 |             Helper.LogNextBuildPopup();
 36 |             if (!SVL.logNextBuild) return;
 37 |             
 38 |             double timeSpent = EditorApplication.timeSinceStartup;
 39 |             
 40 |             //This should be always on
 41 |             ShaderVariantTool_BuildPreprocess.deletePlayerCacheBeforeBuild = true;
 42 |             DeletePlayerCacheBeforeBuild();
 43 | 
 44 |             //IPreprocessShaders happens before IPreprocessBuildWithReport, 
 45 |             //so doing the initial time logging in ShaderVariantTool_ShaderPreprocess instead
 46 |             SVL.ResetBuildList();
 47 |             
 48 |             // Log time
 49 |             timeSpent = EditorApplication.timeSinceStartup - timeSpent;
 50 |             //Debug.Log("OnPreprocessBuild = "+Helper.TimeFormatString(timeSpent));
 51 |             SVL.timeSpentByTool += timeSpent;
 52 |         }
 53 |     }
 54 | 
 55 |     // AFTER BUILD
 56 |     class ShaderVariantTool_BuildPostprocess : IPostprocessBuildWithReport
 57 |     {
 58 |         public int callbackOrder { get { return 10; } }
 59 | 
 60 |         public void OnPostprocessBuild(BuildReport report)
 61 |         {
 62 |             if (!SVL.logNextBuild) return;
 63 |             
 64 |             double timeSpent = EditorApplication.timeSinceStartup;
 65 |             
 66 |             //For reading EditorLog, we can extract the contents
 67 |             Debug.LogFormat(LogType.Log, LogOption.NoStacktrace, null, String.Concat(SVL.buildProcessIDTitleEnd,SVL.buildProcessID));
 68 | 
 69 |             //Reading EditorLog
 70 |             string editorLogPath = Helper.GetEditorLogPath();
 71 | 
 72 |             //Write File
 73 |             var outputRows = WriteCSVFile(report, editorLogPath, String.Concat(SVL.buildProcessIDTitleStart,SVL.buildProcessID));
 74 | 
 75 |             //Save File
 76 |             string fileName = String.Concat("ShaderVariants_",SVL.buildProcessID);//DateTime.Now.ToString("yyyyMMdd_HH-mm-ss");
 77 |             string savedFile = SaveCSVFile(outputRows, fileName);
 78 | 
 79 |             //CleanUp
 80 |             outputRows.Clear();
 81 | 
 82 |             //Let user know the tool has successfully done it's job
 83 |             Debug.Log(String.Concat("Build is done and ShaderVariantTool has done gathering data. Find the details on Windows > ShaderVariantTool, or look at the generated CSV report at: ",savedFile));
 84 | 
 85 |             SVL.buildProcessStarted = false;
 86 |             
 87 |             // Log time (this time value is not included in the CSV as it happens after writing the CSV file)
 88 |             timeSpent = EditorApplication.timeSinceStartup - timeSpent;
 89 |             //Debug.Log("OnPostprocessBuild = "+Helper.TimeFormatString(timeSpent));
 90 |             SVL.timeSpentByTool += timeSpent;
 91 |         }
 92 | 
 93 |         public static List<string[]> WriteCSVFile(BuildReport report, string editorLogPath, string startTimeStamp)
 94 |         {
 95 |             ReadShaderCompileInfo(startTimeStamp, editorLogPath, false);
 96 | 
 97 |             //Prepare CSV string
 98 |             List<string[]> outputRows = new List<string[]>();
 99 | 
100 |             //========================================
101 | 
102 |             if(report != null)
103 |             {
104 |                 //Unity & branch version
105 |                 string version_changeset = Convert.ToString(InternalEditorUtility.GetUnityRevision(), 16);
106 |                 string version_branch = InternalEditorUtility.GetUnityBuildBranch();
107 |                 string unity_version = String.Concat(Application.unityVersion," ",version_branch," (",version_changeset,")");
108 |                 outputRows.Add( new string[] { "Unity" , unity_version } );
109 | 
110 |                 //Platform
111 |                 outputRows.Add( new string[] { "Platform" , report.summary.platform.ToString() } );
112 | 
113 |                 //Get Graphics API list
114 |                 var gfxAPIsList = PlayerSettings.GetGraphicsAPIs(report.summary.platform);
115 |                 StringBuilder gfxAPIs = new StringBuilder();
116 |                 for(int i=0; i<gfxAPIsList.Length; i++)
117 |                 {
118 |                     gfxAPIs.Append(String.Concat(gfxAPIsList[i].ToString(), " "));
119 |                 }
120 |                 outputRows.Add( new string[] { "Graphics API" , gfxAPIs.ToString() } );
121 | 
122 |                 //Build path
123 |                 outputRows.Add( new string[] { "Build Path" , report.summary.outputPath } );
124 | 
125 |                 //Build size
126 |                 var buildSize = report.summary.totalSize / 1024;
127 |                 outputRows.Add( new string[] { "Build Size (Kb)" , buildSize.ToString() } );
128 | 
129 |                 //Build time (report.summary.totalTime is not accurate)
130 |                 SVL.buildTime = EditorApplication.timeSinceStartup - SVL.buildTime;
131 |                 string buildTimeString = Helper.TimeFormatString(SVL.buildTime);
132 |                 outputRows.Add( new string[] { "Build Time" , buildTimeString } );
133 | 
134 |                 //Set keywords declaration types
135 |                 foreach(ShaderItem si in SVL.shaderlist)
136 |                 {
137 |                     si.SetKeywordDeclareType();
138 |                 }
139 |             }
140 | 
141 |             //Calculate total shader numbers
142 |             ShaderItem totalNormalShader = new ShaderItem();
143 |             uint totalNormalShaderCount = 0;
144 |             uint totalProgramInternalCount = 0;
145 |             uint totalProgramUniqueCount = 0;
146 |             ShaderItem totalComputeShader = new ShaderItem(); totalComputeShader.isComputeShader = true;
147 |             uint totalComputeShaderCount = 0;
148 |             foreach(ShaderItem si in SVL.shaderlist)
149 |             {
150 |                 //For bug checking
151 |                 uint shaderInternalProgramCount = 0;
152 | 
153 |                 if(si.isComputeShader)
154 |                 {
155 |                     totalComputeShaderCount ++;
156 | 
157 |                     totalComputeShader.count_variant_before += si.count_variant_before;
158 |                     totalComputeShader.count_dynamicVariant_before += si.count_dynamicVariant_before;
159 |                     totalComputeShader.count_variant_after += si.count_variant_after;
160 |                     totalComputeShader.count_dynamicVariant_after += si.count_dynamicVariant_after;
161 | 
162 |                     totalComputeShader.editorLog_variantOriginalCount += si.editorLog_variantOriginalCount;
163 |                     totalComputeShader.editorLog_variantAfterPrefilteringCount += si.editorLog_variantAfterPrefilteringCount;
164 |                     totalComputeShader.editorLog_variantAfterBuiltinStrippingCount += si.editorLog_variantAfterBuiltinStrippingCount;
165 |                     totalComputeShader.editorLog_variantAfterSciptableStrippingCount += si.editorLog_variantAfterSciptableStrippingCount;
166 |                     totalComputeShader.editorLog_variantMeshDataOptimizationCached += si.editorLog_variantMeshDataOptimizationCached;
167 |                     totalComputeShader.editorLog_variantMeshDataOptimizationCompiled += si.editorLog_variantMeshDataOptimizationCompiled;
168 |                     totalComputeShader.editorLog_variantCompiledCount += si.editorLog_variantCompiledCount;
169 |                     totalComputeShader.editorLog_variantInCache += si.editorLog_variantInCache;
170 |                     totalComputeShader.editorLog_timeCompile += si.editorLog_timeCompile;
171 |                     totalComputeShader.editorLog_timeStripping += si.editorLog_timeStripping;
172 |                 }
173 |                 else
174 |                 {
175 |                     totalNormalShaderCount ++;
176 | 
177 |                     totalNormalShader.count_variant_before += si.count_variant_before;
178 |                     totalNormalShader.count_dynamicVariant_before += si.count_dynamicVariant_before;
179 |                     totalNormalShader.count_variant_after += si.count_variant_after;
180 |                     totalNormalShader.count_dynamicVariant_after += si.count_dynamicVariant_after;
181 | 
182 |                     totalNormalShader.editorLog_variantOriginalCount += si.editorLog_variantOriginalCount;
183 |                     totalNormalShader.editorLog_variantAfterPrefilteringCount += si.editorLog_variantAfterPrefilteringCount;
184 |                     totalNormalShader.editorLog_variantAfterBuiltinStrippingCount += si.editorLog_variantAfterBuiltinStrippingCount;
185 |                     totalNormalShader.editorLog_variantAfterSciptableStrippingCount += si.editorLog_variantAfterSciptableStrippingCount;
186 |                     totalNormalShader.editorLog_variantMeshDataOptimizationCached += si.editorLog_variantMeshDataOptimizationCached;
187 |                     totalNormalShader.editorLog_variantMeshDataOptimizationCompiled += si.editorLog_variantMeshDataOptimizationCompiled;
188 |                     totalNormalShader.editorLog_variantCompiledCount += si.editorLog_variantCompiledCount;
189 |                     totalNormalShader.editorLog_variantInCache += si.editorLog_variantInCache;
190 |                     totalNormalShader.editorLog_timeCompile += si.editorLog_timeCompile;
191 |                     totalNormalShader.editorLog_timeStripping += si.editorLog_timeStripping;
192 | 
193 | 
194 |                     foreach(ShaderProgram pgm in si.programs)
195 |                     {
196 |                         shaderInternalProgramCount += pgm.count_internal;
197 |                         totalProgramInternalCount += pgm.count_internal;
198 |                         totalProgramUniqueCount += pgm.count_unique;
199 |                     }
200 |                 }
201 | 
202 |                 //Bug Check - if the shader has errors, then the program count drops, the tool should print out error message to warn user too
203 |                 if( !si.isComputeShader && shaderInternalProgramCount != si.editorLog_variantAfterSciptableStrippingCount)
204 |                 {
205 |                     Debug.LogWarning(String.Concat("ShaderVariantTool error #E08. Shader ",si.name," has ",si.editorLog_variantAfterSciptableStrippingCount,
206 |                     " variants after ScriptableStripping, but Internal Program Count is not having same number: ",shaderInternalProgramCount,
207 |                     ". Check console to see if this shader has errors. And if you have [Optimize mesh data] enabled in Player Settings, this is normal to see this warning if you have modified shader keywords."));
208 |                 }
209 |                 //Bug check - in case the variants tracked in OnProcessShader VS reading EditorLog counts different result
210 |                 if( si.count_variant_after != si.editorLog_variantAfterSciptableStrippingCount )
211 |                 {
212 |                     string debugMessage = String.Concat("ShaderVariantTool error #E01. ",si.name," has different count after scriptable stripping. ",
213 |                                                         "Tool counted there are ",si.count_variant_after+" shader variants in build, ",
214 |                                                         "but Editor.Log counted ",si.editorLog_variantAfterSciptableStrippingCount,". ",
215 |                                                         "Mesh data optimization count is ",si.editorLog_variantMeshDataOptimizationCached,"(cached) ",si.editorLog_variantMeshDataOptimizationCompiled,"(compiled). ");
216 |                     if (PlayerSettings.stripUnusedMeshComponents)
217 |                     {
218 |                         debugMessage = String.Concat(debugMessage,"This might due to [Optimize Mesh Data] is enabled in Player Settings. Some shader compilation is done and thus being tracked by the tool.");
219 |                         Debug.LogWarning(debugMessage);
220 |                     }
221 |                     else
222 |                     {
223 |                         Debug.LogError(debugMessage);
224 |                     }
225 |                 }
226 |                 if( si.count_variant_before != si.editorLog_variantAfterBuiltinStrippingCount )
227 |                 {
228 |                     string debugMessage = String.Concat("ShaderVariantTool error #E02. ",si.name+" has different count before scriptable stripping. ",
229 |                                                         "Tool counted there are ",si.count_variant_before," variants before striptable-stripping, ",
230 |                                                         "but Editor.Log counted ",si.editorLog_variantAfterBuiltinStrippingCount,". ",
231 |                                                         "Mesh data optimization count is ",si.editorLog_variantMeshDataOptimizationCached,"(cached) ",si.editorLog_variantMeshDataOptimizationCompiled,"(compiled). ");
232 |                     if (PlayerSettings.stripUnusedMeshComponents)
233 |                     {
234 |                         debugMessage = String.Concat(debugMessage,"This might due to [Optimize Mesh Data] is enabled in Player Settings. Some shader compilation is done and thus being tracked by the tool.");
235 |                         Debug.LogWarning(debugMessage);
236 |                     }
237 |                     else
238 |                     {
239 |                         Debug.LogError(debugMessage);
240 |                     }
241 |                 }
242 |             }
243 | 
244 |             //Stripping time
245 |             string strippingTimeString = Helper.TimeFormatString(totalNormalShader.editorLog_timeStripping);
246 |             outputRows.Add( new string[] { "- Stripping Time" , strippingTimeString } );
247 |             
248 |             //Time spent by the tool (list under stripping time)
249 |             string timeSpentByToolString = Helper.TimeFormatString(SVL.timeSpentByTool);
250 |             outputRows.Add( new string[] { String.Concat("--",SVL.timeSpentByToolTitle) , timeSpentByToolString } );
251 |             
252 |             //Compile time
253 |             string compileTimeString = Helper.TimeFormatString(totalNormalShader.editorLog_timeCompile);
254 |             outputRows.Add( new string[] { "- Compilation Time" , compileTimeString } );
255 |             
256 |             //Build time without impact of the tool
257 |             double builtTimeNoImpact = SVL.buildTime - SVL.timeSpentByTool;
258 |             string builtTimeNoImpactString = Helper.TimeFormatString(builtTimeNoImpact);
259 |             outputRows.Add( new string[] { "Build Time minus time spent by tool" , builtTimeNoImpactString } );
260 | 
261 |             //Shader counts
262 |             outputRows.Add( new string[] { "Shader Count" , totalNormalShaderCount.ToString() } );
263 |             outputRows.Add( new string[] { "Shader Variant Count original" , totalNormalShader.editorLog_variantOriginalCount.ToString() } );
264 |             outputRows.Add( new string[] { "Shader Variant Count after Prefiltering" , totalNormalShader.editorLog_variantAfterPrefilteringCount.ToString() } );
265 |             outputRows.Add( new string[] { "Shader Variant Count after Builtin-Stripping" , totalNormalShader.editorLog_variantAfterBuiltinStrippingCount.ToString() } );
266 |             outputRows.Add( new string[] { "Shader Variant Count after Scriptable-Stripping" , totalNormalShader.editorLog_variantAfterSciptableStrippingCount.ToString() } );
267 |             outputRows.Add( new string[] { "- Cached:" , totalNormalShader.editorLog_variantInCache.ToString() } );
268 |             outputRows.Add( new string[] { "- Compiled:" , totalNormalShader.editorLog_variantCompiledCount.ToString() } );
269 |             outputRows.Add( new string[] { "Shader Dynamic Branch variant count" , totalNormalShader.count_dynamicVariant_after.ToString() } );
270 |             outputRows.Add( new string[] { "Shader Program Count" , "" } );
271 |             outputRows.Add( new string[] { "- Internal:" , totalProgramInternalCount.ToString() } );
272 |             outputRows.Add( new string[] { "- Unique:" , totalProgramUniqueCount.ToString() } );
273 | 
274 |             //Compute counts
275 |             outputRows.Add( new string[] { "ComputeShader Count" , totalComputeShaderCount.ToString() } );
276 |             outputRows.Add( new string[] { "Compute Variant Count after Builtin-Stripping" , totalComputeShader.count_variant_before.ToString() } );
277 |             outputRows.Add( new string[] { "Compute Variant Count after Scriptable-Stripping" , totalComputeShader.count_variant_after.ToString() } );
278 |             outputRows.Add( new string[] { "Compute Dynamic Branch variant count" , totalComputeShader.count_dynamicVariant_after.ToString() } );
279 |             outputRows.Add( new string[] { "" } );
280 | 
281 |             //Shader table //remember to match the order & title in Main.uxml
282 |             List<string> shaderTableHeaderRow = new List<string>();
283 |             shaderTableHeaderRow.Add("Shader Name");
284 |             shaderTableHeaderRow.Add("Original");
285 |             shaderTableHeaderRow.Add("After Prefiltering");
286 |             shaderTableHeaderRow.Add("After Builtin-Stripping");
287 |             shaderTableHeaderRow.Add("After Scriptable-Stripping");
288 |             shaderTableHeaderRow.Add("Dynamic Branch");
289 |             shaderTableHeaderRow.Add("Variant in Cache");
290 |             shaderTableHeaderRow.Add("Compiled Variant Count");
291 |             shaderTableHeaderRow.Add("Stripping Time");
292 |             shaderTableHeaderRow.Add("Compilation Time");
293 |             shaderTableHeaderRow.Add("IsComputeShader");
294 |             //Additional header due to per-graphics API program count
295 |             foreach(ShaderItem si in SVL.shaderlist)
296 |             {
297 |                 foreach(ShaderProgram pgm in si.programs)
298 |                 {
299 |                     string program_header = String.Concat("Program Count ",pgm.gfxAPI);
300 | 
301 |                     int shaderTableColumnId = shaderTableHeaderRow.FindIndex(e => e == program_header);
302 |                     if(shaderTableColumnId == -1)
303 |                     {
304 |                         shaderTableHeaderRow.Add(program_header);
305 |                     }
306 |                 }
307 |             }
308 |             outputRows.Add(shaderTableHeaderRow.ToArray());
309 |             //Fill the table
310 |             foreach(ShaderItem si in SVL.shaderlist)
311 |             {
312 |                 string[] shaderTableItemRow = new string[shaderTableHeaderRow.Count];
313 |                 shaderTableItemRow[0] = si.name;
314 |                 shaderTableItemRow[1] = si.editorLog_variantOriginalCount.ToString();
315 |                 shaderTableItemRow[2] = si.editorLog_variantAfterPrefilteringCount.ToString();
316 |                 shaderTableItemRow[3] = si.count_variant_before.ToString();
317 |                 shaderTableItemRow[4] = si.count_variant_after.ToString();
318 |                 shaderTableItemRow[5] = si.count_dynamicVariant_after.ToString();
319 |                 shaderTableItemRow[6] = si.editorLog_variantInCache.ToString();
320 |                 shaderTableItemRow[7] = si.editorLog_variantCompiledCount.ToString();
321 |                 shaderTableItemRow[8] = Helper.TimeFormatString( si.editorLog_timeStripping );
322 |                 shaderTableItemRow[9] = Helper.TimeFormatString( si.editorLog_timeCompile );
323 |                 shaderTableItemRow[10] = si.isComputeShader.ToString();
324 |                 
325 |                 //Program count
326 |                 if(si.isComputeShader)
327 |                 {
328 |                     for(int k=11; k<shaderTableHeaderRow.Count; k++)
329 |                     {
330 |                         shaderTableItemRow[k] = "N/A";
331 |                     }
332 |                 }
333 |                 else
334 |                 {
335 |                     foreach(ShaderProgram pgm in si.programs)
336 |                     {
337 |                         int shaderTableColumnId = shaderTableHeaderRow.FindIndex(e => e == String.Concat("Program Count ",pgm.gfxAPI));
338 |                         if(shaderTableColumnId != -1)
339 |                         {
340 |                             shaderTableItemRow[shaderTableColumnId] = String.Concat("internal: ",pgm.count_internal," | unique: ",pgm.count_unique);
341 |                         }
342 |                     }
343 |                 }
344 |                 
345 |                 outputRows.Add(shaderTableItemRow);
346 |             }
347 |             outputRows.Add( new string[] { "" } );
348 | 
349 |             //Variant Table Column header
350 |             SVL.ReadUXMLForColumns();
351 |             outputRows.Add(SVL.columns);
352 | 
353 |             //Variant Table
354 |             foreach(ShaderItem si in SVL.shaderlist)
355 |             {
356 |                 //Each keyword item
357 |                 si.keywordItems.Sort((x, y) => y.appearCount_after.CompareTo(x.appearCount_after)); //Decending order
358 |                 for(int k=0; k < si.keywordItems.Count; k++)
359 |                 {
360 |                     KeywordItem ki = si.keywordItems[k];
361 |                     outputRows.Add(new string[] 
362 |                     {
363 |                         ki.shaderName,
364 |                         ki.appearCount_before.ToString(),
365 |                         ki.appearCount_after.ToString(),
366 |                         ki.shaderKeywordName,
367 |                         ki.shaderKeywordDeclareType,
368 |                         ki.passName,
369 |                         ki.shaderType,
370 |                         ki.passType,
371 |                         ki.kernelName,
372 |                         ki.graphicsTier,
373 |                         ki.buildTarget,
374 |                         ki.shaderCompilerPlatform,
375 |                         ki.platformKeywords,
376 |                         ki.shaderKeywordType,
377 |                     });
378 |                 }
379 |             }
380 | 
381 |             return outputRows;
382 |         }
383 | 
384 |         public static string SaveCSVFile(List<string[]> outputRows, string fileName)
385 |         {
386 |             //Prepare CSV string
387 |             int length = outputRows.Count;
388 |             string delimiter = ",";
389 |             StringBuilder sb = new StringBuilder();
390 |             for (int index = 0; index < length; index++)
391 |                 sb.AppendLine(string.Join(delimiter, outputRows[index]));
392 |             
393 |             //Write to CSV file
394 |             string savedFile = String.Concat(Helper.GetCSVFolderPath(),fileName,".csv");
395 |             StreamWriter outStream = System.IO.File.CreateText(savedFile);
396 |             outStream.WriteLine(sb);
397 |             outStream.Close();
398 | 
399 |             //CleanUp
400 |             outputRows.Clear();
401 | 
402 |             return savedFile;
403 |         }
404 | 
405 |         public static void ReadShaderCompileInfo(string startTimeStamp, string editorLogPath, bool isLogReader)
406 |         {
407 |             //For bug checking
408 |             UInt64 sum_variantCountinBuild = 0;
409 |             UInt64 sum_variantCountinCache = 0;
410 |             UInt64 sum_variantCountCompiled = 0;
411 |             UInt64 sum_variantCountSkipped = 0;
412 | 
413 |             //Read EditorLog
414 |             string fromtext = startTimeStamp;
415 |             string totext = startTimeStamp.Replace(SVL.buildProcessIDTitleStart,SVL.buildProcessIDTitleEnd);
416 |             string currentLine = "";
417 |             bool startFound = false;
418 |             bool endFound = false;
419 |             FileStream fs = new FileStream(editorLogPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
420 | 
421 |             using (StreamReader sr = new StreamReader(fs))
422 |             {
423 |                 while (!startFound)
424 |                 {
425 |                     currentLine = sr.ReadLine();
426 |                     if(currentLine.Contains(fromtext))
427 |                     {
428 |                         startFound = true;
429 |                     }
430 |                 }
431 |                 while (!endFound)
432 |                 {
433 |                     if(
434 |                         !currentLine.Contains("Compiling shader ") && 
435 |                         !currentLine.Contains("Compiling mesh data optimization processing for") && 
436 |                         !currentLine.Contains("Compiling compute shader ")
437 |                         )
438 |                     {
439 |                         currentLine = sr.ReadLine();
440 |                     }
441 | 
442 |                     if(currentLine.Contains(totext))
443 |                     {
444 |                         endFound = true;
445 |                     }
446 |                     else
447 |                     {
448 |                         //Added in 2023.3.0b2
449 |                         //Compiling mesh data optimization processing for "Test/ShaderKeywordTest" pass "":
450 |                         //Cached mesh channel usage data found for 2 variants. 0 variants require compilation to get this data.
451 |                         if (currentLine.Contains("Compiling mesh data optimization processing for"))
452 |                         {
453 |                             //Shader name
454 |                             string shaderName = Helper.ExtractString(currentLine, "Compiling mesh data optimization processing for " , " pass " );
455 |                             shaderName = shaderName.Replace("\"","");
456 |                             
457 |                             currentLine = sr.ReadLine();
458 |                             
459 |                             while(!currentLine.Contains("Cached mesh channel usage data found for "))
460 |                             {
461 |                                 currentLine = sr.ReadLine();
462 |                             }
463 |                             
464 |                             //Variant count for mesh data optimization
465 |                             UInt64 cachedMeshDataOptimizationVariantInt = 0;
466 |                             UInt64 compiledMeshDataOptimizationVariantInt = 0;
467 |                             if(currentLine.Contains("Cached mesh channel usage data found for "))
468 |                             {
469 |                                 //Cached
470 |                                 string cachedVariantCount = Helper.ExtractString(currentLine, "Cached mesh channel usage data found for " , " variants. " );
471 |                                 cachedVariantCount = cachedVariantCount.Replace(" ","");
472 |                                 cachedMeshDataOptimizationVariantInt = UInt64.Parse(cachedVariantCount);
473 |                                 
474 |                                 //Compiled
475 |                                 string compiledVariantCount = Helper.ExtractString(currentLine, " variants. " , " variants require compilation to get this data." );
476 |                                 compiledVariantCount = compiledVariantCount.Replace(" ","");
477 |                                 compiledMeshDataOptimizationVariantInt = UInt64.Parse(compiledVariantCount);
478 |                                 
479 |                                 //---------- Log ShaderItem ------------//
480 |                                 ShaderItem shaderItem = GetOrCreateShaderItem(shaderName);
481 |                                 shaderItem.editorLog_variantMeshDataOptimizationCached += cachedMeshDataOptimizationVariantInt;
482 |                                 shaderItem.editorLog_variantMeshDataOptimizationCompiled += compiledMeshDataOptimizationVariantInt;
483 |                             }
484 |                         }
485 |                         
486 |                         /* Compute shader:
487 |                         Compiling compute shader "StpSetup"
488 |                         starting stripping...
489 |                         finished in 0.30 seconds. 64 of 64 variants left
490 |                         64 variants, starting compilation...
491 |                         finished in 1.43 seconds. Local cache hits 0, remote cache hits 0, compiled 64 variants
492 |                          */
493 |                         if (currentLine.Contains("Compiling compute shader "))
494 |                         {
495 |                             //Shader name
496 |                             string shaderName = Helper.ExtractString(currentLine, "Compiling compute shader " , "" );
497 |                             shaderName = shaderName.Replace("\"","");
498 |                             
499 |                             currentLine = sr.ReadLine();
500 |                             currentLine = sr.ReadLine();
501 |                             
502 |                             //stripping time
503 |                             string strippingTime = Helper.ExtractString(currentLine, "finished in " , " seconds. " );
504 |                             
505 |                             //Original variant count
506 |                             UInt64 totalVariantInt = 0;
507 |                             string totalVariant = Helper.ExtractString(currentLine, " of " , " variants left" );
508 |                             totalVariant = totalVariant.Replace(" ","");
509 |                             totalVariantInt = UInt64.Parse(totalVariant);
510 |                             
511 |                             //Remaining variant count
512 |                             UInt64 remainingVariantInt = 0;
513 |                             string remainingVariant = Helper.ExtractString(currentLine, " seconds. " , " of " );
514 |                             remainingVariant = remainingVariant.Replace(" ","");
515 |                             remainingVariantInt = UInt64.Parse(remainingVariant);
516 | 
517 |                             //compilation time and compiled variant count (time is faster if there are cached variants)
518 |                             string startString = "";
519 |                             string endString = "";
520 |                             string compileTime = "0.00";
521 |                             string compiledVariants = "0";
522 |                             string localCache = "0";
523 |                             string remoteCache = "0";
524 |                             //string skippedVariants = "0";
525 |                             
526 |                             if (remainingVariantInt > 0)
527 |                             {
528 |                                 currentLine = sr.ReadLine();
529 |                                 currentLine = sr.ReadLine();
530 |                                 string remainingText = currentLine;
531 |                                 
532 |                                 //Compile time
533 |                                 startString = "finished in ";
534 |                                 endString = " seconds. ";
535 |                                 compileTime = Helper.ExtractString(remainingText,startString,endString,true);
536 |                                 compileTime = compileTime.Replace(" ","");
537 |                                 //remainingText = Helper.GetRemainingString(remainingText,endString);
538 | 
539 |                                 //Local cache hit
540 |                                 startString = "Local cache hits ";
541 |                                 endString = ", remote cache hits";
542 |                                 localCache = Helper.ExtractString(remainingText,startString,endString,true);
543 |                                 localCache = localCache.Replace(" ","");
544 |                                 //remainingText = Helper.GetRemainingString(remainingText,endString);
545 | 
546 |                                 //Remote cache hit
547 |                                 startString = "remote cache hits ";
548 |                                 endString = ", compiled ";
549 |                                 remoteCache = Helper.ExtractString(remainingText,startString,endString,true);
550 |                                 remoteCache = remoteCache.Replace(" ","");
551 |                                 //remainingText = Helper.GetRemainingString(remainingText,endString);
552 | 
553 |                                 //Compiled variants
554 |                                 startString = ", compiled ";
555 |                                 endString = " variants";
556 |                                 compiledVariants = Helper.ExtractString(remainingText,startString,endString,true);
557 |                                 compiledVariants = compiledVariants.Replace(" ","");
558 |                                 //remainingText = Helper.GetRemainingString(remainingText,endString);
559 | 
560 |                                 //Skipped variants
561 |                                 //startString = " skipped ";
562 |                                 //endString = " variants";
563 |                                 //skippedVariants = Helper.ExtractString(remainingText,startString,endString,false);
564 |                                 //skippedVariants = skippedVariants.Replace(" ","");
565 |                                 //remainingText = Helper.GetRemainingString(remainingText,endString);
566 |                             }
567 |                             
568 |                             uint compiledVariantsInt = uint.Parse(compiledVariants);
569 |                             uint localCacheInt = uint.Parse(localCache);
570 |                             uint remoteCacheInt = uint.Parse(remoteCache);
571 |                             // skippedVariantsInt = uint.Parse(skippedVariants);
572 |                             float strippingTimeFloat = float.Parse(strippingTime);
573 |                             float compileTimeFloat = float.Parse(compileTime);
574 |                             
575 |                             //---------- Log ShaderItem ------------//
576 |                             ShaderItem shaderItem = GetOrCreateShaderItem(shaderName);
577 |                             shaderItem.editorLog_variantOriginalCount += totalVariantInt;
578 |                             shaderItem.editorLog_variantAfterPrefilteringCount += totalVariantInt; //for compute, this is still the original variant count
579 |                             shaderItem.editorLog_variantAfterBuiltinStrippingCount += totalVariantInt; //for compute, this is still the original variant count
580 |                             shaderItem.editorLog_variantAfterSciptableStrippingCount += remainingVariantInt;
581 |                             shaderItem.editorLog_variantCompiledCount += compiledVariantsInt;
582 |                             shaderItem.editorLog_variantInCache += localCacheInt+remoteCacheInt;
583 |                             shaderItem.editorLog_timeStripping += strippingTimeFloat;
584 |                             shaderItem.editorLog_timeCompile += compileTimeFloat;
585 |                         }
586 |                         
587 |                         //Normal shader
588 |                         if(currentLine.Contains("Compiling shader "))
589 |                         {
590 |                             //Shader name
591 |                             string shaderName = Helper.ExtractString(currentLine, "Compiling shader " , " pass " );
592 |                             shaderName = shaderName.Replace("\"","");
593 | 
594 |                             //Shader pass
595 |                             string passName = Helper.ExtractString(currentLine, " pass " , "\" (" );
596 |                             passName = passName.Replace("\"","");
597 | 
598 |                             //Shader program e.g. vert / frag
599 |                             string programName = Helper.ExtractString(currentLine, String.Concat(passName,"\" ("),"");
600 |                             programName = programName.Replace("\"","").Replace(")","");
601 | 
602 |                             //Sometime the log is like this
603 |                             /*
604 |                             Compiling shader "Universal Render Pipeline/Lit" pass "ForwardLit" (fp)
605 |                             [2.97s] 100M / ~402M prepared
606 |                             [11.34s] 200M / ~402M prepared
607 |                             [19.22s] 300M / ~402M prepared
608 |                             [27.65s] 400M / ~402M prepared
609 |                                 Full variant space:         402653184
610 |                                 After settings filtering:   402653184
611 |                                 After built-in stripping:   3145728
612 |                                 After scriptable stripping: 896
613 |                                 Processed in 28.45 seconds
614 |                                 starting compilation...
615 |                                 [ 61s] 360 / 896 variants ready
616 |                                 [123s] 537 / 896 variants ready
617 |                                 [189s] 660 / 896 variants ready
618 |                                 [254s] 795 / 896 variants ready
619 |                                 finished in 301.68 seconds. Local cache hits 8 (0.00s CPU time), remote cache hits 0 (0.00s CPU time), compiled 888 variants (4504.33s CPU time), skipped 0 variants
620 |                                 Prepared data for serialisation in 0.02s
621 |                             */
622 |                             while(!currentLine.Contains("Full variant space:"))
623 |                             {
624 |                                 currentLine = sr.ReadLine();
625 |                             }
626 | 
627 |                             //Full variant space (variant count before prefiltering & stripping)
628 |                             //currentLine = sr.ReadLine();
629 |                             UInt64 totalVariantInt = 0;
630 |                             if(currentLine.Contains("Full variant space:"))
631 |                             {
632 |                                 string totalVariant = Helper.ExtractString(currentLine, "Full variant space:" , "" );
633 |                                 totalVariant = totalVariant.Replace(" ","");
634 |                                 totalVariantInt = UInt64.Parse(totalVariant);
635 |                             }
636 | 
637 |                             //After settings filtering (variant count after prefiltering)
638 |                             currentLine = sr.ReadLine();
639 |                             UInt64 prefilteredVariantInt = 0;
640 |                             if(currentLine.Contains("After settings filtering:"))
641 |                             {
642 |                                 string prefilteredVariant = Helper.ExtractString(currentLine, "After settings filtering:" , "" );
643 |                                 prefilteredVariant = prefilteredVariant.Replace(" ","");
644 |                                 prefilteredVariantInt = UInt64.Parse(prefilteredVariant);
645 |                             }
646 | 
647 |                             //After builtin stripping
648 |                             currentLine = sr.ReadLine();
649 |                             UInt64 builtinStrippedVariantInt = 0;
650 |                             if(currentLine.Contains("After built-in stripping:"))
651 |                             {
652 |                                 string builtinStrippedVariant = Helper.ExtractString(currentLine, "After built-in stripping:" , "" );
653 |                                 builtinStrippedVariant = builtinStrippedVariant.Replace(" ","");
654 |                                 builtinStrippedVariantInt = UInt64.Parse(builtinStrippedVariant);
655 |                             }
656 | 
657 |                             //After scriptable stripping (final variant count in build)
658 |                             currentLine = sr.ReadLine(); //After scriptable stripping:
659 |                             UInt64 remainingVariantInt = 0;
660 |                             if(currentLine.Contains("After scriptable stripping:"))
661 |                             {
662 |                                 string remainingVariant = Helper.ExtractString(currentLine, "After scriptable stripping:" , "" );
663 |                                 remainingVariant = remainingVariant.Replace(" ","");
664 |                                 remainingVariantInt = UInt64.Parse(remainingVariant);
665 |                             }
666 |                             else
667 |                             {
668 |                                 Debug.LogError(String.Concat("Cannot find line [After scriptable stripping:]. CurrentLine = ",currentLine));
669 |                             }
670 | 
671 |                             //remaining variant & stripping time
672 |                             //string remainingVariant = Helper.ExtractString(currentLine, "" , " / " );
673 |                             //int remainingVariantInt = int.Parse(remainingVariant);
674 | 
675 |                             //total variant
676 |                             //string totalVariant = Helper.ExtractString(currentLine, "/ " , " variants" );
677 |                             //totalVariant = totalVariant.Replace(" ","");
678 |                             //int totalVariantInt = int.Parse(totalVariant);
679 |                             
680 |                             //stripping time
681 |                             currentLine = sr.ReadLine();
682 |                             string strippingTime = Helper.ExtractString(currentLine, "Processed in " , " seconds" );
683 | 
684 |                             //jump to line of compilation time
685 |                             if(remainingVariantInt > 0)
686 |                             {
687 |                                 currentLine = sr.ReadLine();
688 |                                 while (!currentLine.Contains("finished in ") || currentLine.Contains("variants ready"))
689 |                                 {
690 |                                     currentLine = sr.ReadLine();
691 |                                 }
692 |                             }
693 |                             
694 |                             //compilation time and compiled variant count (time is faster if there are cached variants)
695 |                             string remainingText = currentLine;
696 |                             string startString = "";
697 |                             string endString = "";
698 |                             string compileTime = "0.00";
699 |                             string compiledVariants = "0";
700 |                             string localCache = "0";
701 |                             string remoteCache = "0";
702 |                             string skippedVariants = "0";
703 |                             if(remainingVariantInt > 0)
704 |                             {
705 |                                 //Compile time
706 |                                 startString = "finished in ";
707 |                                 endString = " seconds. ";
708 |                                 compileTime = Helper.ExtractString(remainingText,startString,endString,false);
709 |                                 compileTime = compileTime.Replace(" ","");
710 |                                 remainingText = Helper.GetRemainingString(remainingText,endString);
711 | 
712 |                                 //Local cache hit
713 |                                 startString = "Local cache hits ";
714 |                                 endString = " (";
715 |                                 localCache = Helper.ExtractString(remainingText,startString,endString,false);
716 |                                 localCache = localCache.Replace(" ","");
717 |                                 remainingText = Helper.GetRemainingString(remainingText,endString);
718 | 
719 |                                 //Remote cache hit
720 |                                 startString = "remote cache hits ";
721 |                                 endString = " (";
722 |                                 remoteCache = Helper.ExtractString(remainingText,startString,endString,false);
723 |                                 remoteCache = remoteCache.Replace(" ","");
724 |                                 remainingText = Helper.GetRemainingString(remainingText,endString);
725 | 
726 |                                 //Compiled variants
727 |                                 startString = "), compiled ";
728 |                                 endString = " variants (";
729 |                                 compiledVariants = Helper.ExtractString(remainingText,startString,endString,false);
730 |                                 compiledVariants = compiledVariants.Replace(" ","");
731 |                                 remainingText = Helper.GetRemainingString(remainingText,endString);
732 | 
733 |                                 //Skipped variants
734 |                                 startString = " skipped ";
735 |                                 endString = " variants";
736 |                                 skippedVariants = Helper.ExtractString(remainingText,startString,endString,false);
737 |                                 skippedVariants = skippedVariants.Replace(" ","");
738 |                                 remainingText = Helper.GetRemainingString(remainingText,endString);
739 |                             }
740 |                             uint compiledVariantsInt = uint.Parse(compiledVariants);
741 |                             uint localCacheInt = uint.Parse(localCache);
742 |                             uint remoteCacheInt = uint.Parse(remoteCache);
743 |                             uint skippedVariantsInt = uint.Parse(skippedVariants);
744 |                             float strippingTimeFloat = float.Parse(strippingTime);
745 |                             float compileTimeFloat = float.Parse(compileTime);
746 | 
747 |                             //---------- Log ShaderItem ------------//
748 |                             ShaderItem shaderItem = GetOrCreateShaderItem(shaderName);
749 |                             shaderItem.editorLog_variantOriginalCount += totalVariantInt;
750 |                             shaderItem.editorLog_variantAfterPrefilteringCount += prefilteredVariantInt;
751 |                             shaderItem.editorLog_variantAfterBuiltinStrippingCount += builtinStrippedVariantInt;
752 |                             shaderItem.editorLog_variantAfterSciptableStrippingCount += remainingVariantInt;
753 |                             shaderItem.editorLog_variantCompiledCount += compiledVariantsInt;
754 |                             shaderItem.editorLog_variantInCache += localCacheInt+remoteCacheInt;
755 |                             shaderItem.editorLog_timeStripping += strippingTimeFloat;
756 |                             shaderItem.editorLog_timeCompile += compileTimeFloat;
757 | 
758 |                             //Log shader program counts
759 |                             /*
760 |                                 Serialized binary data for shader Hidden/VideoDecode in 0.00s
761 |                                 d3d11 (total internal programs: 30, unique: 19)
762 |                                 vulkan (total internal programs: 15, unique: 15)
763 |                             */
764 |                             currentLine = sr.ReadLine();
765 |                             while(currentLine.Contains("Prepared data for serialisation in "))
766 |                             {
767 |                                 currentLine = sr.ReadLine();
768 |                             }
769 |                             if (currentLine.Contains(String.Concat("Serialized binary data for shader ",shaderName)))
770 |                             {
771 |                                 currentLine = sr.ReadLine();
772 |                                 while(currentLine.Contains("total internal programs:"))
773 |                                 {
774 |                                     string gfxAPI = Helper.ExtractString(currentLine,""," (total internal programs: ",false);
775 |                                            gfxAPI = gfxAPI.Replace(" ","");
776 |                                     string programCount_internal_string = Helper.ExtractString(currentLine,"total internal programs: ",", unique: ",false);
777 |                                     string programCount_unique_string = Helper.ExtractString(currentLine,", unique: ",")",false);
778 |                                     uint programCount_internal = uint.Parse(programCount_internal_string);
779 |                                     uint programCount_unique = uint.Parse(programCount_unique_string); 
780 | 
781 |                                     ShaderProgram pgm = new ShaderProgram(gfxAPI, programCount_internal, programCount_unique);
782 |                                     int matchedProgramId = shaderItem.FindMatchingProgramItem(pgm);
783 |                                     if(matchedProgramId == -1)
784 |                                     {
785 |                                         shaderItem.programs.Add(pgm);
786 |                                     }
787 |                                     else
788 |                                     {
789 |                                         shaderItem.programs[matchedProgramId].count_internal += programCount_internal;
790 |                                         shaderItem.programs[matchedProgramId].count_unique += programCount_unique;
791 |                                     }
792 |                                     currentLine = sr.ReadLine();
793 |                                 }
794 |                             }
795 | 
796 |                             //Bug checking
797 |                             sum_variantCountSkipped += skippedVariantsInt;
798 |                             sum_variantCountinCache += localCacheInt+remoteCacheInt;
799 |                             sum_variantCountCompiled += compiledVariantsInt;
800 |                             sum_variantCountinBuild += remainingVariantInt;
801 |                             //Debug
802 |                             // if(shaderName == "Universal Render Pipeline/Lit")
803 |                             // {
804 |                             //     string debugText = shaderName +"-"+ passName +"-"+ programName + "\n";
805 |                             //     debugText += totalVariant +"-"+ remainingVariant +"-time-"+ strippingTime + "\n";
806 |                             //     debugText += compileTime +"-"+ compiledVariants + "\n";
807 |                             //     DebugLog(debugText);    
808 |                             // }
809 | 
810 |                         }
811 |                     }
812 |                 }
813 |             }
814 |             //Bug checking
815 |             UInt64 variantCacheAndCompiledSum = sum_variantCountinCache + sum_variantCountCompiled + sum_variantCountSkipped;
816 |             if( variantCacheAndCompiledSum != sum_variantCountinBuild)
817 |             {
818 |                 Debug.LogError(String.Concat("ShaderVariantTool error #E03. ",
819 |                 "The sum of shader variants cached + compiled + skipped (",variantCacheAndCompiledSum,") is not equal to the sum of remaining variants (",
820 |                 sum_variantCountinBuild,") in EditorLog. This could be related to existing known issue: Case 1389276"));
821 |             }
822 |         }
823 |         
824 |         private static ShaderItem GetOrCreateShaderItem(string shaderName)
825 |         {
826 |             int shaderItemId = SVL.shaderlist.FindIndex( o=> o.name == shaderName );
827 |             ShaderItem shaderItem;
828 |             if( shaderItemId == -1 )
829 |             {
830 |                 //Make new ShaderItem
831 |                 shaderItem = new ShaderItem();
832 |                 shaderItem.name = shaderName;
833 |                 SVL.shaderlist.Add(shaderItem);
834 |             }
835 |             else
836 |             {
837 |                 //Get existing ShaderItem
838 |                 shaderItem = SVL.shaderlist[shaderItemId];
839 |             }
840 | 
841 |             return shaderItem;
842 |         }
843 |     }
844 | }


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_BuildProcess.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 620060b51edb35e42b3c3f00f39847ee
 3 | MonoImporter:
 4 |   externalObjects: {}
 5 |   serializedVersion: 2
 6 |   defaultReferences: []
 7 |   executionOrder: 0
 8 |   icon: {instanceID: 0}
 9 |   userData: 
10 |   assetBundleName: 
11 |   assetBundleVariant: 
12 | 


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_ComputeProcess.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections.Generic;
  2 | using UnityEditor.Build;
  3 | using UnityEditor.Rendering;
  4 | using UnityEngine;
  5 | using UnityEngine.Rendering;
  6 | using UnityEditor;
  7 | 
  8 | namespace GfxQA.ShaderVariantTool
  9 | {
 10 |     class ShaderVariantTool_ComputePreprocess_Before : IPreprocessComputeShaders
 11 |     {
 12 |         public ShaderVariantTool_ComputePreprocess_Before()
 13 |         {
 14 |             SVL.ResetBuildList();  
 15 |         }
 16 | 
 17 |         public int callbackOrder { get { return -100; } }
 18 | 
 19 |         public void OnProcessComputeShader(ComputeShader shader, string kernelName, IList<ShaderCompilerData> data)
 20 |         {
 21 |             if (!SVL.logNextBuild) return;
 22 |             
 23 |             double timeSpent = EditorApplication.timeSinceStartup;
 24 |             
 25 |             //Log ShaderItem
 26 |             int shaderItemId = SVL.shaderlist.FindIndex( o=> o.name == shader.name );
 27 |             ShaderItem shaderItem;
 28 |             if( shaderItemId == -1 )
 29 |             {
 30 |                 //Make new ShaderItem
 31 |                 shaderItem = new ShaderItem();
 32 |                 shaderItem.name = shader.name;
 33 |                 shaderItem.isComputeShader = true;
 34 |                 shaderItem.assetPath = AssetDatabase.GetAssetPath(shader);
 35 |                 SVL.shaderlist.Add(shaderItem);
 36 |             }
 37 |             else
 38 |             {
 39 |                 //Get existing ShaderItem
 40 |                 shaderItem = SVL.shaderlist[shaderItemId];
 41 |             }
 42 | 
 43 |             //Log variant count
 44 |             shaderItem.count_variant_before += (uint)data.Count;
 45 | 
 46 |             //Go through all the variants
 47 |             for (int i = 0; i < data.Count; ++i)
 48 |             {
 49 |                 ShaderKeyword[] sk = data[i].shaderKeywordSet.GetShaderKeywords();
 50 |                 
 51 |                 //Construct a KeywordItem
 52 |                 if(sk.Length==0) //Default, all keywords are off
 53 |                 {
 54 |                     KeywordItem scv = new KeywordItem(shader,kernelName,data[i],new ShaderKeyword(),true);
 55 |                     shaderItem.SetMatchedKeywordItem(scv);
 56 |                 }
 57 |                 else //Non-default variant
 58 |                 {
 59 |                     bool variantIsDynamic = false;
 60 |                     for (int k = 0; k < sk.Length; ++k)
 61 |                     {
 62 |                         KeywordItem scv = new KeywordItem(shader,kernelName,data[i],sk[k],false);
 63 |                         shaderItem.SetMatchedKeywordItem(scv);
 64 | 
 65 |                         if( scv.isDynamic )
 66 |                         {
 67 |                             variantIsDynamic = true;
 68 |                         }
 69 |                     }
 70 |                     if(variantIsDynamic)
 71 |                     {
 72 |                         shaderItem.count_dynamicVariant_before++;
 73 |                     }
 74 |                 }
 75 |             }
 76 |             
 77 |             // Log time
 78 |             timeSpent = EditorApplication.timeSinceStartup - timeSpent;
 79 |             //Debug.Log("OnProcessComputeShader (Before) = "+Helper.TimeFormatString(timeSpent));
 80 |             SVL.timeSpentByTool += timeSpent;
 81 |         }
 82 |     }
 83 | 
 84 |     class ShaderVariantTool_ComputePreprocess_After : IPreprocessComputeShaders
 85 |     {
 86 |         public int callbackOrder { get { return 10; } }
 87 | 
 88 |         public void OnProcessComputeShader(ComputeShader shader, string kernelName, IList<ShaderCompilerData> data)
 89 |         {
 90 |             if (!SVL.logNextBuild) return;
 91 |             
 92 |             double timeSpent = EditorApplication.timeSinceStartup;
 93 |             
 94 |             //Get existing ShaderItem
 95 |             int shaderItemId = SVL.shaderlist.FindIndex( o=> o.name == shader.name );
 96 |             ShaderItem shaderItem = SVL.shaderlist[shaderItemId];
 97 | 
 98 |             //Log variant count
 99 |             shaderItem.count_variant_after += (uint)data.Count;
100 | 
101 |             //Go through all the variants
102 |             for (int i = 0; i < data.Count; ++i)
103 |             {
104 |                 ShaderKeyword[] sk = data[i].shaderKeywordSet.GetShaderKeywords();
105 |                 
106 |                 //Construct a KeywordItem
107 |                 if(sk.Length==0) //Default, all keywords are off
108 |                 {
109 |                     KeywordItem scv = new KeywordItem(shader,kernelName,data[i],new ShaderKeyword(),true);
110 |                     shaderItem.SetMatchedKeywordItemCount(scv);
111 |                 }
112 |                 else //Non-default variant
113 |                 {
114 |                     bool variantIsDynamic = false;
115 |                     for (int k = 0; k < sk.Length; ++k)
116 |                     {
117 |                         KeywordItem scv = new KeywordItem(shader,kernelName,data[i],sk[k],false);
118 |                         shaderItem.SetMatchedKeywordItemCount(scv);
119 |                         
120 |                         if( scv.isDynamic )
121 |                         {
122 |                             variantIsDynamic = true;
123 |                         }
124 |                     }
125 |                     if(variantIsDynamic)
126 |                     {
127 |                         shaderItem.count_dynamicVariant_after++;
128 |                     }
129 |                 }
130 |             }
131 |             
132 |             // Log time
133 |             timeSpent = EditorApplication.timeSinceStartup - timeSpent;
134 |             //Debug.Log("OnProcessComputeShader (After) = "+Helper.TimeFormatString(timeSpent));
135 |             SVL.timeSpentByTool += timeSpent;
136 |         }
137 |     }
138 | 
139 | }


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_ComputeProcess.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 47c09c5c2f9c24646ac00ffb49ef6cc5
 3 | MonoImporter:
 4 |   externalObjects: {}
 5 |   serializedVersion: 2
 6 |   defaultReferences: []
 7 |   executionOrder: 0
 8 |   icon: {instanceID: 0}
 9 |   userData: 
10 |   assetBundleName: 
11 |   assetBundleVariant: 
12 | 


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_Data.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections.Generic;
  2 | using UnityEditor.Rendering;
  3 | using UnityEngine;
  4 | using UnityEngine.Rendering;
  5 | using UnityEditor;
  6 | using System.Linq;
  7 | using System;
  8 | using System.Text.RegularExpressions;
  9 | 
 10 | namespace GfxQA.ShaderVariantTool
 11 | {
 12 |     
 13 |     //===================================================================================================
 14 | 
 15 |     public class ShaderProgram
 16 |     {
 17 |         public string gfxAPI = "";
 18 |         public uint count_internal = 0;
 19 |         public uint count_unique = 0;
 20 | 
 21 |         public ShaderProgram(string api, uint program_internal, uint program_unique)
 22 |         {
 23 |             gfxAPI = api;
 24 |             count_internal = program_internal;
 25 |             count_unique = program_unique;
 26 |         }
 27 |     }
 28 | 
 29 |     public class ShaderItem
 30 |     {
 31 |         public bool isComputeShader = false;
 32 |         public string name;
 33 |         public string assetPath = "";
 34 |         
 35 |         public uint count_variant_before = 0; //includes dynamic variants
 36 |         public uint count_dynamicVariant_before = 0;
 37 |         public uint count_variant_after = 0; //includes dynamic variants
 38 |         public uint count_dynamicVariant_after = 0;
 39 | 
 40 |         public UInt64 editorLog_variantOriginalCount = 0;
 41 |         public UInt64 editorLog_variantAfterPrefilteringCount = 0;
 42 |         public UInt64 editorLog_variantAfterBuiltinStrippingCount = 0;
 43 |         public UInt64 editorLog_variantAfterSciptableStrippingCount = 0;
 44 |         public UInt64 editorLog_variantMeshDataOptimizationCached = 0;
 45 |         public UInt64 editorLog_variantMeshDataOptimizationCompiled = 0;
 46 |         public uint editorLog_variantCompiledCount = 0;
 47 |         public uint editorLog_variantInCache = 0;
 48 |         public float editorLog_timeCompile = 0;
 49 |         public float editorLog_timeStripping = 0;
 50 |         
 51 |         public List<ShaderProgram> programs = new List<ShaderProgram>();
 52 | 
 53 |         public int FindMatchingProgramItem(ShaderProgram pgm)
 54 |         {
 55 |             //find the matching shader program
 56 |             int matchedId = programs.FindIndex
 57 |             ( e =>
 58 |                 e.gfxAPI == pgm.gfxAPI
 59 |             );
 60 | 
 61 |             return matchedId;
 62 |         }
 63 | 
 64 |         public List<KeywordItem> keywordItems = new List<KeywordItem>();
 65 |         public List<string> keywordItemsLookupString = new List<string>();
 66 |         
 67 |         private string GetKeywordItemsLookupString(KeywordItem scv)
 68 |         {
 69 |             return String.Concat(scv.shaderName, scv.passName, scv.passType, scv.shaderType, scv.kernelName, scv.graphicsTier, scv.buildTarget, scv.shaderCompilerPlatform, scv.platformKeywords, scv.shaderKeywordName, scv.shaderKeywordType);
 70 |         }
 71 | 
 72 |         public int FindMatchingVariantItem(KeywordItem scv)
 73 |         {
 74 |             int matchedId = keywordItemsLookupString.IndexOf(GetKeywordItemsLookupString(scv));
 75 |             return matchedId;
 76 |         }
 77 | 
 78 |         //Use in Preprocess_Before
 79 |         public void SetMatchedKeywordItem(KeywordItem scv)
 80 |         {
 81 |             int matchedID = FindMatchingVariantItem(scv);
 82 |             if(matchedID == -1)
 83 |             {
 84 |                 scv.appearCount_before++;
 85 |                 keywordItems.Add(scv);
 86 |                 keywordItemsLookupString.Add(GetKeywordItemsLookupString(scv));
 87 |             }
 88 |             else
 89 |             {
 90 |                 keywordItems[matchedID].appearCount_before ++;
 91 |             }
 92 |         }
 93 |         
 94 |         //Use in Preprocess_After
 95 |         public void SetMatchedKeywordItemCount(KeywordItem scv)
 96 |         {
 97 |             int matchedID = FindMatchingVariantItem(scv);
 98 |             keywordItems[matchedID].appearCount_after ++;
 99 |         }
100 |         
101 |         //Use in Build Postprocessor
102 |         public void SetKeywordDeclareType()
103 |         {
104 |             if(isComputeShader)
105 |             {
106 |                 //Not able to open this
107 |                 if(assetPath.EndsWith("unity_builtin_extra"))
108 |                 {
109 |                     foreach(KeywordItem item in keywordItems)
110 |                     {
111 |                         item.shaderKeywordDeclareType = "N/A for builtin resource";
112 |                     }
113 |                     return;
114 |                 }
115 | 
116 |                 //A list of keyword and type mapping
117 |                 Dictionary<string, string> keywordDeclareType = new Dictionary<string, string>();
118 | 
119 |                 //Read shader code and find the #pragma lines
120 |                 string shaderCode = System.IO.File.ReadAllText(assetPath);
121 |                 GetDirectPragmaKeywordType(shaderCode, ref keywordDeclareType);
122 | 
123 |                 //Read #include_with_pragmas lines as declare types are in seperate hlsl
124 |                 string pattern = @"#include_with_pragmas\s""(.*)""";
125 |                 MatchCollection matches = Regex.Matches(shaderCode, pattern);
126 |                 List<Match> matchesList = matches.ToList();
127 |                 foreach(Match m in matchesList)
128 |                 {
129 |                     //Read hlsl code and find the #pragma lines
130 |                     string hlslPath = m.Groups[1].Value;
131 |                     string hlslCode = System.IO.File.ReadAllText(hlslPath);
132 |                     GetDirectPragmaKeywordType(hlslCode, ref keywordDeclareType);
133 |                 }
134 | 
135 |                 //Match the mapping with keywords
136 |                 foreach(KeywordItem item in keywordItems)
137 |                 {
138 |                     string keyword = item.shaderKeywordName;
139 |                     item.shaderKeywordDeclareType = keywordDeclareType.FirstOrDefault(x => x.Key.Contains(keyword)).Value;
140 |                 }
141 |             }
142 |             else
143 |             {
144 |                 //A list of keyword and type mapping
145 |                 Dictionary<string, string> keywordDeclareType = new Dictionary<string, string>();
146 |             
147 |                 //Get the shader data
148 |                 var shader = Shader.Find(name);
149 |                 var shaderData = ShaderUtil.GetShaderData(shader);
150 |                 var subShader = shaderData.GetSubshader(0);
151 |                 for (int i = 0; i < subShader.PassCount; i++)
152 |                 {
153 |                     //Get source code
154 |                     var pass = subShader.GetPass(i);
155 |                     string shaderCode = pass.SourceCode;
156 |                 
157 |                     //Read shader code and find the #pragma lines
158 |                     GetDirectPragmaKeywordType(shaderCode, ref keywordDeclareType);
159 | 
160 |                     //Read #include_with_pragmas lines as declare types are in seperate hlsl
161 |                     string pattern = @"#include_with_pragmas\s""(.*)""";
162 |                     MatchCollection matches = Regex.Matches(shaderCode, pattern);
163 |                     List<Match> matchesList = matches.ToList();
164 |                     foreach(Match m in matchesList)
165 |                     {
166 |                         //Read hlsl code and find the #pragma lines
167 |                         string hlslPath = m.Groups[1].Value;
168 |                         string hlslCode = System.IO.File.ReadAllText(hlslPath);
169 |                         GetDirectPragmaKeywordType(hlslCode, ref keywordDeclareType);
170 |                     }
171 |                 }
172 |             
173 |                 //Match the mapping with keywords
174 |                 foreach(KeywordItem item in keywordItems)
175 |                 {
176 |                     string keyword = item.shaderKeywordName;
177 |                     item.shaderKeywordDeclareType = keywordDeclareType.FirstOrDefault(x => x.Key.Contains(keyword)).Value;
178 |                 }
179 |             }
180 |         }
181 | 
182 |         private void GetDirectPragmaKeywordType(string shaderCode, ref Dictionary<string, string> keywordDeclareType)
183 |         {
184 |             //Read shader code and find the #pragma lines
185 |             string pattern = @"#pragma\s(?!\btarget\b)(\w+)\s(\w.*)";
186 |             MatchCollection matches = Regex.Matches(shaderCode, pattern);
187 |             List<Match> matchesList = matches.ToList();
188 |             foreach(Match m in matchesList)
189 |             {
190 |                 string key = m.Groups[2].Value;
191 |                 if(!keywordDeclareType.ContainsKey(key))
192 |                 {
193 |                     keywordDeclareType.Add(key, m.Groups[1].Value);
194 |                 }
195 |             }
196 |         }
197 |     }
198 | 
199 |     //===================================================================================================
200 | 
201 |     public class KeywordItem
202 |     {
203 |         //shader
204 |         public string shaderName;
205 | 
206 |         //snippet
207 |         public string passType = "--";
208 |         public string passName = "--";
209 |         public string shaderType = "--";
210 | 
211 |         //compute kernel
212 |         public string kernelName = "--";
213 | 
214 |         //data
215 |         public string graphicsTier = "--";
216 |         public string buildTarget = "--"; 
217 |         public string shaderCompilerPlatform = "--";
218 | 
219 |         //data - PlatformKeywordSet
220 |         public string platformKeywords = "--";
221 | 
222 |         //data - ShaderKeywordSet
223 |         public string shaderKeywordName = "No Keyword / All Off";
224 |         public string shaderKeywordType = "--";
225 |         public string shaderKeywordDeclareType = "--";
226 |         public bool isDynamic = false;
227 | 
228 |         //how many times this variant appears in IPreprocessShaders
229 |         public int appearCount_before = 0;
230 |         public int appearCount_after = 0;
231 | 
232 |         //Constructor for normal shader
233 |         public KeywordItem(Shader shader, ShaderSnippetData snippet, ShaderCompilerData data, ShaderKeyword sk, bool defaultVariant)
234 |         {
235 |             shaderName = shader.name;
236 |             passName = snippet.passName;
237 |             passType = snippet.passType.ToString();
238 |             shaderType = snippet.shaderType.ToString();
239 |             graphicsTier = data.graphicsTier.ToString();
240 |             buildTarget = data.buildTarget.ToString();
241 |             shaderCompilerPlatform = data.shaderCompilerPlatform.ToString();
242 |             platformKeywords = Helper.GetPlatformKeywordList(data.platformKeywordSet);
243 | 
244 |             if(!defaultVariant)
245 |             {
246 |                 //shaderKeywordName
247 |                 LocalKeyword lkey = new LocalKeyword(shader,sk.name);
248 |                 isDynamic = lkey.isDynamic;
249 |                 shaderKeywordName = sk.name;
250 |                 
251 |                 //shaderKeywordType
252 |                 shaderKeywordType = ShaderKeyword.GetGlobalKeywordType(sk).ToString(); //""+sk[k].GetKeywordType().ToString();
253 |                 
254 |                 //Bug checking
255 |                 if( !sk.IsValid() )
256 |                 {
257 |                     Debug.LogError(String.Concat("ShaderVariantTool error #E06. Shader ",shaderName," Keyword ",shaderKeywordName," is invalid."));
258 |                 }
259 |                 if( !data.shaderKeywordSet.IsEnabled(sk) )
260 |                 {
261 |                     Debug.LogWarning(String.Concat("ShaderVariantTool error #E07. Shader ",shaderName," Keyword ",shaderKeywordName," is not enabled. You can create a custom shader stripping script to strip it."));
262 |                 }
263 |             }
264 |         }
265 | 
266 |         //Constructor for compute shader
267 |         public KeywordItem(ComputeShader shader, string kernelname, ShaderCompilerData data, ShaderKeyword sk, bool defaultVariant)
268 |         {
269 |             shaderName = shader.name;
270 |             kernelName = kernelname;
271 |             graphicsTier = data.graphicsTier.ToString();
272 |             buildTarget = data.buildTarget.ToString();
273 |             shaderCompilerPlatform = data.shaderCompilerPlatform.ToString();
274 |             platformKeywords = Helper.GetPlatformKeywordList(data.platformKeywordSet);
275 | 
276 |             if(!defaultVariant)
277 |             {
278 |                 //shaderKeywordName
279 |                 LocalKeyword lkey = new LocalKeyword(shader,sk.name);
280 |                 isDynamic = lkey.isDynamic;
281 |                 shaderKeywordName = sk.name;
282 |                 
283 |                 //shaderKeywordType
284 |                 shaderKeywordType = ShaderKeyword.GetGlobalKeywordType(sk).ToString(); //""+sk[k].GetKeywordType().ToString();
285 |                 
286 |                 //Bug checking
287 |                 if( !sk.IsValid() )
288 |                 {
289 |                     Debug.LogError(String.Concat("ShaderVariantTool error #E04. Shader ",shaderName," Keyword ",shaderKeywordName," is invalid."));
290 |                 }
291 |                 if( !data.shaderKeywordSet.IsEnabled(sk) )
292 |                 {
293 |                     Debug.LogWarning(String.Concat("ShaderVariantTool error #E05. Shader ",shaderName," Keyword ",shaderKeywordName," is not enabled. You can create a custom shader stripping script to strip it."));
294 |                 }
295 |             }
296 |         }
297 |     };
298 | }
299 | 


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_Data.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 8e5a8eee429a8214b8cac85b5fc760b7
 3 | MonoImporter:
 4 |   externalObjects: {}
 5 |   serializedVersion: 2
 6 |   defaultReferences: []
 7 |   executionOrder: 0
 8 |   icon: {instanceID: 0}
 9 |   userData: 
10 |   assetBundleName: 
11 |   assetBundleVariant: 
12 | 


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_Helper.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections;
  2 | using System.Collections.Generic;
  3 | using UnityEngine;
  4 | using UnityEngine.Rendering;
  5 | using System;
  6 | using System.IO;
  7 | using System.Globalization;
  8 | using System.Text;
  9 | using UnityEditor;
 10 | 
 11 | namespace GfxQA.ShaderVariantTool
 12 | {
 13 |     public static class Helper
 14 |     {
 15 |         public static string GetCSVFolderPath()
 16 |         {
 17 |             return Application.dataPath.Replace("/Assets","/");
 18 |         }
 19 | 
 20 | 
 21 |         private static string logNextBuildPopupPref = "ShaderVariantTool_LogNextBuildPopup";
 22 |         private static DialogOptOutDecisionType dialogOptOutDecisionType = DialogOptOutDecisionType.ForThisSession;
 23 |         public const string logNextBuildPref = "ShaderVariantTool_LogNextBuild";
 24 |         public static bool shouldUpdateLogNextBuildGUI = true;
 25 |         public static void LogNextBuildPopup()
 26 |         {
 27 |             if(EditorUtility.GetDialogOptOutDecision(dialogOptOutDecisionType, logNextBuildPopupPref)) return;
 28 |             
 29 |             string title = "ShaderVariantTool - Log next build?";
 30 |             string message = "If enabled, the tool lengthen shader stripping time. The impact will be listed on the tool under shader stripping time after building.\n\n" +
 31 |                              "You can also configure in Window > ShaderVariantTool > [Log Next Build].";
 32 |             bool enable = EditorUtility.DisplayDialog
 33 |             (
 34 |                 title,message,
 35 |                 "Enable",
 36 |                 "Disable",
 37 |                 dialogOptOutDecisionType,
 38 |                 logNextBuildPopupPref
 39 |             );
 40 |             
 41 |             SetLogNextBuild(enable);
 42 |         }
 43 |         
 44 |         public static void InitiateLogNextBuild()
 45 |         {
 46 |             if (!shouldUpdateLogNextBuildGUI) return;
 47 |             bool logPref = SessionState.GetBool(logNextBuildPref,true);
 48 |             SVL.logNextBuild = logPref;
 49 |             shouldUpdateLogNextBuildGUI = false;
 50 |         }
 51 |         
 52 |         public static void SetLogNextBuild(bool v)
 53 |         {
 54 |             SessionState.SetBool(logNextBuildPref, v);
 55 |             SVL.logNextBuild = v;
 56 |             shouldUpdateLogNextBuildGUI = true;
 57 |         }
 58 | 
 59 |         private static string culturePref = "ShaderVariantTool_Culture";
 60 |         public static CultureInfo culture;
 61 |         public static CultureInfo[] cinfo;
 62 |         public static void SetupCultureInfo()
 63 |         {
 64 |             if(cinfo == null) cinfo = CultureInfo.GetCultures(CultureTypes.AllCultures & ~CultureTypes.NeutralCultures);
 65 |             string cultureString = EditorPrefs.GetString(culturePref,"English (United States)");
 66 |             if(culture == null ) culture = GetCultureInfoWithName(cultureString);
 67 |         }
 68 | 
 69 |         private static CultureInfo GetCultureInfoWithName(string cultureString)
 70 |         {
 71 |             return Array.Find<CultureInfo>(cinfo, x => x.DisplayName == cultureString);
 72 |         }
 73 | 
 74 |         public static void UpdateCultureInfo(string displayName)
 75 |         {
 76 |             EditorPrefs.SetString(culturePref,displayName);
 77 |             culture = GetCultureInfoWithName(displayName);
 78 |         }
 79 | 
 80 |         public static string NumberSeperator(string input)
 81 |         {
 82 |             UInt64 outNum = 0;
 83 |             bool success = UInt64.TryParse(input, out outNum);
 84 |             if(success)
 85 |             {
 86 |                 return outNum.ToString("N0", culture);
 87 |             }
 88 |             else
 89 |             {
 90 |                 return input;
 91 |             }
 92 |         }
 93 | 
 94 |         public static string TimeFormatString (double timeInSeconds)
 95 |         {
 96 |             SetupCultureInfo();
 97 | 
 98 |             float t = (float)timeInSeconds;
 99 | 
100 |             float hour = t / 3600f;
101 |             hour = Mathf.Floor(hour);
102 |             t -= hour*3600f;
103 | 
104 |             float minute = t / 60f;
105 |             minute = Mathf.Floor(minute);
106 |             t -= minute*60f;
107 | 
108 |             float second = t;
109 |             string secondString = minute > 0 ? Mathf.RoundToInt(second).ToString() : second.ToString("0.00");
110 | 
111 |             StringBuilder timeString = new StringBuilder();
112 |             if(hour > 0) timeString.Append(String.Concat(hour , "hr "));
113 |             if(minute > 0) timeString.Append(String.Concat(minute , "m "));
114 |             timeString.Append(string.Concat(NumberSeperator(secondString) , "s"));
115 | 
116 |             return timeString.ToString();
117 |         }
118 | 
119 |         public static string GetRemainingString(string line, string from)
120 |         {
121 |             int index = line.IndexOf(from) + from.Length;
122 |             return line.Substring( index , line.Length - index);
123 |         }
124 | 
125 |         public static string ExtractString(string line, string from, string to, bool takeLastIndexOfTo = true)
126 |         {
127 |             int pFrom = 0;
128 |             if(from != "")
129 |             {
130 |                 int index = line.IndexOf(from);
131 |                 if(index >= 0) pFrom = index + from.Length;
132 |             }
133 |             
134 |             int pTo = line.Length;
135 |             if(to != "")
136 |             {
137 |                 int index = line.LastIndexOf(to);
138 |                 if(!takeLastIndexOfTo)
139 |                 {
140 |                     index = line.IndexOf(to);
141 |                 }
142 | 
143 |                 if(index >= 0) pTo = index;
144 |             }
145 | 
146 |             return line.Substring(pFrom, pTo - pFrom);
147 |         }
148 | 
149 |         public static void DebugLog(string msg)
150 |         {
151 |             Debug.LogFormat(LogType.Log, LogOption.NoStacktrace, null, msg);
152 |         }
153 | 
154 |         public static string GetPlatformKeywordList(PlatformKeywordSet pks)
155 |         {
156 |             StringBuilder enabledPKeys = new StringBuilder();
157 |             foreach(BuiltinShaderDefine sd in System.Enum.GetValues(typeof(BuiltinShaderDefine))) 
158 |             {
159 |                 //Only pay attention to SHADER_API_MOBILE, SHADER_API_DESKTOP and SHADER_API_GLES30
160 |                 if( sd.ToString().Contains("SHADER_API") && pks.IsEnabled(sd) )
161 |                 {
162 |                     if(enabledPKeys.Length>0) enabledPKeys.Append(" ");
163 |                     enabledPKeys.Append(sd.ToString());
164 |                 }
165 |             }
166 |             return enabledPKeys.ToString();
167 |         }
168 | 
169 |         public static string GetEditorLogPath()
170 |         {
171 |             string editorLogPath = "";
172 |             switch(Application.platform)
173 |             {
174 |                 case RuntimePlatform.WindowsEditor: editorLogPath=String.Concat(Environment.GetEnvironmentVariable("AppData").Replace("Roaming",""),"Local\\Unity\\Editor\\Editor.log"); break;
175 |                 case RuntimePlatform.OSXEditor: editorLogPath=String.Concat(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), "Library"),"/Logs/Unity/Editor.log"); break;
176 |                 case RuntimePlatform.LinuxEditor: editorLogPath="~/.config/unity3d/Editor.log"; break;
177 |             }
178 |             return editorLogPath;
179 |         }
180 |     }
181 | }


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_Helper.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: bbf37ef3f79c01147bdc359aab813889
 3 | MonoImporter:
 4 |   externalObjects: {}
 5 |   serializedVersion: 2
 6 |   defaultReferences: []
 7 |   executionOrder: 0
 8 |   icon: {instanceID: 0}
 9 |   userData: 
10 |   assetBundleName: 
11 |   assetBundleVariant: 
12 | 


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_LogReader.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using UnityEditor;
  3 | using UnityEngine;
  4 | using System.IO;
  5 | using System.Linq;
  6 | using System.Collections.Generic;
  7 | using System.Globalization;
  8 | 
  9 | namespace GfxQA.ShaderVariantTool
 10 | {
 11 |     public class ShaderVariantTool_LogReader : EditorWindow
 12 |     {
 13 |         private List<string> timeStamps;
 14 |         private int selectedTimeStamp = 0;
 15 |         private string editorLogPath = "";
 16 |         private string savedFile = "";
 17 |         private CultureInfo culture = new CultureInfo("is-IS");
 18 | 
 19 |         [MenuItem("Window/ShaderVariantTool_LogReader")]
 20 |         public static void ShowWindow ()
 21 |         {
 22 |             var window = EditorWindow.GetWindow (typeof(ShaderVariantTool_LogReader));
 23 |             window.name = "ShaderVariantTool LogReader";
 24 |             window.titleContent = new GUIContent("ShaderVariantTool LogReader");
 25 |         }
 26 | 
 27 |         public void Awake()
 28 |         {
 29 |             editorLogPath = Helper.GetEditorLogPath();
 30 |         }
 31 | 
 32 |         private void UpdateTimeStampList()
 33 |         {
 34 |             timeStamps = new List<string>();
 35 |             FileStream fs = new FileStream(editorLogPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
 36 |             using (StreamReader sr = new StreamReader(fs))
 37 |             {
 38 |                 string line;
 39 |                 while ((line = sr.ReadLine()) != null)
 40 |                 {
 41 |                     if(line.Contains(SVL.buildProcessIDTitleStart))
 42 |                     {
 43 |                         timeStamps.Add(line);
 44 |                     }
 45 |                 }
 46 |             }
 47 |         }
 48 | 
 49 |         // public void OnDestroy()
 50 |         // {
 51 |         // }
 52 | 
 53 |         void OnGUI () 
 54 |         {
 55 |             Color originalBackgroundColor = GUI.backgroundColor;
 56 | 
 57 |             //Width for the columns & style
 58 |             float currentSize = this.position.width;
 59 |             GUIStyle background = new GUIStyle 
 60 |             { 
 61 |                 normal = 
 62 |                 { 
 63 |                     background = Texture2D.whiteTexture,
 64 |                     textColor = Color.white
 65 |                 } 
 66 |             };
 67 | 
 68 |             //Title
 69 |             GUI.color = Color.cyan;
 70 |             GUILayout.Label ("This log reader is for reading previous builds, which only reads information about variant count before/after stripping per shader. \n"+"Therefore detailed shader keywords and compute shader information is not available. So please only use this if the original ShaderVariantTool doesn't work.", EditorStyles.wordWrappedLabel);
 71 |             GUILayout.Space(10);
 72 |             GUI.color = Color.white;
 73 | 
 74 |             //Editor.Log path textbox
 75 |             editorLogPath = GUILayout.TextField(editorLogPath);
 76 | 
 77 |             //TimeStamp select: drop down and a button to update drop down
 78 |             if(timeStamps== null) UpdateTimeStampList();
 79 |             selectedTimeStamp = EditorGUILayout.Popup("Select timestamp", selectedTimeStamp, timeStamps.ToArray());
 80 |             if (GUILayout.Button ("Update TimeStampList",GUILayout.Width(200)))
 81 |             {
 82 |                 UpdateTimeStampList();
 83 |             }
 84 | 
 85 |             //Read log and save the CSV file
 86 |             if (GUILayout.Button ("Read log",GUILayout.Width(200)))
 87 |             {
 88 |                 //Write File
 89 |                 List<string[]> outputRows = ShaderVariantTool_BuildPostprocess.WriteCSVFile(null,editorLogPath,timeStamps[selectedTimeStamp]);
 90 | 
 91 |                 //Save File
 92 |                 string fileName = "ShaderVariant_ReadLog_"+timeStamps[selectedTimeStamp].Replace(SVL.buildProcessIDTitleStart,"");
 93 |                 savedFile = ShaderVariantTool_BuildPostprocess.SaveCSVFile(outputRows, fileName);
 94 |                 Debug.Log("ShaderVariantTool_LogReader has generated CSV report at: "+savedFile);
 95 | 
 96 |                 //CleanUp
 97 |                 outputRows.Clear();
 98 |             }
 99 | 
100 |             //Display CSV generation result
101 |             if(savedFile != "")
102 |             {
103 |                 //Saved file path
104 |                 GUI.color = Color.green;
105 |                 GUILayout.Label ( "Saved: "+savedFile, EditorStyles.wordWrappedLabel);
106 |             }
107 | 
108 |             //End Window
109 |             GUILayout.FlexibleSpace();
110 |             EditorGUILayout.Separator();
111 |         }
112 |     }
113 | }
114 | 


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_LogReader.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 455b50a99bf6ba14a86df3528f4f1256
 3 | MonoImporter:
 4 |   externalObjects: {}
 5 |   serializedVersion: 2
 6 |   defaultReferences: []
 7 |   executionOrder: 0
 8 |   icon: {instanceID: 0}
 9 |   userData: 
10 |   assetBundleName: 
11 |   assetBundleVariant: 
12 | 


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_ShaderProcess.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections.Generic;
  2 | using UnityEditor.Build;
  3 | using UnityEditor.Rendering;
  4 | using UnityEngine;
  5 | using UnityEngine.Rendering;
  6 | using UnityEditor;
  7 | using System.IO;
  8 | 
  9 | 
 10 | namespace GfxQA.ShaderVariantTool
 11 | {
 12 |     class ShaderVariantTool_ShaderPreprocess_Before : IPreprocessShaders
 13 |     {
 14 |         public ShaderVariantTool_ShaderPreprocess_Before()
 15 |         {
 16 |             SVL.ResetBuildList();
 17 |         }
 18 | 
 19 |         public int callbackOrder { get { return -100; } }
 20 | 
 21 |         public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList<ShaderCompilerData> data)
 22 |         {
 23 |             if (!SVL.logNextBuild) return;
 24 |             
 25 |             double timeSpent = EditorApplication.timeSinceStartup;
 26 |             
 27 |             //Log ShaderItem
 28 |             int shaderItemId = SVL.shaderlist.FindIndex( o=> o.name == shader.name );
 29 |             ShaderItem shaderItem;
 30 |             if( shaderItemId == -1 )
 31 |             {
 32 |                 //Make new ShaderItem
 33 |                 shaderItem = new ShaderItem();
 34 |                 shaderItem.name = shader.name;
 35 |                 shaderItem.assetPath = AssetDatabase.GetAssetPath(shader);
 36 |                 SVL.shaderlist.Add(shaderItem);
 37 |             }
 38 |             else
 39 |             {
 40 |                 //Get existing ShaderItem
 41 |                 shaderItem = SVL.shaderlist[shaderItemId];
 42 |             }
 43 | 
 44 |             //Log variant count
 45 |             shaderItem.count_variant_before += (uint)data.Count;
 46 | 
 47 |             //Go through all the variants
 48 |             for (int i = 0; i < data.Count; ++i)
 49 |             {
 50 |                 ShaderKeyword[] sk = data[i].shaderKeywordSet.GetShaderKeywords();
 51 |                 
 52 |                 //Construct a KeywordItem
 53 |                 if(sk.Length==0) //Default, all keywords are off
 54 |                 {
 55 |                     KeywordItem scv = new KeywordItem(shader,snippet,data[i],new ShaderKeyword(),true);
 56 |                     shaderItem.SetMatchedKeywordItem(scv);
 57 |                 }
 58 |                 else //Non-default variant
 59 |                 {
 60 |                     bool variantIsDynamic = false;
 61 |                     for (int k = 0; k < sk.Length; ++k)
 62 |                     {
 63 |                         KeywordItem scv = new KeywordItem(shader,snippet,data[i],sk[k],false);
 64 |                         shaderItem.SetMatchedKeywordItem(scv);
 65 | 
 66 |                         if( scv.isDynamic )
 67 |                         {
 68 |                             variantIsDynamic = true;
 69 |                         }
 70 |                     }
 71 |                     if(variantIsDynamic)
 72 |                     {
 73 |                         shaderItem.count_dynamicVariant_before++;
 74 |                     }
 75 |                 }
 76 |             }
 77 |             
 78 |             // Log time
 79 |             timeSpent = EditorApplication.timeSinceStartup - timeSpent;
 80 |             //Debug.Log("OnProcessShader (Before) = "+Helper.TimeFormatString(timeSpent));
 81 |             SVL.timeSpentByTool += timeSpent;
 82 |         }
 83 |     }
 84 | 
 85 |     class ShaderVariantTool_ShaderPreprocess_After : IPreprocessShaders
 86 |     {
 87 |         public int callbackOrder { get { return 10; } }
 88 | 
 89 |         public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList<ShaderCompilerData> data)
 90 |         {
 91 |             if (!SVL.logNextBuild) return;
 92 |             
 93 |             double timeSpent = EditorApplication.timeSinceStartup;
 94 |             
 95 |             //Get existing ShaderItem
 96 |             int shaderItemId = SVL.shaderlist.FindIndex( o=> o.name == shader.name );
 97 |             ShaderItem shaderItem = SVL.shaderlist[shaderItemId];
 98 | 
 99 |             //Log variant count
100 |             shaderItem.count_variant_after += (uint)data.Count;
101 | 
102 |             //Go through all the variants
103 |             for (int i = 0; i < data.Count; ++i)
104 |             {
105 |                 ShaderKeyword[] sk = data[i].shaderKeywordSet.GetShaderKeywords();
106 |                 
107 |                 //Construct a KeywordItem
108 |                 if(sk.Length==0) //Default, all keywords are off
109 |                 {
110 |                     KeywordItem scv = new KeywordItem(shader,snippet,data[i],new ShaderKeyword(),true);
111 |                     shaderItem.SetMatchedKeywordItemCount(scv);
112 |                 }
113 |                 else //Non-default variant
114 |                 {
115 |                     bool variantIsDynamic = false;
116 |                     for (int k = 0; k < sk.Length; ++k)
117 |                     {
118 |                         KeywordItem scv = new KeywordItem(shader,snippet,data[i],sk[k],false);
119 |                         shaderItem.SetMatchedKeywordItemCount(scv);
120 | 
121 |                         if( scv.isDynamic )
122 |                         {
123 |                             variantIsDynamic = true;
124 |                         }
125 |                     }
126 |                     if(variantIsDynamic)
127 |                     {
128 |                         shaderItem.count_dynamicVariant_after++;
129 |                     }
130 |                 }
131 |             }
132 |             
133 |             // Log time
134 |             timeSpent = EditorApplication.timeSinceStartup - timeSpent;
135 |             //Debug.Log("OnProcessShader (After) = "+Helper.TimeFormatString(timeSpent));
136 |             SVL.timeSpentByTool += timeSpent;
137 |         }
138 | 
139 |     }
140 | 
141 | }


--------------------------------------------------------------------------------
/Editor/ShaderVariantTool_ShaderProcess.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 4d6a0af63dedd2a4cb384cf1d4fddf74
 3 | MonoImporter:
 4 |   externalObjects: {}
 5 |   serializedVersion: 2
 6 |   defaultReferences: []
 7 |   executionOrder: 0
 8 |   icon: {instanceID: 0}
 9 |   userData: 
10 |   assetBundleName: 
11 |   assetBundleVariant: 
12 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2023 mingwai
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/LICENSE.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: a68ccdf2e8dac604fa3eb56e5870f6e1
3 | DefaultImporter:
4 |   externalObjects: {}
5 |   userData: 
6 |   assetBundleName: 
7 |   assetBundleVariant: 
8 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ShaderVariantTool
 2 | This tool lists out all shader keywords and variant counts that are being included in player build and before stripping. \
 3 | Expand a shader and see it's keyword table. e.g. If a shader keyword is being completely stripped, the Comiled Count for that keyword should be 0 in the after scriptable stripping column.
 4 | 
 5 | ### How to install:
 6 | 1. On Unity Editor > Window > Package Manager
 7 | 2. On top left, click "+"
 8 | 3. Select "Add package from git URL..."
 9 | 4. Copy and paste:
10 |    - For Unity **2023.3.0b2+**: `https://github.com/cinight/ShaderVariantTool.git`
11 |    - For Unity **2022.2.6f1+**: `https://github.com/cinight/ShaderVariantTool.git#2022.2`
12 |    - For Unity **2021.3.18f1+**: `https://github.com/cinight/ShaderVariantTool.git#2021.3`
13 | 5. Click Add
14 | 6. OR you can edit Packages/manifest.json and add <br>`"com.cinight.shader-variant-tool": "https://github.com/cinight/ShaderVariantTool.git",`
15 | 
16 | ### How to use:
17 | 1. Make a player build
18 | 2. Top menu > Windows > ShaderVariantTool
19 | Note: The tool also generates a .csv file under the project root folder. \
20 | It contains more information and it's useful for keeping a record.
21 | \
22 | \
23 | ![](README01.jpg)
24 | 
25 | ### FAQ:
26 | 1. What is Compiled Count?
27 |    - Each entry on the tool = each keyword in a shader snippet before / after scriptable stripping.
28 |    - The column "Complied Count" = how many variants in that snippet contain this keyword.
29 | 2. Shouldn't the tool show all the keywords in every individual variant?
30 |    - In most of my use case, I care more about what keywords are being included (i.e. not stripped) in the build, instead of individual variant, which the keyword list for each variant could be too many/long to look at.
31 |    - If you do need the detailed variant list, use [Project Auditor](https://github.com/Unity-Technologies/ProjectAuditor/blob/master/Documentation~/Installing.md#package-manager-ui-recommended)
32 | 3. What are internal / unique program count?
33 |    - internal count = shader variants that are serialized in the player. This count should be equals to the shader variant count after scriptable-stripping. If not, it means a shader has error and thus the problematic shader variant will be skipped.
34 |    - unique count = deduplicated shader variants after shader compilation
35 | 4. Please note that for XR there might be more variants added after compilation so the original shader variant count might be less than the shader variant counts after stripping.
36 | 


--------------------------------------------------------------------------------
/README.md.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 5be97fd38b3fd35499e1e15daec528e5
3 | TextScriptImporter:
4 |   externalObjects: {}
5 |   userData: 
6 |   assetBundleName: 
7 |   assetBundleVariant: 
8 | 


--------------------------------------------------------------------------------
/README01.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cinight/ShaderVariantTool/998ddf51b36ccba053ff7e7af4f7a470a59259ac/README01.jpg


--------------------------------------------------------------------------------
/README01.jpg.meta:
--------------------------------------------------------------------------------
  1 | fileFormatVersion: 2
  2 | guid: e1abec2642d915047ac0fe901d9a32ad
  3 | TextureImporter:
  4 |   internalIDToNameTable: []
  5 |   externalObjects: {}
  6 |   serializedVersion: 12
  7 |   mipmaps:
  8 |     mipMapMode: 0
  9 |     enableMipMap: 1
 10 |     sRGBTexture: 1
 11 |     linearTexture: 0
 12 |     fadeOut: 0
 13 |     borderMipMap: 0
 14 |     mipMapsPreserveCoverage: 0
 15 |     alphaTestReferenceValue: 0.5
 16 |     mipMapFadeDistanceStart: 1
 17 |     mipMapFadeDistanceEnd: 3
 18 |   bumpmap:
 19 |     convertToNormalMap: 0
 20 |     externalNormalMap: 0
 21 |     heightScale: 0.25
 22 |     normalMapFilter: 0
 23 |     flipGreenChannel: 0
 24 |   isReadable: 0
 25 |   streamingMipmaps: 0
 26 |   streamingMipmapsPriority: 0
 27 |   vTOnly: 0
 28 |   ignoreMipmapLimit: 0
 29 |   grayScaleToAlpha: 0
 30 |   generateCubemap: 6
 31 |   cubemapConvolution: 0
 32 |   seamlessCubemap: 0
 33 |   textureFormat: 1
 34 |   maxTextureSize: 2048
 35 |   textureSettings:
 36 |     serializedVersion: 2
 37 |     filterMode: 1
 38 |     aniso: 1
 39 |     mipBias: 0
 40 |     wrapU: 0
 41 |     wrapV: 0
 42 |     wrapW: 0
 43 |   nPOTScale: 1
 44 |   lightmap: 0
 45 |   compressionQuality: 50
 46 |   spriteMode: 0
 47 |   spriteExtrude: 1
 48 |   spriteMeshType: 1
 49 |   alignment: 0
 50 |   spritePivot: {x: 0.5, y: 0.5}
 51 |   spritePixelsToUnits: 100
 52 |   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
 53 |   spriteGenerateFallbackPhysicsShape: 1
 54 |   alphaUsage: 1
 55 |   alphaIsTransparency: 0
 56 |   spriteTessellationDetail: -1
 57 |   textureType: 0
 58 |   textureShape: 1
 59 |   singleChannelComponent: 0
 60 |   flipbookRows: 1
 61 |   flipbookColumns: 1
 62 |   maxTextureSizeSet: 0
 63 |   compressionQualitySet: 0
 64 |   textureFormatSet: 0
 65 |   ignorePngGamma: 0
 66 |   applyGammaDecoding: 0
 67 |   swizzle: 50462976
 68 |   cookieLightType: 0
 69 |   platformSettings:
 70 |   - serializedVersion: 3
 71 |     buildTarget: DefaultTexturePlatform
 72 |     maxTextureSize: 2048
 73 |     resizeAlgorithm: 0
 74 |     textureFormat: -1
 75 |     textureCompression: 1
 76 |     compressionQuality: 50
 77 |     crunchedCompression: 0
 78 |     allowsAlphaSplitting: 0
 79 |     overridden: 0
 80 |     androidETC2FallbackOverride: 0
 81 |     forceMaximumCompressionQuality_BC6H_BC7: 0
 82 |   - serializedVersion: 3
 83 |     buildTarget: Standalone
 84 |     maxTextureSize: 2048
 85 |     resizeAlgorithm: 0
 86 |     textureFormat: -1
 87 |     textureCompression: 1
 88 |     compressionQuality: 50
 89 |     crunchedCompression: 0
 90 |     allowsAlphaSplitting: 0
 91 |     overridden: 0
 92 |     androidETC2FallbackOverride: 0
 93 |     forceMaximumCompressionQuality_BC6H_BC7: 0
 94 |   - serializedVersion: 3
 95 |     buildTarget: Server
 96 |     maxTextureSize: 2048
 97 |     resizeAlgorithm: 0
 98 |     textureFormat: -1
 99 |     textureCompression: 1
100 |     compressionQuality: 50
101 |     crunchedCompression: 0
102 |     allowsAlphaSplitting: 0
103 |     overridden: 0
104 |     androidETC2FallbackOverride: 0
105 |     forceMaximumCompressionQuality_BC6H_BC7: 0
106 |   - serializedVersion: 3
107 |     buildTarget: Android
108 |     maxTextureSize: 2048
109 |     resizeAlgorithm: 0
110 |     textureFormat: -1
111 |     textureCompression: 1
112 |     compressionQuality: 50
113 |     crunchedCompression: 0
114 |     allowsAlphaSplitting: 0
115 |     overridden: 0
116 |     androidETC2FallbackOverride: 0
117 |     forceMaximumCompressionQuality_BC6H_BC7: 0
118 |   spriteSheet:
119 |     serializedVersion: 2
120 |     sprites: []
121 |     outline: []
122 |     physicsShape: []
123 |     bones: []
124 |     spriteID: 
125 |     internalID: 0
126 |     vertices: []
127 |     indices: 
128 |     edges: []
129 |     weights: []
130 |     secondaryTextures: []
131 |     nameFileIdTable: {}
132 |   mipmapLimitGroupName: 
133 |   pSDRemoveMatte: 0
134 |   userData: 
135 |   assetBundleName: 
136 |   assetBundleVariant: 
137 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "com.cinight.shader-variant-tool",
 3 |   "version": "1.0.0",
 4 |   "description": "ShaderVariantTool lists out all shader keywords and variant counts that are being included in player build and before stripping.",
 5 |   "displayName": "ShaderVariantTool",
 6 |   "unity": "2022.2",
 7 |   "unityRelease": "6f1",
 8 |   "author": {
 9 |     "name": "mingwai"
10 |   },
11 |   "repository": {
12 |     "type": "git",
13 |     "url": "https://github.com/cinight/ShaderVariantTool"
14 |   }
15 | }


--------------------------------------------------------------------------------
/package.json.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 48dcbfbbb7e3f9447beb914c7664f5fb
3 | PackageManifestImporter:
4 |   externalObjects: {}
5 |   userData: 
6 |   assetBundleName: 
7 |   assetBundleVariant: 
8 | 


--------------------------------------------------------------------------------