renamed ParameterConfiguration to ParameterList

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

 using UnityEngine;
 using UnityEditor;
 using UnityEditor.UIElements;
-using UnityEngine.Perception.Randomization.ParameterBehaviours.Configuration;
+using UnityEngine.Perception.Randomization.ParameterBehaviours;
-    [CustomEditor(typeof(ParameterConfiguration))]
-    class ParameterConfigurationEditor : UnityEditor.Editor
+    [CustomEditor(typeof(ParameterList))]
+    class ParameterListEditor : UnityEditor.Editor
-        public ParameterConfiguration config;
+        public ParameterList config;
 
         string m_FilterString = string.Empty;
         public string FilterString
                 {
                     var paramIndex = m_ParameterContainer.IndexOf(child);
                     var param = config.configuredParameters[paramIndex];
-                    ((ConfiguredParameterElement)child).filtered = param.name.ToLower().Contains(lowerFilter);
+                    ((ParameterListItemElement)child).filtered = param.name.ToLower().Contains(lowerFilter);
                 }
             }
         }
-            config = (ParameterConfiguration)target;
-            m_Parameters = serializedObject.FindProperty("parameters");
+            config = (ParameterList)target;
+            m_Parameters = serializedObject.FindProperty("configuredParameters");
-                $"{StaticData.uxmlDir}/ParameterConfiguration.uxml").CloneTree();
+                $"{StaticData.uxmlDir}/ParameterListEditor.uxml").CloneTree();
 
             m_ParameterContainer = m_Root.Q<VisualElement>("parameters-container");
 
         {
             m_ParameterContainer.Clear();
             for (var i = 0; i < m_Parameters.arraySize; i++)
-                m_ParameterContainer.Add(new ConfiguredParameterElement(m_Parameters.GetArrayElementAtIndex(i), this));
+                m_ParameterContainer.Add(new ParameterListItemElement(m_Parameters.GetArrayElementAtIndex(i), this));
         }
 
         void AddParameter(Type parameterType)
         void CollapseParameters(bool collapsed)
         {
             foreach (var child in m_ParameterContainer.Children())
-                ((ConfiguredParameterElement)child).collapsed = collapsed;
+                ((ParameterListItemElement)child).collapsed = collapsed;
         }
     }
 }

com.unity.perception/Editor/Randomization/Uxml/ParameterListItemElement.uxml

 
             <VisualElement name="properties" class="parameter-properties-container">
                 <Box>
-                    <editor:ObjectField label="Target GameObject" name="target"/>
-                    <VisualElement name="target-container">
-                        <VisualElement class="unity-base-field">
-                            <Label text="Target Property" class="unity-base-field__label"/>
-                            <editor:ToolbarMenu text="Select A Property" name="property-select-menu" class="property-select-menu"/>
-                        </VisualElement>
-                        <editor:EnumField label="Application Frequency" name="application-frequency"/>
+                    <VisualElement class="unity-base-field">
+                        <Label text="Target Property" class="unity-base-field__label"/>
+                        <editor:ToolbarMenu text="Select A Property" name="property-select-menu" class="property-select-menu"/>
+                    <editor:EnumField label="Application Frequency" name="application-frequency"/>
                 </Box>
             </VisualElement>
         </VisualElement>

com.unity.perception/Editor/Randomization/Uxml/ParameterListEditor.uxml

 <UXML xmlns="UnityEngine.UIElements" xmlns:editor="UnityEditor.UIElements">
     <VisualElement>
-        <Style src="../Uss/ParameterConfigurationStyles.uss"/>
+        <Style src="../Uss/ParameterListStyles.uss"/>
 
         <VisualElement style="flex-direction: row; align-items: center; margin-bottom: 2px; margin-top: 2px;">
             <VisualElement class="search-icon" style="margin-left: 3px; margin-right: 2px;"/>

com.unity.perception/Editor/Randomization/VisualElements/ParameterDragManipulator.cs

     {
         bool m_Active;
         float m_Offset;
-        ConfiguredParameterElement m_ParameterElement;
+        ParameterListItemElement m_ParameterListItemElement;
         VisualElement m_DragHandle;
         VisualElement m_DragBar;
         VisualElement m_ParameterContainer;
-            m_ParameterElement = (ConfiguredParameterElement)target;
-            m_DragHandle = m_ParameterElement.Q<VisualElement>("drag-handle");
+            m_ParameterListItemElement = (ParameterListItemElement)target;
+            m_DragHandle = m_ParameterListItemElement.Q<VisualElement>("drag-handle");
             m_DragHandle.RegisterCallback<MouseDownEvent>(OnMouseDown);
             m_DragHandle.RegisterCallback<MouseMoveEvent>(OnMouseMove);
             m_DragHandle.RegisterCallback<MouseUpEvent>(OnMouseUp);
                 return;
             }
 
-            if (m_ParameterElement.configEditor.FilterString != string.Empty)
+            if (m_ParameterListItemElement.configEditor.FilterString != string.Empty)
                 return;
 
             m_ParameterContainer = target.parent;
             {
                 if (dragBarY < middlePoints[i])
                 {
-                    ReorderParameter(m_ParameterElement.ParameterIndex, i);
+                    ReorderParameter(m_ParameterListItemElement.ParameterIndex, i);
-            ReorderParameter(m_ParameterElement.ParameterIndex, middlePoints.Length);
+            ReorderParameter(m_ParameterListItemElement.ParameterIndex, middlePoints.Length);
-            m_ParameterElement.configEditor.ReorderParameter(currentIndex, nextIndex);
+            m_ParameterListItemElement.configEditor.ReorderParameter(currentIndex, nextIndex);
         }
     }
 }

