Added new shader keyword features

francis-page · francis-page · commit f55ac384bb65 · 2022-10-12T11:03:14.000-04:00
diff --git a/Analyzer/Processors/ShaderProcessor.cs b/Analyzer/Processors/ShaderProcessor.cs
@@ -12,11 +12,15 @@ public class ShaderProcessor : IProcessor, IDisposable
     {
         SQLiteCommand m_InsertCommand;
         SQLiteCommand m_InsertSubProgramCommand;
+        SQLiteCommand m_InsertKeywordCommand;
+        SQLiteCommand m_InsertSubProgramKeywordsCommand;
 
-        Dictionary<int, string> m_KeywordNames = new Dictionary<int, string>();
-        StringBuilder m_Keywords = new StringBuilder();
-        HashSet<string> m_UniqueKeywords = new HashSet<string>();
-        HashSet<uint> m_UniquePrograms = new HashSet<uint>();
+        List<int> m_Keywords = new();
+        Dictionary<int, string> m_KeywordNames = new();
+        HashSet<uint> m_UniquePrograms = new();
+
+        static Dictionary<string, int> s_Keywords = new();
+        static long s_SubProgramId = 0;
 
         static readonly List<(string fieldName, string typeName)> s_progTypes = new()
         {
@@ -36,37 +40,43 @@ public void Init(SQLiteConnection db)
             command.ExecuteNonQuery();
 
             m_InsertCommand = new SQLiteCommand(db);
-            m_InsertCommand.CommandText = "INSERT INTO shaders(id, decompressed_size, sub_shaders, unique_programs, keywords) VALUES(@id, @decompressed_size, @sub_shaders, @unique_programs, @keywords)";
+            m_InsertCommand.CommandText = "INSERT INTO shaders(id, decompressed_size, unique_programs) VALUES(@id, @decompressed_size, @unique_programs)";
             m_InsertCommand.Parameters.Add("@id", DbType.Int64);
             m_InsertCommand.Parameters.Add("@decompressed_size", DbType.Int32);
-            m_InsertCommand.Parameters.Add("@sub_shaders", DbType.Int32);
             m_InsertCommand.Parameters.Add("@unique_programs", DbType.Int32);
-            m_InsertCommand.Parameters.Add("@keywords", DbType.String);
 
             m_InsertSubProgramCommand = new SQLiteCommand(db);
-            m_InsertSubProgramCommand.CommandText = "INSERT INTO shader_subprograms(shader, pass, sub_program, hw_tier, shader_type, api, keywords) VALUES(@shader, @pass, @sub_program, @hw_tier, @shader_type, @api, @keywords)";
+            m_InsertSubProgramCommand.CommandText = "INSERT INTO shader_subprograms(shader, sub_shader, pass, pass_name, sub_program, hw_tier, shader_type, api) VALUES(@shader, @sub_shader, @pass, @pass_name, @sub_program, @hw_tier, @shader_type, @api)";
+            m_InsertSubProgramCommand.Parameters.Add("@id", DbType.Int64);
             m_InsertSubProgramCommand.Parameters.Add("@shader", DbType.Int64);
+            m_InsertSubProgramCommand.Parameters.Add("@sub_shader", DbType.Int32);
             m_InsertSubProgramCommand.Parameters.Add("@pass", DbType.Int32);
+            m_InsertSubProgramCommand.Parameters.Add("@pass_name", DbType.String);
             m_InsertSubProgramCommand.Parameters.Add("@sub_program", DbType.Int32);
             m_InsertSubProgramCommand.Parameters.Add("@hw_tier", DbType.Int32);
             m_InsertSubProgramCommand.Parameters.Add("@shader_type", DbType.String);
             m_InsertSubProgramCommand.Parameters.Add("@api", DbType.Int32);
-            m_InsertSubProgramCommand.Parameters.Add("@keywords", DbType.String);
+
+            m_InsertKeywordCommand = new SQLiteCommand(db);
+            m_InsertKeywordCommand.CommandText = "INSERT INTO shader_keywords(id, keyword) VALUES(@id, @keyword)";
+            m_InsertKeywordCommand.Parameters.Add("@id", DbType.Int32);
+            m_InsertKeywordCommand.Parameters.Add("@keyword", DbType.String);
+
+            m_InsertSubProgramKeywordsCommand = new SQLiteCommand(db);
+            m_InsertSubProgramKeywordsCommand.CommandText = "INSERT INTO shader_subprogram_keywords(subprogram_id, keyword_id) VALUES (@subprogram_id, @keyword_id)";
+            m_InsertSubProgramKeywordsCommand.Parameters.Add("@subprogram_id", DbType.Int64);
+            m_InsertSubProgramKeywordsCommand.Parameters.Add("@keyword_id", DbType.Int32);
         }
 
         public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> localToDbFileId, RandomAccessReader reader, out string name, out long streamedDataSize)
         {
-            int currentProgram = 0;
-
             streamedDataSize = 0;
 
-            m_UniqueKeywords.Clear();
             m_UniquePrograms.Clear();
 
             var parsedForm = reader["m_ParsedForm"];
 
             m_InsertCommand.Parameters["@id"].Value = objectId;
-            m_InsertCommand.Parameters["@sub_shaders"].Value = parsedForm["m_SubShaders"].GetArraySize();
 
             // Starting in some Unity 2021 version, keyword names are stored in m_KeywordNames.
             bool keywordsUnity2021 = false;
@@ -84,10 +94,13 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l
                 }
             }
 
