Added randomization deserialization

com.unity.perception/Editor/Randomization/Editors/ScenarioBaseEditor.cs

             serializeConstantsButton.clicked += () => m_Scenario.Serialize();
 
             var deserializeConstantsButton = m_Root.Q<Button>("deserialize-constants");
-            deserializeConstantsButton.clicked += () => m_Scenario.Deserialize();
+            deserializeConstantsButton.clicked += () =>
+            {
+                Undo.RecordObject(m_Scenario, "Deserialized scenario configuration");
+                m_Scenario.Deserialize();
+            };
 
             m_RandomizerListPlaceholder = m_Root.Q<VisualElement>("randomizer-list-placeholder");
 

com.unity.perception/Runtime/Randomization/Scenarios/Scenario.cs

 using System;
 using System.CodeDom;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine.Experimental.Perception.Randomization.Randomizers;
 using UnityEngine.Experimental.Perception.Randomization.Samplers;
 
 namespace UnityEngine.Experimental.Perception.Randomization.Scenarios
         /// </summary>
         public override void Serialize()
         {
-            SerializeRandomizers();
-                writer.Write(JsonUtility.ToJson(constants, true));
+                writer.Write(SerializeRandomizers());
         }
 
         static bool IsSubclassOfRawGeneric(Type generic, Type toCheck) {
             return false;
         }
 
-        void SerializeRandomizers()
+        string SerializeRandomizers()
+            var constantsObj = new JObject();
+            configObj["constants"] = constantsObj;
+            var constantsFields = constants.GetType().GetFields();
+            foreach (var constantsField in constantsFields)
+                constantsObj.Add(new JProperty(constantsField.Name, constantsField.GetValue(constants)));
+
             var randomizersObj = new JObject();
             configObj["randomizers"] = randomizersObj;
             foreach (var randomizer in m_Randomizers)
                     {
                         if (samplerField.FieldType != typeof(ISampler))
                             continue;
-                        var sampler = samplerField.GetValue(parameter);
+                        var sampler = (ISampler)samplerField.GetValue(parameter);
-                        Debug.Log(fields.Length);
-                        {
+                        if (sampler.GetType() != typeof(ConstantSampler))
+                        {
+                            var rangeProperty = sampler.GetType().GetProperty("range");
+                            if (rangeProperty != null)
+                            {
+                                var range = (FloatRange)rangeProperty.GetValue(sampler);
+                                var rangeObj = new JObject
+                                {
+                                    new JProperty("minimum", range.minimum),
+                                    new JProperty("maximum", range.maximum)
+                                };
+                                samplerObj.Add(new JProperty("range", rangeObj));
+                            }
                         }
                         parameterObj.Add(new JProperty(samplerField.Name, samplerObj));
                     }
                 if (randomizerObj.Count > 0)
                     randomizersObj.Add(new JProperty(randomizer.GetType().Name, randomizerObj));
             }
-            Debug.Log(JsonConvert.SerializeObject(configObj, Formatting.Indented));
+            return JsonConvert.SerializeObject(configObj, Formatting.Indented);
         }
 
         /// <summary>
             else if (File.Exists(serializedConstantsFilePath))
             {
                 var jsonText = File.ReadAllText(serializedConstantsFilePath);
-                constants = JsonUtility.FromJson<T>(jsonText);
+                // constants = JsonUtility.FromJson<T>(jsonText);
+                DeserializeRandomizers(jsonText);
+            }
+        }
+
+        void DeserializeRandomizers(string json)
+        {
+            var jsonObj = JObject.Parse(json);
+            var constantsObj = (JObject)jsonObj["constants"];
+            constants = constantsObj.ToObject<T>();
+
+            var randomizersObj = (JObject)jsonObj["randomizers"];
+            var randomizerTypeMap = new Dictionary<string, Randomizer>();
+            foreach (var randomizer in randomizers)
+                randomizerTypeMap.Add(randomizer.GetType().Name, randomizer);
+
+            foreach (var randomizerPair in randomizersObj)
+            {
+                if (!randomizerTypeMap.ContainsKey(randomizerPair.Key))
+                    continue;
+                var randomizer = randomizerTypeMap[randomizerPair.Key];
+                var randomizerObj = (JObject)randomizerPair.Value;
+                foreach (var parameterPair in randomizerObj)
+                {
+                    var parameterField = randomizer.GetType().GetField(parameterPair.Key);
+                    if (parameterField == null)
+                        continue;
+                    var parameter = (Parameter)parameterField.GetValue(randomizer);
+                    var parameterObj = (JObject)parameterPair.Value;
+                    foreach (var samplerPair in parameterObj)
+                    {
+                        var samplerField = parameter.GetType().GetField(samplerPair.Key);
+                        if (samplerField == null)
+                            continue;
+                        var sampler = (ISampler)samplerField.GetValue(parameter);
+                        var samplerObj = (JObject)samplerPair.Value;
+                        foreach (var samplerFieldPair in samplerObj)
+                        {
+                            if (samplerFieldPair.Key == "range")
+                            {
+                                var rangeObj = (JObject)samplerFieldPair.Value;
+                                sampler.range = new FloatRange(
+                                    rangeObj["minimum"].ToObject<float>(), rangeObj["maximum"].ToObject<float>());
+                            }
+                            else
+                            {
+                                var field = sampler.GetType().GetField(samplerFieldPair.Key);
+                                if (field != null)
+                                    field.SetValue(sampler, ((JValue)samplerFieldPair.Value).Value);
+                            }
+                        }
+                    }
+                }
             }
         }
     }