com.unity.perception/Runtime/Randomization/ParameterBehaviours/Configuration/ParameterTarget.cs

 using System;
 using UnityEngine.Perception.Randomization.Parameters;
 
-namespace UnityEngine.Perception.Randomization.ParameterBehaviours.Configuration
+namespace UnityEngine.Perception.Randomization.ParameterBehaviours
 {
     /// <summary>
     /// Used to apply sampled parameter values to a particular GameObject, Component, and property.
     public class ParameterTarget
     {
-        [SerializeField] internal GameObject gameObject;
         [SerializeField] internal Component component;
         [SerializeField] internal string propertyName = string.Empty;
         [SerializeField] internal FieldOrProperty fieldOrProperty = FieldOrProperty.Field;
         /// Assigns a new target
         /// </summary>
-        /// <param name="targetObject">The target GameObject</param>
-            GameObject targetObject,
-            gameObject = targetObject;
             component = targetComponent;
             propertyName = fieldOrPropertyName;
             applicationFrequency = frequency;
 
         internal void Clear()
         {
-            gameObject = null;
             component = null;
             propertyName = string.Empty;
         }
     public enum ParameterApplicationFrequency
     {
         /// <summary>
-        /// Applies a parameter once every iteration
+        /// Applies a parameter once at the beginning of every iteration
         /// </summary>
         OnIterationStart,
 

com.unity.perception/Runtime/Randomization/ParameterBehaviours/ParameterBehaviour.cs

 using System;
 using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Perception.Randomization.Scenarios;
-        internal static HashSet<ParameterBehaviour> activeBehaviours = new HashSet<ParameterBehaviour>();
+        static HashSet<ParameterBehaviour> s_ActiveBehaviours = new HashSet<ParameterBehaviour>();
+        static Queue<ParameterBehaviour> s_PendingBehaviours = new Queue<ParameterBehaviour>();
+
+        internal static IEnumerable<ParameterBehaviour> behaviours
+        {
+            get
+            {
+                var currentBehaviours = s_ActiveBehaviours.ToArray();
+                foreach (var behaviour in currentBehaviours)
+                    if (s_ActiveBehaviours.Contains(behaviour))
+                        yield return behaviour;
+                while (s_PendingBehaviours.Count > 0)
+                {
+                    var behaviour = s_PendingBehaviours.Dequeue();
+                    if (!s_ActiveBehaviours.Contains(behaviour))
+                    {
+                        s_ActiveBehaviours.Add(behaviour);
+                        yield return behaviour;
+                    }
+                }
+            }
+        }
-            activeBehaviours.Add(this);
+            s_PendingBehaviours.Enqueue(this);
+            ResetState();
-            activeBehaviours.Remove(this);
+            s_PendingBehaviours.Enqueue(this);
         }
 
         protected virtual void OnInitialize() { }
 
         public virtual void Validate() { }
 
-        internal void ResetState(int scenarioIteration)
+        internal void ResetState()
-                parameter.ResetState(scenarioIteration);
+            {
+                parameter.ResetState();
+                parameter.IterateState(ScenarioBase.ActiveScenario.currentIteration);
+                parameter.IterateState(GetInstanceID());
+            }
         }
 
         public virtual void Reset()

com.unity.perception/Runtime/Randomization/Parameters/Parameter.cs

         }
 
         /// <summary>
-        /// Resets sampler states and then offsets those states using the current scenario iteration
+        /// Resets the state of each sampler employed by this parameter
-        /// <param name="scenarioIteration">The current scenario iteration</param>
-        public void ResetState(int scenarioIteration)
+        public void ResetState()
-            {
-                sampler.IterateState(scenarioIteration);
-            }
+        }
+
+        /// <summary>
+        /// Offsets the state of each sampler employed by this parameter
+        /// </summary>
+        /// <param name="offsetIndex">Often the current scenario iteration</param>
+        public void IterateState(int offsetIndex)
+        {
+            foreach (var sampler in samplers)
+                sampler.IterateState(offsetIndex);
         }
 
         /// <summary>

com.unity.perception/Runtime/Randomization/Samplers/SamplerTypes/ConstantSampler.cs

         public void ResetState() { }
 
         /// <summary>
-        /// Resets a sampler's state to its base random seed and then offsets said seed using an index value.
-        /// Note that ConstantSamplers do not have random states.
-        /// </summary>
-        /// <param name="index">Often a the active scenario's currentIteration</param>
-        public void ResetState(int index) { }
-
-        /// <summary>
-        /// Set the base seed value of this sampler.
-        /// Note that ConstantSamplers do not have base seeds.
-        /// </summary>
-        /// <param name="seed">The seed that will replace the sampler's current seed</param>
-        public void Rebase(uint seed) { }
-
-        /// <summary>
-        /// Deterministically offsets a sampler's state when generating values within a batched job.
+        /// Deterministically offsets a sampler's state.
         /// Note that ConstantSamplers do not have a state to iterate.
         /// </summary>
         /// <param name="offsetIndex">

com.unity.perception/Runtime/Randomization/Samplers/SamplerTypes/NormalSampler.cs

         }
 
         /// <summary>
-        /// Resets a sampler's state to its base random seed and then offsets said seed using an index value
-        /// </summary>
-        /// <param name="index">Often a the active scenario's currentIteration</param>
-        public void ResetState(int index)
-        {
-            ResetState();
-            IterateState(index);
-        }
-
-        /// <summary>
-        /// Set the base seed value of this sampler
-        /// </summary>
-        /// <param name="seed">The seed that will replace the sampler's current seed</param>
-        public void Rebase(uint seed)
-        {
-            baseSeed = seed;
-        }
-
-        /// <summary>
-        /// Deterministically offsets a sampler's state when generating values within a batched job
+        /// Deterministically offsets a sampler's state
         /// </summary>
         /// <param name="offsetIndex">
         /// The index used to offset the sampler's state.