+            int subShaderNum = 0;
             foreach (var subShader in parsedForm["m_SubShaders"])
             {
                 int passNum = 0;
 
+                m_InsertSubProgramCommand.Parameters["@sub_shader"].Value = subShaderNum++;
+
                 foreach (var pass in subShader["m_Passes"])
                 {
                     if (!keywordsUnity2021)
@@ -102,6 +115,16 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l
                         }
                     }
 
+                    string passName = "";
+                    if (pass.HasChild("m_State"))
+                    {
+                        passName = pass["m_State"]["m_Name"].GetValue<string>();
+                    }
+
+                    m_InsertSubProgramCommand.Parameters["@shader"].Value = objectId;
+                    m_InsertSubProgramCommand.Parameters["@pass"].Value = passNum;
+                    m_InsertSubProgramCommand.Parameters["@pass_name"].Value = passName;
+
                     foreach (var progType in s_progTypes)
                     {
                         if (!pass.HasChild(progType.fieldName))
@@ -111,6 +134,8 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l
 
                         var program = pass[progType.fieldName];
 
+                        m_InsertSubProgramCommand.Parameters["@shader_type"].Value = progType.typeName;
+
                         // Sarting in some Unity 2021.3 version, programs are stored in m_PlayerSubPrograms instead of m_SubPrograms.
                         if (program.HasChild("m_PlayerSubPrograms"))
                         {
@@ -119,12 +144,12 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l
                             // And they are stored per hardware tiers.
                             foreach (var tierProgram in program["m_PlayerSubPrograms"])
                             {
-                                ProcessProgram(objectId, passNum, ref currentProgram, tierProgram, progType.typeName, hwTier++);
+                                ProcessProgram(tierProgram, hwTier++);
                             }
                         }
                         else
                         {
-                            ProcessProgram(objectId, passNum, ref currentProgram, program["m_SubPrograms"], progType.typeName);
+                            ProcessProgram(program["m_SubPrograms"]);
                         }
                     }
 
@@ -136,7 +161,7 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l
 
             if (!reader["decompressedLengths"].TypeTreeNode.Children[1].IsLeaf)
             {
-                // The decompressed lengths are now stored per graphics API.
+                // The decompressed lengths are stored per graphics API.
                 foreach (var apiLengths in reader["decompressedLengths"])
                 {
                     foreach (var blockSize in apiLengths.GetValue<int[]>())
@@ -156,20 +181,15 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l
                 }
             }
 
-            m_Keywords.Clear();
-            m_Keywords.AppendJoin(' ', m_UniqueKeywords);
-
             m_InsertCommand.Parameters["@id"].Value = objectId;
             m_InsertCommand.Parameters["@decompressed_size"].Value = decompressedSize;
-            m_InsertCommand.Parameters["@sub_shaders"].Value = parsedForm["m_SubShaders"].GetArraySize();
             m_InsertCommand.Parameters["@unique_programs"].Value = m_UniquePrograms.Count;
-            m_InsertCommand.Parameters["@keywords"].Value = m_Keywords.ToString();
             m_InsertCommand.ExecuteNonQuery();
 
             name = parsedForm["m_Name"].GetValue<string>();
         }
 
