changed schema for sampler and scalar valid ranges

com.unity.perception/Runtime/Randomization/Randomizers/Randomizer.cs

         /// <summary>
         /// Some Randomizers should not be disabled by the user as they are critical to the project. E.g. We might want to mark this as false for a foreground objects placement randomizer in some projects
         /// </summary>
-#if !SCENARIO_CONFIG_POWER_USER
-        [HideInInspector]
-#endif
-        public bool enabledStateCanBeSwitchedByUser = true;
+        [field: SerializeField]
+        public bool enabledStateCanBeSwitchedByUser { get; set; }
 
         /// <summary>
         /// Returns the scenario containing this Randomizer

com.unity.perception/Runtime/Randomization/Scenarios/Serialization/ScenarioSerializer.cs

                 samplerData.defaultSampler = new ConstantSampler
                 {
                     value = constantSampler.value,
-                    minAllowed = constantSampler.minAllowed,
-                    maxAllowed = constantSampler.maxAllowed,
-                    shouldCheckValidRange = constantSampler.shouldCheckValidRange
+                    limits = new Limits {
+                        min = constantSampler.minAllowed,
+                        max = constantSampler.maxAllowed,
+                        shouldValidateRange = constantSampler.shouldCheckValidRange
+                    }
                 };
             else if (sampler is Samplers.UniformSampler uniformSampler)
                 samplerData.defaultSampler = new UniformSampler
-                    minAllowed = uniformSampler.minAllowed,
-                    maxAllowed = uniformSampler.maxAllowed,
-                    shouldCheckValidRange = uniformSampler.shouldCheckValidRange
+                    limits = new Limits {
+                        min = uniformSampler.minAllowed,
+                        max = uniformSampler.maxAllowed,
+                        shouldValidateRange = uniformSampler.shouldCheckValidRange
+                    }
                 };
             else if (sampler is Samplers.NormalSampler normalSampler)
                 samplerData.defaultSampler = new NormalSampler
                     mean = normalSampler.mean,
                     stddev = normalSampler.standardDeviation,
-                    minAllowed = normalSampler.minAllowed,
-                    maxAllowed = normalSampler.maxAllowed,
-                    shouldCheckValidRange = normalSampler.shouldCheckValidRange
+                    limits = new Limits {
+                        min = normalSampler.minAllowed,
+                        max = normalSampler.maxAllowed,
+                        shouldValidateRange = normalSampler.shouldCheckValidRange
+                    }
                 };
             else
                 throw new ArgumentException($"Invalid sampler type ({sampler.GetType()})");
                 return new DoubleScalarValue
                 {
                     num = Convert.ToDouble(field.GetValue(obj)),
-                    minAllowed = minAllowed,
-                    maxAllowed = maxAllowed,
-                    shouldCheckValidRange = shouldCheckValidRange
+                    limits = new Limits {
+                        min = minAllowed,
+                        max = maxAllowed,
+                        shouldValidateRange = shouldCheckValidRange
+                    }
                 };
             }
 
                 return new Samplers.ConstantSampler
                 {
                     value = (float)constantSampler.value,
-                    minAllowed = (float)constantSampler.minAllowed,
-                    maxAllowed = (float)constantSampler.maxAllowed,
-                    shouldCheckValidRange = constantSampler.shouldCheckValidRange
+                    minAllowed = (float)constantSampler.limits.min,
+                    maxAllowed = (float)constantSampler.limits.max,
+                    shouldCheckValidRange = constantSampler.limits.shouldValidateRange
                 };
             if (samplerOption is UniformSampler uniformSampler)
                 return new Samplers.UniformSampler
                         minimum = (float)uniformSampler.min,
                         maximum = (float)uniformSampler.max,
                     },
-                    minAllowed = (float)uniformSampler.minAllowed,
-                    maxAllowed = (float)uniformSampler.maxAllowed,
-                    shouldCheckValidRange = uniformSampler.shouldCheckValidRange
+                    minAllowed = (float)uniformSampler.limits.min,
+                    maxAllowed = (float)uniformSampler.limits.max,
+                    shouldCheckValidRange = uniformSampler.limits.shouldValidateRange
                 };
             if (samplerOption is NormalSampler normalSampler)
                 return new Samplers.NormalSampler
                     },
                     mean = (float)normalSampler.mean,
                     standardDeviation = (float)normalSampler.stddev,
-                    minAllowed = (float)normalSampler.minAllowed,
-                    maxAllowed = (float)normalSampler.maxAllowed,
-                    shouldCheckValidRange = normalSampler.shouldCheckValidRange
+                    minAllowed = (float)normalSampler.limits.min,
+                    maxAllowed = (float)normalSampler.limits.max,
+                    shouldCheckValidRange = normalSampler.limits.shouldValidateRange
                 };
             throw new ArgumentException($"Cannot deserialize unsupported sampler type {samplerOption.GetType()}");
         }

com.unity.perception/Runtime/Randomization/Scenarios/Serialization/SerializationStructures.cs

         public bool canBeSwitchedByUser;
     }
 
+    class Limits
+    {
+        public double min;
+        public double max;
+        public bool shouldValidateRange;
+    }
+
     class Group
     {
         public StandardMetadata metadata = new StandardMetadata();
     {
         public double min;
         public double max;
-        public double minAllowed;
-        public double maxAllowed;
-        public bool shouldCheckValidRange;
+        public Limits limits;
     }
 
     class NormalSampler : ISamplerOption
         public double mean;
         public double stddev;
-        public double minAllowed;
-        public double maxAllowed;
-        public bool shouldCheckValidRange;
+        public Limits limits;
-        public double minAllowed;
-        public double maxAllowed;
-        public bool shouldCheckValidRange;
+        public Limits limits;
     }
     #endregion
 
     class DoubleScalarValue : IScalarValue
     {
         public double num;
-        public double minAllowed;
-        public double maxAllowed;
-        public bool shouldCheckValidRange;
+        public Limits limits;
     }
 
     class BooleanScalarValue : IScalarValue

com.unity.perception/Tests/Runtime/Randomization/ScenarioTests/Resources/SampleScenarioConfiguration.json

                     "uniform": {
                       "min": 0.0,
                       "max": 360.0,
-                      "minAllowed": 0.0,
-                      "maxAllowed": 0.0,
-                      "shouldCheckValidRange": false
+                      "limits": {
+                        "min": 0.0,
+                        "max": 0.0,
+                        "shouldValidateRange": false
+                      }
                     }
                   }
                 },
                     "uniform": {
                       "min": 0.0,
                       "max": 360.0,
-                      "minAllowed": 0.0,
-                      "maxAllowed": 0.0,
-                      "shouldCheckValidRange": false
+                      "limits": {
+                        "min": 0.0,
+                        "max": 0.0,
+                        "shouldValidateRange": false
+                      }
                     }
                   }
                 },
                     "uniform": {
                       "min": 0.0,
                       "max": 360.0,
-                      "minAllowed": 0.0,
-                      "maxAllowed": 0.0,
-                      "shouldCheckValidRange": false
+                      "limits": {
+                        "min": 0.0,
+                        "max": 0.0,
+                        "shouldValidateRange": false
+                      }
                     }
                   }
                 }