com.unity.perception/Runtime/Randomization/Samplers/SamplerTypes/UniformSampler.cs

         }
 
         /// <summary>
-        /// Resets a sampler's state to its base random seed and then offsets said seed using an index value
-        /// </summary>
-        /// <param name="index">Often a the active scenario's currentIteration</param>
-        public void ResetState(int index)
-        {
-            ResetState();
-            IterateState(index);
-        }
-
-        /// <summary>
-        /// Set the base seed value of this sampler
-        /// </summary>
-        /// <param name="seed">The seed that will replace the sampler's current seed</param>
-        public void Rebase(uint seed)
-        {
-            baseSeed = seed;
-        }
-
-        /// <summary>
-        /// Deterministically offsets a sampler's state when generating values within a batched job
+        /// Deterministically offsets a sampler's state
         /// </summary>
         /// <param name="offsetIndex">
         /// The index used to offset the sampler's state.

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

 using System;
+using System.Linq;
 using Randomization.ParameterBehaviours;
 using UnityEngine;
 using UnityEngine.Perception.GroundTruth;
     /// <summary>
     /// The base class of all scenario classes
     /// </summary>
+    [DefaultExecutionOrder(-1)]
     public abstract class ScenarioBase : MonoBehaviour
     {
         static ScenarioBase s_ActiveScenario;
             get => s_ActiveScenario;
             private set
             {
-                if (s_ActiveScenario != null)
-                    throw new ScenarioException("There cannot be more than one active ParameterConfiguration");
+                if (value != null && s_ActiveScenario != null && value != s_ActiveScenario)
+                    throw new ScenarioException("There cannot be more than one active Scenario");
                 s_ActiveScenario = value;
             }
         }
         /// </summary>
         public abstract void Deserialize();
 
+        void Awake()
+        {
+            ActiveScenario = this;
+        }
+
         void OnEnable()
         {
             ActiveScenario = this;
         {
             if (deserializeOnStart)
                 Deserialize();
-            foreach (var behaviour in ParameterBehaviour.activeBehaviours)
+            foreach (var behaviour in ParameterBehaviour.behaviours)
                 behaviour.Validate();
         }
 
                 {
                     currentIteration++;
                     currentIterationFrame = 0;
-                    foreach (var behaviour in ParameterBehaviour.activeBehaviours)
+                    foreach (var behaviour in ParameterBehaviour.behaviours)
                         behaviour.OnIterationEnd();
                 }
             }
             {
-                foreach (var behaviour in ParameterBehaviour.activeBehaviours)
+                foreach (var behaviour in ParameterBehaviour.behaviours)
                     behaviour.OnScenarioComplete();
                 DatasetCapture.ResetSimulation();
                 if (quitOnComplete)
             }
 
             // Perform new iteration tasks
+
-                foreach (var behaviour in ParameterBehaviour.activeBehaviours)
-                    behaviour.ResetState(currentIteration);
-                foreach (var behaviour in ParameterBehaviour.activeBehaviours)
+                foreach (var behaviour in ParameterBehaviour.behaviours)
+                    behaviour.ResetState();
+                foreach (var behaviour in ParameterBehaviour.behaviours)
-            foreach (var behaviour in ParameterBehaviour.activeBehaviours)
+            foreach (var behaviour in ParameterBehaviour.behaviours)
                 behaviour.OnFrameStart();
         }
     }

com.unity.perception/Runtime/Randomization/Scenarios/ScenarioBase.cs.meta

-fileFormatVersion: 2
+fileFormatVersion: 2
-timeCreated: 1589772146
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.perception/Tests/Runtime/Randomization/ParameterConfigurationTests.cs

 using NUnit.Framework;
 using UnityEngine;
-using UnityEngine.Perception.Randomization.ParameterBehaviours.Configuration;
+using UnityEngine.Perception.Randomization.ParameterBehaviours;
 using UnityEngine.Perception.Randomization.Parameters;
 
 namespace RandomizationTests
         [Test]
         public void CheckForParametersWithSameNameTest()
         {
-            var config = m_TestObject.AddComponent<ParameterConfiguration>();
+            var config = m_TestObject.AddComponent<ParameterList>();
-            Assert.Throws<ParameterConfigurationException>(() => config.Validate());
+            Assert.Throws<ParameterListException>(() => config.Validate());
-            var config = m_TestObject.AddComponent<ParameterConfiguration>();
+            var config = m_TestObject.AddComponent<ParameterList>();
-            Assert.Throws<ParameterConfigurationException>(() => config.AddParameter("TestParam2", typeof(Rigidbody)));
+            Assert.Throws<ParameterListException>(() => config.AddParameter("TestParam2", typeof(Rigidbody)));
         }
     }
 }

com.unity.perception/Tests/Runtime/Randomization/ScenarioTests.cs

 using NUnit.Framework;
 using UnityEngine;
 using UnityEngine.Perception.GroundTruth;