-        void ProcessProgram(long objectId, int passNum, ref int currentProgram, RandomAccessReader subPrograms, string shaderType, int hwTier = -1)
+        void ProcessProgram(RandomAccessReader subPrograms, int hwTier = -1)
         {
             int progNum = 0;
 
@@ -187,9 +207,7 @@ void ProcessProgram(long objectId, int passNum, ref int currentProgram, RandomAc
                     {
                         if (m_KeywordNames.TryGetValue(index, out var name))
                         {
-                            m_Keywords.Append(name);
-                            m_Keywords.Append(' ');
-                            m_UniqueKeywords.Add(name);
+                            m_Keywords.Add(GetKeywordId(name));
                         }
                     }
                 }
@@ -199,38 +217,59 @@ void ProcessProgram(long objectId, int passNum, ref int currentProgram, RandomAc
                     {
                         if (m_KeywordNames.TryGetValue(index, out var name))
                         {
-                            m_Keywords.Append(name);
-                            m_Keywords.Append(' ');
-                            m_UniqueKeywords.Add(name);
+                            m_Keywords.Add(GetKeywordId(name));
                         }
                     }
 
                     foreach (var index in subProgram["m_LocalKeywordIndices"].GetValue<ushort[]>())
                     {
                         if (m_KeywordNames.TryGetValue(index, out var name))
                         {
-                            m_Keywords.Append(name);
-                            m_Keywords.Append(' ');
-                            m_UniqueKeywords.Add(name);
+                            m_Keywords.Add(GetKeywordId(name));
                         }
                     }
                 }
 
-                m_InsertSubProgramCommand.Parameters["@shader"].Value = objectId;
-                m_InsertSubProgramCommand.Parameters["@pass"].Value = passNum;
+                m_InsertSubProgramCommand.Parameters["@id"].Value = s_SubProgramId;
                 m_InsertSubProgramCommand.Parameters["@sub_program"].Value = progNum++;
                 m_InsertSubProgramCommand.Parameters["@hw_tier"].Value = hwTier != -1 ? hwTier : subProgram["m_ShaderHardwareTier"].GetValue<sbyte>();
-                m_InsertSubProgramCommand.Parameters["@shader_type"].Value = shaderType;
                 m_InsertSubProgramCommand.Parameters["@api"].Value = subProgram["m_GpuProgramType"].GetValue<sbyte>();
-                m_InsertSubProgramCommand.Parameters["@keywords"].Value = m_Keywords.ToString();
                 m_InsertSubProgramCommand.ExecuteNonQuery();
+
+                m_InsertSubProgramKeywordsCommand.Parameters["@subprogram_id"].Value = s_SubProgramId;
+                foreach (var keyword in m_Keywords)
+                {
+                    m_InsertSubProgramKeywordsCommand.Parameters["@keyword_id"].Value = keyword;
+                    m_InsertSubProgramKeywordsCommand.ExecuteNonQuery();
+                }
+
+                ++s_SubProgramId;
             }
         }
 
+        int GetKeywordId(string keyword)
+        {
+            int id;
+
+            if (!s_Keywords.TryGetValue(keyword, out id))
+            {
+                id = s_Keywords.Count;
+                s_Keywords[keyword] = id;
+
+                m_InsertKeywordCommand.Parameters["@id"].Value = id;
+                m_InsertKeywordCommand.Parameters["@keyword"].Value = keyword;
+                m_InsertKeywordCommand.ExecuteNonQuery();
+            }
+
+            return id;
+        }
+
         void IDisposable.Dispose()
         {
             m_InsertCommand.Dispose();
             m_InsertSubProgramCommand.Dispose();
+            m_InsertKeywordCommand.Dispose();
+            m_InsertSubProgramKeywordsCommand.Dispose();
         }
     }
 }
diff --git a/Analyzer/Resources/Finalize.sql b/Analyzer/Resources/Finalize.sql
@@ -1,3 +1,6 @@
 CREATE INDEX refs_object_index ON refs(object);
 CREATE INDEX refs_referenced_object_index ON refs(referenced_object);
-CREATE INDEX shader_sp_index ON shader_subprograms(shader);
+CREATE INDEX shader_subprograms_shader_index ON shader_subprograms(shader);
+
+-- TODO: Processors should have a Finalize method and this should be moved into the ShaderProcessor.
+CREATE INDEX shader_subprogram_keywords_subprogram_id_index ON shader_subprogram_keywords(subprogram_id);
diff --git a/Analyzer/Resources/Init.sql b/Analyzer/Resources/Init.sql
@@ -78,7 +78,7 @@ END AS pretty_total_size,
 sum(size) AS total_size,
 size,
 pretty_size,
