Merge pull request #8083 from Unity-Technologies/internal/master

Internal/master

Author: UnityAljosha

Packages/com.unity.render-pipelines.core/Documentation~/User-Render-Requests.md

@@ -8,12 +8,12 @@ The request is processed sequentially in your script, so there's no callback inv
 
 `RenderPipeline.StandardRequest` renders the following:
 
-- A full stack of cameras in the [Universal Render Pipeline](https://docs.unity3d.com/Packages/com.unity.render-pipelines.universal@latest/index.html) (URP).
-- A single camera in the [High Definition Render Pipeline](https://docs.unity3d.com/Packages/com.unity.render-pipelines.high-definition@latest/index.html) (HDRP).
+* A full stack of cameras in the [Universal Render Pipeline](https://docs.unity3d.com/Packages/com.unity.render-pipelines.universal@latest/index.html) (URP).
+* A single camera in the [High Definition Render Pipeline](https://docs.unity3d.com/Packages/com.unity.render-pipelines.high-definition@latest/index.html) (HDRP).
 
 The following code sample gets the output of the scriptable render pipeline when you select a GUI button. Attach the script to a camera and select **Enter Play Mode**.
 
-```
+```c#
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
@@ -91,5 +91,4 @@ public class StandardRenderRequest : MonoBehaviour
 
 ## Other useful information
 
-- On [Universal Render Pipeline (URP)](https://docs.unity3d.com/Packages/com.unity.render-pipelines.universal@latest/User-Render-Requests.html).
-
+* On [Universal Render Pipeline (URP)](https://docs.unity3d.com/Packages/[email protected]/manual/User-Render-Requests.html).

Packages/com.unity.render-pipelines.core/Editor/Analytics/AnalyticsUtils.cs

@@ -156,53 +156,93 @@ static Dictionary<string, string> GetDiffAsDictionary(Type type, object current,
 
             foreach (var field in type.GetSerializableFields())
             {
-                var t = field.FieldType;
-                try
-                {
-                    if (t.GetCustomAttribute<ObsoleteAttribute>() != null || typeof(ScriptableObject).IsAssignableFrom(t))
-                        continue;
+                var fieldType = field.FieldType;
+                if (!IsFieldIgnored(fieldType))
+                    AddDiff(current, defaults, field, fieldType, diff);
+            }
 
-                    var valueCurrent = current != null ? field.GetValue(current) : null;
-                    var valueDefault = defaults != null ? field.GetValue(defaults) : null;
+            return diff;
+        }
 
-                    if (t == typeof(string))
-                    {
-                        var stringCurrent = (string)valueCurrent;
-                        var stringDefault = (string)valueDefault;
-                        if (stringCurrent != stringDefault)
-                        {
-                            diff[field.Name] = stringCurrent;
-                        }
-                    }
-                    else if (t.IsPrimitive || t.IsEnum)
-                    {
-                        if (!valueCurrent.Equals(valueDefault))
-                            diff[field.Name] = ConvertPrimitiveWithInvariants(valueCurrent);
-                    }
-                    else if (t.IsArray && valueCurrent is IList valueCurrentList)
-                    {
-                        if (AreArraysDifferent(valueCurrentList, valueDefault as IList))
-                            diff[field.Name] = valueCurrentList.DumpValues();
-                    }
-                    else if (t.IsClass || t.IsValueType)
-                    {
-                        if (valueCurrent is IEnumerable ea)
-                            continue; // List<T> not supported
+        private static void AddDiff(object current, object defaults, FieldInfo field, Type fieldType, Dictionary<string, string> diff)
+        {
+            try
+            {
+                var valueCurrent = current != null ? field.GetValue(current) : null;
+                var valueDefault = defaults != null ? field.GetValue(defaults) : null;
+                AddIfDifferent(field, fieldType, diff, valueCurrent, valueDefault);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"Exception found while parsing {field}, {ex}");
+            }
+        }
 
-                        var subDiff = GetDiffAsDictionary(t, valueCurrent, valueDefault);
-                        foreach (var d in subDiff)
-                        {
-                            diff[field.Name + "." + d.Key] = d.Value;
-                        }
+        private static void AddIfDifferent(FieldInfo field, Type fieldType, Dictionary<string, string> diff, object valueCurrent, object valueDefault)
+        {
+            if (!AreValuesEqual(fieldType, valueCurrent, valueDefault))
+            {
+                if (IsComplexType(fieldType))
+                {
+                    var subDiff = GetDiffAsDictionary(fieldType, valueCurrent, valueDefault);
+                    foreach (var d in subDiff)
+                    {
+                        diff[$"{field.Name}.{d.Key}"] = d.Value;
                     }
                 }
-                catch (Exception ex)
+                else
                 {
-                    Debug.LogError($"Exception found while parsing {field}, {ex}");
+                    diff[field.Name] = ConvertValueToString(valueCurrent);
                 }
             }
+        }
 
-            return diff;
+        static bool IsFieldIgnored(Type fieldType)
+        {
+            return fieldType.GetCustomAttribute<ObsoleteAttribute>() != null || typeof(ScriptableObject).IsAssignableFrom(fieldType);
+        }
+
+        internal static bool AreValuesEqual(Type fieldType, object valueCurrent, object valueDefault)
+        {
+            if (fieldType == typeof(string))
+                return (string)valueCurrent == (string)valueDefault;
+
+            if (fieldType.IsPrimitive || fieldType.IsEnum)
+                return valueCurrent.Equals(valueDefault);
+
+            if (fieldType.IsArray && valueCurrent is IList currentList)
+                return !AreArraysDifferent(currentList, valueDefault as IList);
+
+            if (valueCurrent == null && valueDefault == null)
+                return true;
+
+            return valueDefault?.Equals(valueCurrent) ?? valueCurrent?.Equals(null) ?? false;
+        }
+
+        internal static bool IsComplexType(Type fieldType)
+        {
+            // Primitive types and enums are not considered complex
+            if (fieldType.IsPrimitive || fieldType.IsEnum)
+                return false;
+
+            // String is considered a primitive type for our purposes
+            if (fieldType == typeof(string))
+                return false;
+
+            // Arrays can be converted to string easy without sub-elements
+            if (fieldType.IsArray)
+                return false;
+
+            // Value types (structs) that are not primitive are considered complex
+            // Classes are considered complex types
+            return fieldType.IsValueType || fieldType.IsClass;
+        }
+
+        static string ConvertValueToString(object value)
+        {
+            if (value == null) return null;
+            if (value is IList list) return list.DumpValues();
+            return ConvertPrimitiveWithInvariants(value);
         }
 
         static string ConvertPrimitiveWithInvariants(object obj)
@@ -212,17 +252,49 @@ static string ConvertPrimitiveWithInvariants(object obj)
             return obj.ToString();
         }
 
-        static string[] ToStringArray(Dictionary<string, string> diff)
+        static string[] ToStringArray(Dictionary<string, string> diff, string format = null)
         {
             var changedSettings = new string[diff.Count];
 
+            if (string.IsNullOrEmpty(format))
+                format = @"{{""{0}"":""{1}""}}";
+
             int i = 0;
             foreach (var d in diff)
-                changedSettings[i++] = $@"{{""{d.Key}"":""{d.Value}""}}";
+                changedSettings[i++] = string.Format(format, d.Key, d.Value);
 
             return changedSettings;
         }
 
+        private static string[] EnumerableToNestedColumn<T>([DisallowNull] this IEnumerable collection)
+        {
+            using (ListPool<string>.Get(out var tmp))
+            {
+                foreach (var element in collection)
+                {
+                    string[] elementColumns = ToStringArray(DumpValues(element.GetType(), element), @"""{0}"":""{1}""");
+                    tmp.Add("{" + string.Join(", ", elementColumns) + "}");
+                }
+
+                return tmp.ToArray();
+            }
+        }
+
+        private static string[] ToNestedColumnSimplify<T>([DisallowNull] this T current)
+            where T : new()
+        {
+            var type = current.GetType();
+
+            if (typeof(UnityEngine.Object).IsAssignableFrom(typeof(T)))
+            {
+                var instance = ScriptableObject.CreateInstance(type);
+                ToStringArray(GetDiffAsDictionary(type, current, instance));
+                ScriptableObject.DestroyImmediate(instance);
+            }
+
+            return ToStringArray(GetDiffAsDictionary(type, current, new T()));
+        }
+
         /// <summary>
         /// Obtains the Serialized fields and values in form of nested columns for BigQuery
         /// https://cloud.google.com/bigquery/docs/nested-repeated
@@ -238,28 +310,13 @@ public static string[] ToNestedColumn<T>([DisallowNull] this T current, bool com
             if (current == null)
                 throw new ArgumentNullException(nameof(current));
 
-            var type = current.GetType();
+            if (current is IEnumerable currentAsEnumerable)
+                return EnumerableToNestedColumn<T>(currentAsEnumerable);
 
-            Dictionary<string, string> diff;
             if (compareAndSimplifyWithDefault)
-            {
-                if (typeof(UnityEngine.Object).IsAssignableFrom(typeof(T)))
-                {
-                    var instance = ScriptableObject.CreateInstance(type);
-                    diff = GetDiffAsDictionary(type, current, instance);
-                    ScriptableObject.DestroyImmediate(instance);
-                }
-                else
-                {
-                    diff = GetDiffAsDictionary(type, current, new T());
-                }
-            }
-            else
-            {
-                diff = DumpValues(type, current);
-            }
+                return ToNestedColumnSimplify(current);
 
-            return ToStringArray(diff);
+            return ToStringArray(DumpValues(current.GetType(), current));
         }
 
         /// <summary>

Packages/com.unity.render-pipelines.core/Editor/Analytics/BuildTargetAnalytic.cs

@@ -22,7 +22,7 @@ public bool TryGatherData([NotNullWhen(true)] out IAnalytic.IData data, [NotNull
             {
                 var activeBuildTarget = EditorUserBuildSettings.activeBuildTarget;
                 var activeBuildTargetGroup = BuildPipeline.GetBuildTargetGroup(activeBuildTarget);
-                var activeBuildTargetGroupName = activeBuildTargetGroup.ToString();
+                var activeBuildTargetGroupName = NamedBuildTarget.FromBuildTargetGroup(activeBuildTargetGroup).TargetName;
 
                 error = null;
 
@@ -37,7 +37,6 @@ public bool TryGatherData([NotNullWhen(true)] out IAnalytic.IData data, [NotNull
                 };
                 return true;
             }
-
         };
 
         [System.Diagnostics.DebuggerDisplay("{render_pipeline_asset_type} - {quality_levels}/{total_quality_levels_on_project}")]