-using UnityEngine.Perception.Randomization.ParameterBehaviours.Configuration;
+using UnityEngine.Perception.Randomization.ParameterBehaviours;
 using UnityEngine.Perception.Randomization.Parameters;
 using UnityEngine.Perception.Randomization.Samplers;
 using UnityEngine.Perception.Randomization.Scenarios;
         [UnityTest]
         public IEnumerator AppliesParametersEveryFrame()
         {
-            var config = m_TestObject.AddComponent<ParameterConfiguration>();
+            var config = m_TestObject.AddComponent<ParameterList>();
             var configuredParameter = config.AddParameter<Vector3Parameter>("testParam");
             var parameter = (Vector3Parameter)configuredParameter.parameter;
             parameter.x = new UniformSampler(1, 2);
-                m_TestObject, m_TestObject.transform, "position", ParameterApplicationFrequency.EveryFrame);
+                m_TestObject.transform, "position", ParameterApplicationFrequency.EveryFrame);
 
             var initialPosition = Vector3.zero;
             yield return CreateNewScenario(1, 5);
         [UnityTest]
         public IEnumerator AppliesParametersEveryIteration()
         {
-            var config = m_TestObject.AddComponent<ParameterConfiguration>();
+            var config = m_TestObject.AddComponent<ParameterList>();
             var configuredParameter = config.AddParameter<Vector3Parameter>("testParam");
             var parameter = (Vector3Parameter)configuredParameter.parameter;
             parameter.x = new UniformSampler(1, 2);
             var prevPosition = new Vector3();
             transform.position = prevPosition;
             configuredParameter.target.AssignNewTarget(
-                m_TestObject, transform, "position", ParameterApplicationFrequency.OnIterationStart);
+                transform, "position", ParameterApplicationFrequency.OnIterationStart);
 
 
             yield return CreateNewScenario(2, 2);

com.unity.perception/Editor/Randomization/VisualElements/ParameterListItemElement.cs

+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine.Perception.Randomization.ParameterBehaviours;
+using UnityEngine.Perception.Randomization.Parameters;
+using UnityEngine.UIElements;
+
+namespace UnityEngine.Perception.Randomization.Editor
+{
+    class ParameterListItemElement : VisualElement
+    {
+        Type m_ParameterSampleType;
+        VisualElement m_Properties;
+        VisualElement m_TargetContainer;
+        ToolbarMenu m_TargetPropertyMenu;
+        SerializedProperty m_SerializedProperty;
+        SerializedProperty m_Collapsed;
+        SerializedProperty m_Target;
+        SerializedProperty m_TargetComponent;
+        SerializedProperty m_TargetProperty;
+
+        const string k_CollapsedParameterClass = "collapsed-parameter";
+
+        public ParameterListEditor configEditor { get; }
+
+        public int ParameterIndex => parent.IndexOf(this);
+
+        GameObject gameObject => ((ParameterList)m_SerializedProperty.serializedObject.targetObject).gameObject;
+        GameObject targetGameObject => m_TargetComponent.objectReferenceValue != null
+                ? ((Component)m_TargetComponent.objectReferenceValue).gameObject : null;
+
+        public bool collapsed
+        {
+            get => m_Collapsed.boolValue;
+            set
+            {
+                m_Collapsed.boolValue = value;
+                m_SerializedProperty.serializedObject.ApplyModifiedProperties();
+                if (value)
+                    AddToClassList(k_CollapsedParameterClass);
+                else
+                    RemoveFromClassList(k_CollapsedParameterClass);
+            }
+        }
+
+        public bool filtered
+        {
+            set => style.display = value
+                ? new StyleEnum<DisplayStyle>(DisplayStyle.Flex)
+                : new StyleEnum<DisplayStyle>(DisplayStyle.None);
+        }
+
+        public ParameterListItemElement(SerializedProperty property, ParameterListEditor config)
+        {
+            configEditor = config;
+            var template = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(
+                $"{StaticData.uxmlDir}/ParameterListItemElement.uxml");
+            template.CloneTree(this);
+
+            m_SerializedProperty = property;
+            var parameterProperty = m_SerializedProperty.FindPropertyRelative("parameter");
+            var parameter = (Parameter)StaticData.GetManagedReferenceValue(parameterProperty);
+            m_ParameterSampleType = parameter.sampleType;
+            m_Collapsed = parameterProperty.FindPropertyRelative("collapsed");
+            m_Target = m_SerializedProperty.FindPropertyRelative("target");
+            m_TargetComponent = m_Target.FindPropertyRelative("component");
+            m_TargetProperty = m_Target.FindPropertyRelative("propertyName");
+
+            this.AddManipulator(new ParameterDragManipulator());
+
+            var removeButton = this.Q<Button>("remove-parameter");
+            removeButton.RegisterCallback<MouseUpEvent>(evt => configEditor.RemoveParameter(this));
+
+            var parameterTypeLabel = this.Query<Label>("parameter-type-label").First();
+            parameterTypeLabel.text = Parameter.GetDisplayName(parameter.GetType());
+
+            var parameterNameField = this.Q<TextField>("name");
+            parameterNameField.isDelayed = true;
+            parameterNameField.BindProperty(m_SerializedProperty.FindPropertyRelative("name"));
+
+            var targetObj = targetGameObject;
+            if (targetObj == null)
+                m_TargetProperty.stringValue = string.Empty;
+            else if (targetObj != gameObject)
+            {
+                var component = (Component)m_TargetComponent.objectReferenceValue;
+                m_TargetComponent.objectReferenceValue = gameObject.GetComponent(component.GetType());
+                m_SerializedProperty.serializedObject.ApplyModifiedPropertiesWithoutUndo();
+            }
+            m_TargetPropertyMenu = this.Q<ToolbarMenu>("property-select-menu");
+            FillPropertySelectMenu();
+
+            var frequencyField = this.Q<EnumField>("application-frequency");
+            frequencyField.Init(ParameterApplicationFrequency.OnIterationStart);
+            var applicationFrequency = m_Target.FindPropertyRelative("applicationFrequency");
+            frequencyField.BindProperty(applicationFrequency);
+
+            var collapseToggle = this.Q<VisualElement>("collapse");
+            collapseToggle.RegisterCallback<MouseUpEvent>(evt => collapsed = !collapsed);
+
+            var parameterProperties = this.Q<VisualElement>("properties");
+            parameterProperties.Add(new ParameterElement(m_SerializedProperty.FindPropertyRelative("parameter")));
+        }
+
+        void SetTarget(ParameterTarget newTarget)
+        {
+            m_Target.FindPropertyRelative("component").objectReferenceValue = newTarget.component;
+            m_Target.FindPropertyRelative("propertyName").stringValue = newTarget.propertyName;
+            m_Target.FindPropertyRelative("fieldOrProperty").intValue = (int)newTarget.fieldOrProperty;
+            m_SerializedProperty.serializedObject.ApplyModifiedProperties();
+            m_TargetPropertyMenu.text = TargetPropertyDisplayText(newTarget.component, newTarget.propertyName);
+        }
+
+        static string TargetPropertyDisplayText(Component component, string propertyName)
+        {
+            return $"{component.GetType().Name}.{propertyName}";
+        }
+
+        void FillPropertySelectMenu()
+        {
+            m_TargetPropertyMenu.menu.MenuItems().Clear();
+            var options = GatherPropertyOptions(m_ParameterSampleType);
+            if (options.Count == 0)
+            {
+                m_TargetPropertyMenu.text = "No compatible properties";
+                m_TargetPropertyMenu.SetEnabled(false);
+            }
+            else
+            {
+                m_TargetPropertyMenu.SetEnabled(true);
+                foreach (var option in options)
+                {
+                    m_TargetPropertyMenu.menu.AppendAction(
+                        TargetPropertyDisplayText(option.component, option.propertyName),
+                        a => { SetTarget(option); });
+                }
+                m_TargetPropertyMenu.text = m_TargetProperty.stringValue == string.Empty
+                    ? "Select a property"
+                    : TargetPropertyDisplayText((Component)m_TargetComponent.objectReferenceValue, m_TargetProperty.stringValue);
+            }
+        }
+
+        List<ParameterTarget> GatherPropertyOptions(Type propertyType)
+        {
+            var obj = ((ParameterList)m_SerializedProperty.serializedObject.targetObject).gameObject;
+            var options = new List<ParameterTarget>();
+            foreach (var component in obj.GetComponents<Component>())
+            {
+                if (component == null)
+                    continue;
+                var componentType = component.GetType();
+                var fieldInfos = componentType.GetFields();
+                foreach (var fieldInfo in fieldInfos)
+                {
+                    if (fieldInfo.FieldType == propertyType && fieldInfo.IsPublic && !fieldInfo.IsInitOnly)
+                        options.Add(new ParameterTarget()
+                        {
+                            component = component,
+                            propertyName = fieldInfo.Name,
+                            fieldOrProperty = FieldOrProperty.Field
+                        });
+                }
+
+                var propertyInfos = componentType.GetProperties();
+                foreach (var propertyInfo in propertyInfos)
+                {
+                    if (propertyInfo.PropertyType == propertyType && propertyInfo.GetSetMethod() != null)
+                        options.Add(new ParameterTarget()
+                        {
+                            component = component,
+                            propertyName = propertyInfo.Name,
+                            fieldOrProperty = FieldOrProperty.Property
+                        });
+                }
+            }
+            return options;
+        }
+    }
+}