-REPLACE(GROUP_CONCAT(DISTINCT asset_bundle), ',', ', ') AS in_bundles
+REPLACE(GROUP_CONCAT(DISTINCT asset_bundle), ',', ',' || CHAR(13)) AS in_bundles
 FROM object_view
 GROUP BY name, type, size
 HAVING instances > 1
diff --git a/Analyzer/Resources/Shader.sql b/Analyzer/Resources/Shader.sql
@@ -1,36 +1,57 @@
 ﻿CREATE TABLE shaders(
     id INTEGER,
     decompressed_size INTEGER,
-    sub_shaders INTEGER,
     unique_programs INTEGER,
-    keywords TEXT,
     PRIMARY KEY (id)
 );
 
+CREATE TABLE shader_keywords(
+    id INTEGER,
+    keyword TEXT,
+    PRIMARY KEY (id)
+);
+
+CREATE TABLE shader_subprogram_keywords(
+    subprogram_id INTEGER,
+    keyword_id INTEGER
+);
+
 CREATE TABLE shader_apis(
     id INTEGER,
     name TEXT,
     PRIMARY KEY (id)
 );
 
 CREATE TABLE shader_subprograms(
+    id INTEGER,
     shader INTEGER,
+    sub_shader INTEGER,
     pass INTEGER,
+    pass_name TEXT,
     sub_program INTEGER,
     hw_tier INTEGER,
     shader_type TEXT,
     api INTEGER,
-    keywords TEXT
+    PRIMARY KEY(id)
 );
 
 CREATE VIEW shader_view AS
 SELECT
     o.*,
     s.decompressed_size,
-    s.sub_shaders,
+	(SELECT MAX(sub_shader) FROM shader_subprograms sp WHERE s.id = sp.shader) + 1 AS sub_shaders,
     (SELECT COUNT(*) FROM shader_subprograms sp WHERE s.id = sp.shader) AS sub_programs,
     s.unique_programs,
-    s.keywords
+    (
+		SELECT GROUP_CONCAT(k.keyword, ',' || CHAR(13)) FROM
+		(
+			SELECT DISTINCT kp.keyword_id FROM
+			shader_subprograms sp
+			INNER JOIN shader_subprogram_keywords kp ON sp.id = kp.subprogram_id
+			WHERE sp.shader = s.id
+		)
+		INNER JOIN shader_keywords k ON keyword_id = k.id
+	) AS keywords
 FROM object_view o
 INNER JOIN shaders s ON o.id = s.id;
 
@@ -42,16 +63,40 @@ CASE
     WHEN sum(size) >= (1024 * 1024)  AND sum(size) < (1024 * 1024 * 1024) THEN printf('%!5.1f MB', sum(size) / 1024.0 / 1024)
     WHEN sum(size) >= (1024 * 1024 * 1024) THEN printf('%!5.1f GB', sum(size) / 1024.0 / 1024 / 1024)
 END AS pretty_total_size,
-sum(size) AS total_size, GROUP_CONCAT(asset_bundle, CHAR(13)) AS in_bundles
+sum(size) AS total_size, GROUP_CONCAT(asset_bundle, ',' || CHAR(13)) AS in_bundles
 FROM shader_view
 GROUP BY name
 ORDER BY total_size DESC, instances DESC;
 
 CREATE VIEW shader_subprogram_view AS
-SELECT s.*, pt.name AS api, sp.pass, sp.hw_tier, sp.shader_type, sp.keywords AS prog_keywords
-FROM shader_view s
-LEFT JOIN shader_subprograms sp ON s.id = sp.shader
-LEFT JOIN shader_apis pt ON pt.id = sp.api;
+SELECT sp.shader AS shader_id, o.name, sp.sub_shader, sp.hw_tier, api.name api, sp.pass, sp.pass_name, sp.shader_type, sp.sub_program, GROUP_CONCAT(k.keyword, ',' || CHAR(13)) AS keywords
+FROM shader_subprograms sp
+CROSS JOIN objects o ON o.id = sp.shader
+CROSS JOIN shader_apis api ON api.id = sp.api
+CROSS JOIN shader_subprogram_keywords sk ON sk.subprogram_id = sp.id
+CROSS JOIN shader_keywords k ON sk.keyword_id = k.id
+GROUP BY sp.id;
+
+CREATE VIEW shader_keyword_ratios AS
+SELECT t.shader_id, o.name, t.sub_shader, t.hw_tier, t.pass, api.name AS api, t.pass_name, t.shader_type, t.total_variants, k.keyword, t.variants, t.ratio
+FROM
+(
+	SELECT sp.shader AS shader_id, sp.sub_shader, sp.hw_tier, sp.api, sp.pass, sp.pass_name, sp.shader_type, sp.total_variants, sk.keyword_id,
+	COUNT(*) AS variants,
+	printf('%.3f', CAST(COUNT(*) AS FLOAT) / sp.total_variants) AS ratio
+	FROM
+	(
+		SELECT id, shader, sub_shader, hw_tier, api, pass, pass_name, shader_type,
+		COUNT(id) OVER(PARTITION BY shader, sub_shader, hw_tier, api, pass, shader_type) AS total_variants
+		FROM shader_subprograms
+	) sp
+	INNER JOIN shader_subprogram_keywords sk ON sk.subprogram_id = sp.id
+	GROUP BY shader_id, sp.sub_shader, sp.hw_tier, sp.api, sp.pass, sp.shader_type, sk.keyword_id
+	ORDER BY shader_id, sp.sub_shader, sp.hw_tier, sp.api, sp.pass, sp.shader_type, ratio DESC
+) t
+CROSS JOIN objects o ON o.id = t.shader_id
+CROSS JOIN shader_apis api ON api.id = t.api
+CROSS JOIN shader_keywords k ON k.id = t.keyword_id;
 
 INSERT INTO shader_apis (name, id)
 VALUES

Original file line number	Diff line number	Diff line change
`@@ -12,11 +12,15 @@ public class ShaderProcessor : IProcessor, IDisposable`
`12`	`12`	`{`
`13`	`13`	`SQLiteCommand m_InsertCommand;`
`14`	`14`	`SQLiteCommand m_InsertSubProgramCommand;`
	`15`	`+ SQLiteCommand m_InsertKeywordCommand;`
	`16`	`+ SQLiteCommand m_InsertSubProgramKeywordsCommand;`
`15`	`17`
`16`		`- Dictionary<int, string> m_KeywordNames = new Dictionary<int, string>();`
`17`		`- StringBuilder m_Keywords = new StringBuilder();`
`18`		`- HashSet<string> m_UniqueKeywords = new HashSet<string>();`
`19`		`- HashSet<uint> m_UniquePrograms = new HashSet<uint>();`
	`18`	`+ List<int> m_Keywords = new();`
	`19`	`+ Dictionary<int, string> m_KeywordNames = new();`
	`20`	`+ HashSet<uint> m_UniquePrograms = new();`
	`21`	`+`
	`22`	`+ static Dictionary<string, int> s_Keywords = new();`
	`23`	`+ static long s_SubProgramId = 0;`
`20`	`24`
`21`	`25`	`static readonly List<(string fieldName, string typeName)> s_progTypes = new()`
`22`	`26`	`{`
`@@ -36,37 +40,43 @@ public void Init(SQLiteConnection db)`
`36`	`40`	`command.ExecuteNonQuery();`
`37`	`41`
`38`	`42`	`m_InsertCommand = new SQLiteCommand(db);`
`39`		`- m_InsertCommand.CommandText = "INSERT INTO shaders(id, decompressed_size, sub_shaders, unique_programs, keywords) VALUES(@id, @decompressed_size, @sub_shaders, @unique_programs, @keywords)";`
	`43`	`+ m_InsertCommand.CommandText = "INSERT INTO shaders(id, decompressed_size, unique_programs) VALUES(@id, @decompressed_size, @unique_programs)";`
`40`	`44`	`m_InsertCommand.Parameters.Add("@id", DbType.Int64);`
`41`	`45`	`m_InsertCommand.Parameters.Add("@decompressed_size", DbType.Int32);`
`42`		`- m_InsertCommand.Parameters.Add("@sub_shaders", DbType.Int32);`
`43`	`46`	`m_InsertCommand.Parameters.Add("@unique_programs", DbType.Int32);`
`44`		`- m_InsertCommand.Parameters.Add("@keywords", DbType.String);`
`45`	`47`
`46`	`48`	`m_InsertSubProgramCommand = new SQLiteCommand(db);`
`47`		`- m_InsertSubProgramCommand.CommandText = "INSERT INTO shader_subprograms(shader, pass, sub_program, hw_tier, shader_type, api, keywords) VALUES(@shader, @pass, @sub_program, @hw_tier, @shader_type, @api, @keywords)";`
	`49`	`+ m_InsertSubProgramCommand.CommandText = "INSERT INTO shader_subprograms(shader, sub_shader, pass, pass_name, sub_program, hw_tier, shader_type, api) VALUES(@shader, @sub_shader, @pass, @pass_name, @sub_program, @hw_tier, @shader_type, @api)";`
	`50`	`+ m_InsertSubProgramCommand.Parameters.Add("@id", DbType.Int64);`