com.unity.perception/Runtime/Randomization/ParameterBehaviours/Configuration/ParameterList.cs

+using System;
+using System.Collections.Generic;
+using Randomization.ParameterBehaviours;
+using UnityEngine;
+using UnityEngine.Perception.Randomization.Parameters;
+
+namespace UnityEngine.Perception.Randomization.ParameterBehaviours
+{
+    /// <summary>
+    /// Defines a list of parameters for randomizing simulations
+    /// </summary>
+    [ExecuteInEditMode]
+    [AddComponentMenu("Perception/Randomization/Parameter List")]
+    public class ParameterList : ParameterBehaviour
+    {
+        [SerializeReference] internal List<ParameterListItem> configuredParameters = new List<ParameterListItem>();
+
+        public override IEnumerable<Parameter> parameters
+        {
+            get
+            {
+                foreach (var configParameter in configuredParameters)
+                    yield return configParameter.parameter;
+            }
+        }
+
+        internal ParameterListItem AddParameter<T>(string parameterName) where T : Parameter, new()
+        {
+            var parameter = new T();
+            var configParameter = new ParameterListItem { name = parameterName, parameter = parameter };
+            configuredParameters.Add(configParameter);
+            return configParameter;
+        }
+
+        internal ParameterListItem AddParameter(string parameterName, Type parameterType)
+        {
+            if (!parameterType.IsSubclassOf(typeof(Parameter)))
+                throw new ParameterListException($"Cannot add non-parameter types ({parameterType})");
+            var parameter = (Parameter)Activator.CreateInstance(parameterType);
+            var configParameter = new ParameterListItem { name = parameterName, parameter = parameter };
+            configuredParameters.Add(configParameter);
+            return configParameter;
+        }
+
+        /// <summary>
+        /// Find a parameter in this configuration by name
+        /// </summary>
+        /// <param name="parameterName">The name of the parameter to lookup</param>
+        /// <param name="parameterType">The type of parameter to lookup</param>
+        /// <returns>The parameter if found, null otherwise</returns>
+        /// <exception cref="ParameterListException"></exception>
+        public Parameter GetParameter(string parameterName, Type parameterType)
+        {
+            foreach (var configParameter in configuredParameters)
+            {
+                if (configParameter.name == parameterName && configParameter.parameter.GetType() ==  parameterType)
+                    return configParameter.parameter;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Find a parameter in this configuration by name and type
+        /// </summary>
+        /// <param name="parameterName"></param>
+        /// <typeparam name="T">The type of parameter to look for</typeparam>
+        /// <returns>The parameter if found, null otherwise</returns>
+        public T GetParameter<T>(string parameterName) where T : Parameter
+        {
+            foreach (var configuredParameter in configuredParameters)
+            {
+                if (configuredParameter.name == parameterName && configuredParameter.parameter is T typedParameter)
+                    return typedParameter;
+            }
+            return null;
+        }
+
+        public override void OnIterationStart()
+        {
+            foreach (var configParameter in configuredParameters)
+                if (configParameter.target.applicationFrequency == ParameterApplicationFrequency.OnIterationStart)
+                    configParameter.ApplyToTarget();
+        }
+
+        public override void OnFrameStart()
+        {
+            foreach (var configParameter in configuredParameters)
+                if (configParameter.target.applicationFrequency == ParameterApplicationFrequency.EveryFrame)
+                    configParameter.ApplyToTarget();
+        }
+
+        public override void Validate()
+        {
+            var parameterNames = new HashSet<string>();
+            foreach (var configParameter in configuredParameters)
+            {
+                if (parameterNames.Contains(configParameter.name))
+                    throw new ParameterListException(
+                        $"Two or more parameters cannot share the same name (\"{configParameter.name}\")");
+                parameterNames.Add(configParameter.name);
+                configParameter.Validate();
+            }
+        }
+    }
+}

com.unity.perception/Runtime/Randomization/ParameterBehaviours/Configuration/ParameterListException.cs

+using System;
+
+namespace UnityEngine.Perception.Randomization.ParameterBehaviours
+{
+    [Serializable]
+    class ParameterListException : Exception
+    {
+        public ParameterListException(string message) : base(message) { }
+        public ParameterListException(string message, Exception innerException) : base(message, innerException) { }
+    }
+}

com.unity.perception/Runtime/Randomization/ParameterBehaviours/Configuration/ParameterListItem.cs

+using System;
+using UnityEngine.Perception.Randomization.Parameters;
+
+namespace UnityEngine.Perception.Randomization.ParameterBehaviours
+{
+    [Serializable]
+    class ParameterListItem
+    {
+        public string name = "Parameter";
+        [SerializeReference] public Parameter parameter;
+        [HideInInspector, SerializeField] public ParameterTarget target = new ParameterTarget();
+
+        public bool hasTarget => target.component != null;
+
+        public void ApplyToTarget()
+        {
+            if (!hasTarget)
+                return;
+            target.ApplyValueToTarget(parameter.GenericSample());
+        }
+
+        public void Validate()
+        {
+            target.Validate();
+            parameter.Validate();
+        }
+    }
+}

com.unity.perception/Editor/Randomization/VisualElements/ConfiguredParameterElement.cs

-using System;
-using System.Collections.Generic;
-using UnityEditor;
-using UnityEditor.UIElements;
-using UnityEngine.Perception.Randomization.ParameterBehaviours.Configuration;
-using UnityEngine.Perception.Randomization.Parameters;
-using UnityEngine.UIElements;
-
-namespace UnityEngine.Perception.Randomization.Editor
-{
-    class ConfiguredParameterElement : VisualElement
-    {
-        bool m_Filtered;
-        Type m_ParameterSampleType;
-
-        VisualElement m_Properties;
-        VisualElement m_TargetContainer;
-        ToolbarMenu m_TargetPropertyMenu;
-        SerializedProperty m_SerializedProperty;
-        SerializedProperty m_Collapsed;
-        SerializedProperty m_Target;
-        SerializedProperty m_TargetGameObject;
-        SerializedProperty m_TargetComponent;
-        SerializedProperty m_TargetProperty;
-
-        const string k_CollapsedParameterClass = "collapsed-parameter";
-
-        public ParameterConfigurationEditor configEditor { get; private set; }
-
-        public int ParameterIndex => parent.IndexOf(this);
-
-        public bool collapsed
-        {
-            get => m_Collapsed.boolValue;
-            set
-            {
-                m_Collapsed.boolValue = value;
-                m_SerializedProperty.serializedObject.ApplyModifiedProperties();
-                if (value)
-                    AddToClassList(k_CollapsedParameterClass);
-                else
-                    RemoveFromClassList(k_CollapsedParameterClass);
-            }
-        }
-
-        public bool filtered
-        {
-            get => m_Filtered;
-            set
-            {
-                m_Filtered = value;
-                style.display = value
-                    ? new StyleEnum<DisplayStyle>(DisplayStyle.Flex)
-                    : new StyleEnum<DisplayStyle>(DisplayStyle.None);
-            }
-        }
-
-        public ConfiguredParameterElement(SerializedProperty property, ParameterConfigurationEditor config)
-        {
-            configEditor = config;
-            var template = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(
-                $"{StaticData.uxmlDir}/ConfiguredParameterElement.uxml");
-            template.CloneTree(this);
-
-            m_SerializedProperty = property;
-            var parameterProperty = m_SerializedProperty.FindPropertyRelative("parameter");
-            var parameter = (Parameter)StaticData.GetManagedReferenceValue(parameterProperty);
-            m_ParameterSampleType = parameter.sampleType;
-            m_Collapsed = parameterProperty.FindPropertyRelative("collapsed");
-            m_Target = m_SerializedProperty.FindPropertyRelative("target");
-            m_TargetGameObject = m_Target.FindPropertyRelative("gameObject");
-            m_TargetComponent = m_Target.FindPropertyRelative("component");
-            m_TargetProperty = m_Target.FindPropertyRelative("property");
-
-            this.AddManipulator(new ParameterDragManipulator());
-
-            var removeButton = this.Q<Button>("remove-parameter");
-            removeButton.RegisterCallback<MouseUpEvent>(evt => configEditor.RemoveParameter(this));
-
-            var parameterTypeLabel = this.Query<Label>("parameter-type-label").First();
-            parameterTypeLabel.text = Parameter.GetDisplayName(parameter.GetType());
-
-            var parameterNameField = this.Q<TextField>("name");
-            parameterNameField.isDelayed = true;
-            parameterNameField.BindProperty(m_SerializedProperty.FindPropertyRelative("name"));
-
-            m_TargetContainer = this.Q<VisualElement>("target-container");
-            m_TargetPropertyMenu = this.Q<ToolbarMenu>("property-select-menu");
-
-            ToggleTargetContainer();
-
-            var frequencyField = this.Q<EnumField>("application-frequency");
-            frequencyField.Init(ParameterApplicationFrequency.OnIterationStart);
-            var applicationFrequency = m_Target.FindPropertyRelative("applicationFrequency");
-            frequencyField.BindProperty(applicationFrequency);
-
-            var targetField = this.Q<ObjectField>("target");
-            targetField.objectType = typeof(GameObject);
-            targetField.value = m_TargetGameObject.objectReferenceValue;
-            targetField.RegisterCallback<ChangeEvent<Object>>(evt =>
-            {
-                ClearTarget();
-                var appFreqEnumIndex = applicationFrequency.intValue;
-                m_TargetGameObject.objectReferenceValue = (GameObject)evt.newValue;
-                applicationFrequency.intValue = appFreqEnumIndex;
-                m_SerializedProperty.serializedObject.ApplyModifiedProperties();
-                ToggleTargetContainer();
-                FillPropertySelectMenu();
-            });
-            FillPropertySelectMenu();
-
-            var collapseToggle = this.Q<VisualElement>("collapse");
-            collapseToggle.RegisterCallback<MouseUpEvent>(evt => collapsed = !collapsed);
-
-            var parameterProperties = this.Q<VisualElement>("properties");
-            parameterProperties.Add(new ParameterElement(m_SerializedProperty.FindPropertyRelative("parameter")));
-        }
-
-        void ToggleTargetContainer()
-        {
-            m_TargetContainer.style.display = m_TargetGameObject.objectReferenceValue == null
-                ? new StyleEnum<DisplayStyle>(DisplayStyle.None)
-                : new StyleEnum<DisplayStyle>(DisplayStyle.Flex);
-        }
-
-        void ClearTarget()
-        {
-            m_Target.FindPropertyRelative("component").objectReferenceValue = null;
-            m_Target.FindPropertyRelative("propertyName").stringValue = string.Empty;
-            m_SerializedProperty.serializedObject.ApplyModifiedProperties();
-        }
-
-        void SetTarget(ParameterTarget newTarget)
-        {
-            m_TargetGameObject.objectReferenceValue = newTarget.gameObject;
-            m_Target.FindPropertyRelative("component").objectReferenceValue = newTarget.component;
-            m_Target.FindPropertyRelative("propertyName").stringValue = newTarget.propertyName;
-            m_Target.FindPropertyRelative("fieldOrProperty").intValue = (int)newTarget.fieldOrProperty;
-            m_SerializedProperty.serializedObject.ApplyModifiedProperties();
-            m_TargetPropertyMenu.text = TargetPropertyDisplayText(newTarget.component, newTarget.propertyName);
-        }
-
-        static string TargetPropertyDisplayText(Component component, string propertyName)
-        {
-            return $"{component.GetType().Name}.{propertyName}";
-        }
-
-        void FillPropertySelectMenu()
-        {
-            if (m_TargetGameObject.objectReferenceValue == null)
-                return;
-
-            m_TargetPropertyMenu.menu.MenuItems().Clear();
-            var options = GatherPropertyOptions((GameObject)m_TargetGameObject.objectReferenceValue, m_ParameterSampleType);
-            if (options.Count == 0)
-            {
-                m_TargetPropertyMenu.text = "No compatible properties";
-                m_TargetPropertyMenu.SetEnabled(false);
-            }
-            else
-            {
-                m_TargetPropertyMenu.SetEnabled(true);
-                foreach (var option in options)
-                {
-                    m_TargetPropertyMenu.menu.AppendAction(
-                        TargetPropertyDisplayText(option.component, option.propertyName),
-                        a => { SetTarget(option); });
-                }
-                m_TargetPropertyMenu.text = m_TargetProperty.stringValue == string.Empty
-                    ? "Select a property"
-                    : TargetPropertyDisplayText((Component)m_TargetComponent.objectReferenceValue, m_TargetProperty.stringValue);
-            }
-        }
-
-        static List<ParameterTarget> GatherPropertyOptions(GameObject obj, Type propertyType)
-        {
-            var options = new List<ParameterTarget>();
-            foreach (var component in obj.GetComponents<Component>())
-            {
-                if (component == null)
-                    continue;
-                var componentType = component.GetType();
-                var fieldInfos = componentType.GetFields();
-                foreach (var fieldInfo in fieldInfos)
-                {
-                    if (fieldInfo.FieldType == propertyType && fieldInfo.IsPublic && !fieldInfo.IsInitOnly)
-                        options.Add(new ParameterTarget()
-                        {
-                            gameObject = obj,
-                            component = component,
-                            propertyName = fieldInfo.Name,
-                            fieldOrProperty = FieldOrProperty.Field
-                        });
-                }
-
-                var propertyInfos = componentType.GetProperties();
-                foreach (var propertyInfo in propertyInfos)
-                {
-                    if (propertyInfo.PropertyType == propertyType && propertyInfo.GetSetMethod() != null)
-                        options.Add(new ParameterTarget()
-                        {
-                            gameObject = obj,
-                            component = component,
-                            propertyName = propertyInfo.Name,
-                            fieldOrProperty = FieldOrProperty.Property
-                        });
-                }
-            }
-            return options;
-        }
-    }
-}

com.unity.perception/Runtime/Randomization/ParameterBehaviours/Configuration/ConfiguredParameter.cs

-using System;
-using UnityEngine.Perception.Randomization.Parameters;
-
-namespace UnityEngine.Perception.Randomization.ParameterBehaviours.Configuration
-{
-    [Serializable]
-    class ConfiguredParameter
-    {
-        public string name = "Parameter";
-        [SerializeReference] public Parameter parameter;
-        [HideInInspector, SerializeField] public ParameterTarget target = new ParameterTarget();
-
-        public bool hasTarget => target.gameObject != null;
-
-        public void ApplyToTarget()
-        {
-            if (!hasTarget)
-                return;
-            target.ApplyValueToTarget(parameter.GenericSample());
-        }
-
-        public void Validate()
-        {
-            target.Validate();
-            parameter.Validate();
-        }
-    }
-}

com.unity.perception/Runtime/Randomization/ParameterBehaviours/Configuration/ParameterConfiguration.cs

-using System;
-using System.Collections.Generic;
-using Randomization.ParameterBehaviours;
-using UnityEngine;
-using UnityEngine.Perception.Randomization.Parameters;
-
-namespace UnityEngine.Perception.Randomization.ParameterBehaviours.Configuration
-{
-    /// <summary>
-    /// Creates parameter interfaces for randomizing simulations
-    /// </summary>
-    [ExecuteInEditMode]
-    [AddComponentMenu("Perception/Randomization/ParameterConfiguration")]
-    public class ParameterConfiguration : ParameterBehaviour
-    {
-        [SerializeReference] internal List<ConfiguredParameter> configuredParameters = new List<ConfiguredParameter>();
-
-        public override IEnumerable<Parameter> parameters
-        {
-            get
-            {
-                foreach (var configParameter in configuredParameters)
-                    yield return configParameter.parameter;
-            }
-        }
-
-        internal ConfiguredParameter AddParameter<T>(string parameterName) where T : Parameter, new()
-        {
-            var parameter = new T();
-            var configParameter = new ConfiguredParameter { name = parameterName, parameter = parameter };
-            configuredParameters.Add(configParameter);
-            return configParameter;
-        }
-
-        internal ConfiguredParameter AddParameter(string parameterName, Type parameterType)
-        {
-            if (!parameterType.IsSubclassOf(typeof(Parameter)))
-                throw new ParameterConfigurationException($"Cannot add non-parameter types ({parameterType})");
-            var parameter = (Parameter)Activator.CreateInstance(parameterType);
-            var configParameter = new ConfiguredParameter { name = parameterName, parameter = parameter };
-            configuredParameters.Add(configParameter);
-            return configParameter;
-        }
-
-        /// <summary>
-        /// Find a parameter in this configuration by name
-        /// </summary>
-        /// <param name="parameterName">The name of the parameter to lookup</param>
-        /// <param name="parameterType">The type of parameter to lookup</param>
-        /// <returns>The parameter if found, null otherwise</returns>
-        /// <exception cref="ParameterConfigurationException"></exception>
-        public Parameter GetParameter(string parameterName, Type parameterType)
-        {
-            foreach (var configParameter in configuredParameters)
-            {
-                if (configParameter.name == parameterName && configParameter.parameter.GetType() ==  parameterType)
-                    return configParameter.parameter;
-            }
-            return null;
-        }
-
-        /// <summary>
-        /// Find a parameter in this configuration by name and type
-        /// </summary>
-        /// <param name="parameterName"></param>
-        /// <typeparam name="T">The type of parameter to look for</typeparam>
-        /// <returns>The parameter if found, null otherwise</returns>
-        public T GetParameter<T>(string parameterName) where T : Parameter
-        {
-            foreach (var configuredParameter in configuredParameters)
-            {
-                if (configuredParameter.name == parameterName && configuredParameter.parameter is T typedParameter)
-                    return typedParameter;
-            }
-            return null;
-        }
-
-        public override void OnIterationStart()
-        {
-            foreach (var configParameter in configuredParameters)
-                if (configParameter.target.applicationFrequency == ParameterApplicationFrequency.OnIterationStart)
-                    configParameter.ApplyToTarget();
-        }
-
-        public override void OnFrameStart()
-        {
-            foreach (var configParameter in configuredParameters)
-                if (configParameter.target.applicationFrequency == ParameterApplicationFrequency.EveryFrame)
-                    configParameter.ApplyToTarget();
-        }
-
-        public override void Validate()
-        {
-            var parameterNames = new HashSet<string>();
-            foreach (var configParameter in configuredParameters)
-            {
-                if (parameterNames.Contains(configParameter.name))
-                    throw new ParameterConfigurationException(
-                        $"Two or more parameters cannot share the same name (\"{configParameter.name}\")");
-                parameterNames.Add(configParameter.name);
-                configParameter.Validate();
-            }
-        }
-    }
-}

com.unity.perception/Runtime/Randomization/ParameterBehaviours/Configuration/ParameterConfigurationException.cs

-using System;
-
-namespace UnityEngine.Perception.Randomization.ParameterBehaviours.Configuration
-{
-    [Serializable]
-    class ParameterConfigurationException : Exception
-    {
-        public ParameterConfigurationException(string message) : base(message) { }
-        public ParameterConfigurationException(string message, Exception innerException) : base(message, innerException) { }
-    }
-}