`48`	`51`	`m_InsertSubProgramCommand.Parameters.Add("@shader", DbType.Int64);`
	`52`	`+ m_InsertSubProgramCommand.Parameters.Add("@sub_shader", DbType.Int32);`
`49`	`53`	`m_InsertSubProgramCommand.Parameters.Add("@pass", DbType.Int32);`
	`54`	`+ m_InsertSubProgramCommand.Parameters.Add("@pass_name", DbType.String);`
`50`	`55`	`m_InsertSubProgramCommand.Parameters.Add("@sub_program", DbType.Int32);`
`51`	`56`	`m_InsertSubProgramCommand.Parameters.Add("@hw_tier", DbType.Int32);`
`52`	`57`	`m_InsertSubProgramCommand.Parameters.Add("@shader_type", DbType.String);`
`53`	`58`	`m_InsertSubProgramCommand.Parameters.Add("@api", DbType.Int32);`
`54`		`- m_InsertSubProgramCommand.Parameters.Add("@keywords", DbType.String);`
	`59`	`+`
	`60`	`+ m_InsertKeywordCommand = new SQLiteCommand(db);`
	`61`	`+ m_InsertKeywordCommand.CommandText = "INSERT INTO shader_keywords(id, keyword) VALUES(@id, @keyword)";`
	`62`	`+ m_InsertKeywordCommand.Parameters.Add("@id", DbType.Int32);`
	`63`	`+ m_InsertKeywordCommand.Parameters.Add("@keyword", DbType.String);`
	`64`	`+`
	`65`	`+ m_InsertSubProgramKeywordsCommand = new SQLiteCommand(db);`
	`66`	`+ m_InsertSubProgramKeywordsCommand.CommandText = "INSERT INTO shader_subprogram_keywords(subprogram_id, keyword_id) VALUES (@subprogram_id, @keyword_id)";`
	`67`	`+ m_InsertSubProgramKeywordsCommand.Parameters.Add("@subprogram_id", DbType.Int64);`
	`68`	`+ m_InsertSubProgramKeywordsCommand.Parameters.Add("@keyword_id", DbType.Int32);`
`55`	`69`	`}`
`56`	`70`
`57`	`71`	`public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> localToDbFileId, RandomAccessReader reader, out string name, out long streamedDataSize)`
`58`	`72`	`{`
`59`		`- int currentProgram = 0;`
`60`		`-`
`61`	`73`	`streamedDataSize = 0;`
`62`	`74`
`63`		`- m_UniqueKeywords.Clear();`
`64`	`75`	`m_UniquePrograms.Clear();`
`65`	`76`
`66`	`77`	`var parsedForm = reader["m_ParsedForm"];`
`67`	`78`
`68`	`79`	`m_InsertCommand.Parameters["@id"].Value = objectId;`
`69`		`- m_InsertCommand.Parameters["@sub_shaders"].Value = parsedForm["m_SubShaders"].GetArraySize();`
`70`	`80`
`71`	`81`	`// Starting in some Unity 2021 version, keyword names are stored in m_KeywordNames.`
`72`	`82`	`bool keywordsUnity2021 = false;`
`@@ -84,10 +94,13 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l`
`84`	`94`	`}`
`85`	`95`	`}`
`86`	`96`
	`97`	`+ int subShaderNum = 0;`
`87`	`98`	`foreach (var subShader in parsedForm["m_SubShaders"])`
`88`	`99`	`{`
`89`	`100`	`int passNum = 0;`
`90`	`101`
	`102`	`+ m_InsertSubProgramCommand.Parameters["@sub_shader"].Value = subShaderNum++;`
	`103`	`+`
`91`	`104`	`foreach (var pass in subShader["m_Passes"])`
`92`	`105`	`{`
`93`	`106`	`if (!keywordsUnity2021)`
`@@ -102,6 +115,16 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l`
`102`	`115`	`}`
`103`	`116`	`}`
`104`	`117`
	`118`	`+ string passName = "";`
	`119`	`+ if (pass.HasChild("m_State"))`
	`120`	`+ {`
	`121`	`+ passName = pass["m_State"]["m_Name"].GetValue<string>();`
	`122`	`+ }`
	`123`	`+`
	`124`	`+ m_InsertSubProgramCommand.Parameters["@shader"].Value = objectId;`
	`125`	`+ m_InsertSubProgramCommand.Parameters["@pass"].Value = passNum;`
	`126`	`+ m_InsertSubProgramCommand.Parameters["@pass_name"].Value = passName;`
	`127`	`+`
`105`	`128`	`foreach (var progType in s_progTypes)`
`106`	`129`	`{`
`107`	`130`	`if (!pass.HasChild(progType.fieldName))`
`@@ -111,6 +134,8 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l`
`111`	`134`
`112`	`135`	`var program = pass[progType.fieldName];`
`113`	`136`
	`137`	`+ m_InsertSubProgramCommand.Parameters["@shader_type"].Value = progType.typeName;`
	`138`	`+`
`114`	`139`	`// Sarting in some Unity 2021.3 version, programs are stored in m_PlayerSubPrograms instead of m_SubPrograms.`
`115`	`140`	`if (program.HasChild("m_PlayerSubPrograms"))`
`116`	`141`	`{`
`@@ -119,12 +144,12 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l`
`119`	`144`	`// And they are stored per hardware tiers.`
`120`	`145`	`foreach (var tierProgram in program["m_PlayerSubPrograms"])`
`121`	`146`	`{`
`122`		`- ProcessProgram(objectId, passNum, ref currentProgram, tierProgram, progType.typeName, hwTier++);`
	`147`	`+ ProcessProgram(tierProgram, hwTier++);`
`123`	`148`	`}`
`124`	`149`	`}`
`125`	`150`	`else`
`126`	`151`	`{`
`127`		`- ProcessProgram(objectId, passNum, ref currentProgram, program["m_SubPrograms"], progType.typeName);`
	`152`	`+ ProcessProgram(program["m_SubPrograms"]);`
`128`	`153`	`}`
`129`	`154`	`}`
`130`	`155`
`@@ -136,7 +161,7 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l`
`136`	`161`
`137`	`162`	`if (!reader["decompressedLengths"].TypeTreeNode.Children[1].IsLeaf)`
`138`	`163`	`{`
`139`		`- // The decompressed lengths are now stored per graphics API.`
	`164`	`+ // The decompressed lengths are stored per graphics API.`
`140`	`165`	`foreach (var apiLengths in reader["decompressedLengths"])`
`141`	`166`	`{`
`142`	`167`	`foreach (var blockSize in apiLengths.GetValue<int[]>())`
`@@ -156,20 +181,15 @@ public void Process(AnalyzerTool analyzer, long objectId, Dictionary<int, int> l`
`156`	`181`	`}`
`157`	`182`	`}`
`158`	`183`
`159`		`- m_Keywords.Clear();`
`160`		`- m_Keywords.AppendJoin(' ', m_UniqueKeywords);`
`161`		`-`
`162`	`184`	`m_InsertCommand.Parameters["@id"].Value = objectId;`
`163`	`185`	`m_InsertCommand.Parameters["@decompressed_size"].Value = decompressedSize;`
`164`		`- m_InsertCommand.Parameters["@sub_shaders"].Value = parsedForm["m_SubShaders"].GetArraySize();`
`165`	`186`	`m_InsertCommand.Parameters["@unique_programs"].Value = m_UniquePrograms.Count;`
`166`		`- m_InsertCommand.Parameters["@keywords"].Value = m_Keywords.ToString();`
`167`	`187`	`m_InsertCommand.ExecuteNonQuery();`
`168`	`188`
`169`	`189`	`name = parsedForm["m_Name"].GetValue<string>();`
`170`	`190`	`}`
`171`	`191`
`172`		`- void ProcessProgram(long objectId, int passNum, ref int currentProgram, RandomAccessReader subPrograms, string shaderType, int hwTier = -1)`
	`192`	`+ void ProcessProgram(RandomAccessReader subPrograms, int hwTier = -1)`
`173`	`193`	`{`
`174`	`194`	`int progNum = 0;`
`175`	`195`
`@@ -187,9 +207,7 @@ void ProcessProgram(long objectId, int passNum, ref int currentProgram, RandomAc`
`187`	`207`	`{`
`188`	`208`	`if (m_KeywordNames.TryGetValue(index, out var name))`
`189`	`209`	`{`
`190`		`- m_Keywords.Append(name);`
`191`		`- m_Keywords.Append(' ');`
`192`		`- m_UniqueKeywords.Add(name);`
	`210`	`+ m_Keywords.Add(GetKeywordId(name));`
`193`	`211`	`}`
`194`	`212`	`}`
`195`	`213`	`}`
`@@ -199,38 +217,59 @@ void ProcessProgram(long objectId, int passNum, ref int currentProgram, RandomAc`
`199`	`217`	`{`
`200`	`218`	`if (m_KeywordNames.TryGetValue(index, out var name))`
`201`	`219`	`{`
`202`		`- m_Keywords.Append(name);`
`203`		`- m_Keywords.Append(' ');`
`204`		`- m_UniqueKeywords.Add(name);`
	`220`	`+ m_Keywords.Add(GetKeywordId(name));`
`205`	`221`	`}`
`206`	`222`	`}`
`207`	`223`
`208`	`224`	`foreach (var index in subProgram["m_LocalKeywordIndices"].GetValue<ushort[]>())`
`209`	`225`	`{`
`210`	`226`	`if (m_KeywordNames.TryGetValue(index, out var name))`
`211`	`227`	`{`
`212`		`- m_Keywords.Append(name);`
`213`		`- m_Keywords.Append(' ');`
`214`		`- m_UniqueKeywords.Add(name);`
	`228`	`+ m_Keywords.Add(GetKeywordId(name));`
`215`	`229`	`}`
`216`	`230`	`}`
`217`	`231`	`}`
`218`	`232`
`219`		`- m_InsertSubProgramCommand.Parameters["@shader"].Value = objectId;`
`220`		`- m_InsertSubProgramCommand.Parameters["@pass"].Value = passNum;`
	`233`	`+ m_InsertSubProgramCommand.Parameters["@id"].Value = s_SubProgramId;`
`221`	`234`	`m_InsertSubProgramCommand.Parameters["@sub_program"].Value = progNum++;`
`222`	`235`	`m_InsertSubProgramCommand.Parameters["@hw_tier"].Value = hwTier != -1 ? hwTier : subProgram["m_ShaderHardwareTier"].GetValue<sbyte>();`
`223`		`- m_InsertSubProgramCommand.Parameters["@shader_type"].Value = shaderType;`
`224`	`236`	`m_InsertSubProgramCommand.Parameters["@api"].Value = subProgram["m_GpuProgramType"].GetValue<sbyte>();`
`225`		`- m_InsertSubProgramCommand.Parameters["@keywords"].Value = m_Keywords.ToString();`
`226`	`237`	`m_InsertSubProgramCommand.ExecuteNonQuery();`
	`238`	`+`
	`239`	`+ m_InsertSubProgramKeywordsCommand.Parameters["@subprogram_id"].Value = s_SubProgramId;`
	`240`	`+ foreach (var keyword in m_Keywords)`
	`241`	`+ {`
	`242`	`+ m_InsertSubProgramKeywordsCommand.Parameters["@keyword_id"].Value = keyword;`
	`243`	`+ m_InsertSubProgramKeywordsCommand.ExecuteNonQuery();`
	`244`	`+ }`
	`245`	`+`
	`246`	`+ ++s_SubProgramId;`
`227`	`247`	`}`
`228`	`248`	`}`
`229`	`249`
	`250`	`+ int GetKeywordId(string keyword)`
	`251`	`+ {`
	`252`	`+ int id;`
	`253`	`+`
	`254`	`+ if (!s_Keywords.TryGetValue(keyword, out id))`
	`255`	`+ {`
	`256`	`+ id = s_Keywords.Count;`
	`257`	`+ s_Keywords[keyword] = id;`
	`258`	`+`
	`259`	`+ m_InsertKeywordCommand.Parameters["@id"].Value = id;`
	`260`	`+ m_InsertKeywordCommand.Parameters["@keyword"].Value = keyword;`
	`261`	`+ m_InsertKeywordCommand.ExecuteNonQuery();`
	`262`	`+ }`
	`263`	`+`
	`264`	`+ return id;`
	`265`	`+ }`
	`266`	`+`
`230`	`267`	`void IDisposable.Dispose()`
`231`	`268`	`{`
`232`	`269`	`m_InsertCommand.Dispose();`
`233`	`270`	`m_InsertSubProgramCommand.Dispose();`
	`271`	`+ m_InsertKeywordCommand.Dispose();`
	`272`	`+ m_InsertSubProgramKeywordsCommand.Dispose();`
`234`	`273`	`}`
`235`	`274`	`}`
`236`	`275`	`}`