[change] public SensorComponent fields to properties, add custom editor (#3564)

com.unity.ml-agents/CHANGELOG.md

  - The method `GetStepCount()` on the Agent class has been replaced with the property getter `StepCount`
  - `RayPerceptionSensorComponent` and related classes now display the debug gizmos whenever the Agent is selected (not just Play mode).
  - Most fields on `RayPerceptionSensorComponent` can now be changed while the editor is in Play mode. The exceptions to this are fields that affect the number of observations.
+ - Most fields on `CameraSensorComponent` and `RenderTextureSensorComponent` were changed to private and replaced by properties with the same name.
  - Unused static methods from the `Utilities` class (ShiftLeft, ReplaceRange, AddRangeNoAlloc, and GetSensorFloatObservationSize) were removed.
  - The `Agent` class is no longer abstract.
  - SensorBase was moved out of the package and into the Examples directory.

com.unity.ml-agents/Editor/RayPerceptionSensorComponentBaseEditor.cs

             EditorGUI.BeginChangeCheck();
             EditorGUI.indentLevel++;
 
-            EditorGUILayout.PropertyField(so.FindProperty("m_SensorName"), true);
-
-            // Because the number of rays and the tags affect the observation shape,
-            // they are not editable during play mode.
+            // Don't allow certain fields to be modified during play mode.
+            // * SensorName affects the ordering of the Agent's observations
+            // * The number of tags and rays affects the size of the observations.
+                EditorGUILayout.PropertyField(so.FindProperty("m_SensorName"), true);
                 EditorGUILayout.PropertyField(so.FindProperty("m_DetectableTags"), true);
                 EditorGUILayout.PropertyField(so.FindProperty("m_RaysPerDirection"), true);
             }
                 m_RequireSensorUpdate = true;
             }
 
-            UpdateSensorIfDirty();
+            UpdateSensorIfDirty();
         }
 
 

com.unity.ml-agents/Runtime/Policies/BehaviorParameters.cs

         /// <summary>
         /// The team ID for this behavior.
         /// </summary>
-        [HideInInspector]
-        [SerializeField]
-        [FormerlySerializedAs("m_TeamID")]
+        [HideInInspector, SerializeField, FormerlySerializedAs("m_TeamID")]
         public int TeamId;
 
         [FormerlySerializedAs("m_useChildSensors")]

com.unity.ml-agents/Runtime/Sensors/CameraSensor.cs

         SensorCompressionType m_CompressionType;
 
         /// <summary>
+        /// The Camera used for rendering the sensor observations.
+        /// </summary>
+        public Camera camera
+        {
+            get { return m_Camera; }
+            set { m_Camera = value; }
+        }
+
+        /// <summary>
+        /// The compression type used by the sensor.
+        /// </summary>
+        public SensorCompressionType compressionType
+        {
+            get { return m_CompressionType;  }
+            set { m_CompressionType = value; }
+        }
+
+
+        /// <summary>
         /// Creates and returns the camera sensor.
         /// </summary>
         /// <param name="camera">Camera object to capture images from.</param>

com.unity.ml-agents/Runtime/Sensors/CameraSensorComponent.cs

 using UnityEngine;
+using UnityEngine.Serialization;
 
 namespace MLAgents.Sensors
 {
     [AddComponentMenu("ML Agents/Camera Sensor", (int)MenuGroup.Sensors)]
     public class CameraSensorComponent : SensorComponent
     {
+        [HideInInspector, SerializeField, FormerlySerializedAs("camera")]
+        Camera m_Camera;
+
+        CameraSensor m_Sensor;
+
-        public new Camera camera;
+        public new Camera camera
+        {
+            get { return m_Camera;  }
+            set { m_Camera = value; UpdateSensor(); }
+        }
+
+        [HideInInspector, SerializeField, FormerlySerializedAs("sensorName")]
+        string m_SensorName = "CameraSensor";
-        public string sensorName = "CameraSensor";
+        public string sensorName
+        {
+            get { return m_SensorName;  }
+            internal set { m_SensorName = value;  }
+        }
+
+        [HideInInspector, SerializeField, FormerlySerializedAs("width")]
+        int m_Width = 84;
-        /// Width of the generated image.
+        /// Width of the generated observation.
-        public int width = 84;
+        public int width
+        {
+            get { return m_Width;  }
+            internal set { m_Width = value;  }
+        }
+
+        [HideInInspector, SerializeField, FormerlySerializedAs("height")]
+        int m_Height = 84;
-        /// Height of the generated image.
+        /// Height of the generated observation.
-        public int height = 84;
+        public int height
+        {
+            get { return m_Height;  }
+            internal set { m_Height = value;  }
+        }
+
+        [HideInInspector, SerializeField, FormerlySerializedAs("grayscale")]
+        public bool m_Grayscale;
-        public bool grayscale;
+        public bool grayscale
+        {
+            get { return m_Grayscale;  }
+            internal set { m_Grayscale = value;  }
+        }
+
+        [HideInInspector, SerializeField, FormerlySerializedAs("compression")]
+        SensorCompressionType m_Compression = SensorCompressionType.PNG;
-        public SensorCompressionType compression = SensorCompressionType.PNG;
+        public SensorCompressionType compression
+        {
+            get { return m_Compression;  }
+            set { m_Compression = value; UpdateSensor(); }
+        }
 
         /// <summary>
         /// Creates the <see cref="CameraSensor"/>
         {
-            return new CameraSensor(camera, width, height, grayscale, sensorName, compression);
+            m_Sensor = new CameraSensor(m_Camera, m_Width, m_Height, grayscale, m_SensorName, compression);
+            return m_Sensor;
         }
 
         /// <summary>
         public override int[] GetObservationShape()
         {
-            return CameraSensor.GenerateShape(width, height, grayscale);
+            return CameraSensor.GenerateShape(m_Width, m_Height, grayscale);
+        }
+
+        /// <summary>
+        /// Update fields that are safe to change on the Sensor at runtime.
+        /// </summary>
+        internal void UpdateSensor()
+        {
+            if (m_Sensor != null)
+            {
+                m_Sensor.camera = m_Camera;
+                m_Sensor.compressionType = m_Compression;
+            }
         }
     }
 }

com.unity.ml-agents/Runtime/Sensors/RayPerceptionSensorComponent3D.cs

     [AddComponentMenu("ML Agents/Ray Perception Sensor 3D", (int)MenuGroup.Sensors)]
     public class RayPerceptionSensorComponent3D : RayPerceptionSensorComponentBase
     {
-        [HideInInspector]
-        [SerializeField]
-        [FormerlySerializedAs("startVerticalOffset")]
+        [HideInInspector, SerializeField, FormerlySerializedAs("startVerticalOffset")]
         [Range(-10f, 10f)]
         [Tooltip("Ray start is offset up or down by this amount.")]
         float m_StartVerticalOffset;
             set { m_StartVerticalOffset = value; UpdateSensor(); }
         }
 
-        [HideInInspector]
-        [SerializeField]
-        [FormerlySerializedAs("endVerticalOffset")]
+        [HideInInspector, SerializeField, FormerlySerializedAs("endVerticalOffset")]
         [Range(-10f, 10f)]
         [Tooltip("Ray end is offset up or down by this amount.")]
         float m_EndVerticalOffset;

com.unity.ml-agents/Runtime/Sensors/RayPerceptionSensorComponentBase.cs

     /// </summary>
     public abstract class RayPerceptionSensorComponentBase : SensorComponent
     {
-        [HideInInspector]
-        [SerializeField]
-        [FormerlySerializedAs("sensorName")]
+        [HideInInspector, SerializeField, FormerlySerializedAs("sensorName")]
         string m_SensorName = "RayPerceptionSensor";
 
         /// <summary>
             internal set => m_SensorName = value;
         }
 
-        [SerializeField]
-        [FormerlySerializedAs("detectableTags")]
+        [SerializeField, FormerlySerializedAs("detectableTags")]
         [Tooltip("List of tags in the scene to compare against.")]
         List<string> m_DetectableTags;
 
             internal set => m_DetectableTags = value;
         }
 
-        [HideInInspector]
-        [SerializeField]
-        [FormerlySerializedAs("raysPerDirection")]
+        [HideInInspector, SerializeField, FormerlySerializedAs("raysPerDirection")]
         [Range(0, 50)]
         [Tooltip("Number of rays to the left and right of center.")]
         int m_RaysPerDirection = 3;
             internal set => m_RaysPerDirection = value;
         }
 
-        [HideInInspector]
-        [SerializeField]
-        [FormerlySerializedAs("maxRayDegrees")]
+        [HideInInspector, SerializeField, FormerlySerializedAs("maxRayDegrees")]
         [Range(0, 180)]
         [Tooltip("Cone size for rays. Using 90 degrees will cast rays to the left and right. " +
                  "Greater than 90 degrees will go backwards.")]
             set { m_MaxRayDegrees = value; UpdateSensor(); }
         }
 
-        [HideInInspector]
-        [SerializeField]
-        [FormerlySerializedAs("sphereCastRadius")]
+        [HideInInspector, SerializeField, FormerlySerializedAs("sphereCastRadius")]
         [Range(0f, 10f)]
         [Tooltip("Radius of sphere to cast. Set to zero for raycasts.")]
         float m_SphereCastRadius = 0.5f;
             set { m_SphereCastRadius = value; UpdateSensor(); }
         }
 
-        [HideInInspector]
-        [SerializeField]
-        [FormerlySerializedAs("rayLength")]
+        [HideInInspector, SerializeField, FormerlySerializedAs("rayLength")]
         [Range(1, 1000)]
         [Tooltip("Length of the rays to cast.")]
         float m_RayLength = 20f;
             set { m_RayLength = value; UpdateSensor(); }
         }
 
-        [HideInInspector]
-        [SerializeField]
-        [FormerlySerializedAs("rayLayerMask")]
+        [HideInInspector, SerializeField, FormerlySerializedAs("rayLayerMask")]
         [Tooltip("Controls which layers the rays can hit.")]
         LayerMask m_RayLayerMask = Physics.DefaultRaycastLayers;
 
             set { m_RayLayerMask = value; UpdateSensor();}
         }
 
-        [HideInInspector]
-        [SerializeField]
-        [FormerlySerializedAs("observationStacks")]
+        [HideInInspector, SerializeField, FormerlySerializedAs("observationStacks")]
         [Range(1, 50)]
         [Tooltip("Whether to stack previous observations. Using 1 means no previous observations.")]
         int m_ObservationStacks = 1;

com.unity.ml-agents/Runtime/Sensors/RenderTextureSensor.cs

         SensorCompressionType m_CompressionType;
 
         /// <summary>
+        /// The compression type used by the sensor.
+        /// </summary>
+        public SensorCompressionType compressionType
+        {
+            get { return m_CompressionType;  }
+            set { m_CompressionType = value; }
+        }
+
+
+        /// <summary>
         /// Initializes the sensor.
         /// </summary>
         /// <param name="renderTexture">The <see cref="RenderTexture"/> instance to wrap.</param>

com.unity.ml-agents/Runtime/Sensors/RenderTextureSensorComponent.cs

 using UnityEngine;
+using UnityEngine.Serialization;
 
 namespace MLAgents.Sensors
 {
     [AddComponentMenu("ML Agents/Render Texture Sensor", (int)MenuGroup.Sensors)]
     public class RenderTextureSensorComponent : SensorComponent
     {
+        RenderTextureSensor m_Sensor;
+
-        public RenderTexture renderTexture;
+        [HideInInspector, SerializeField, FormerlySerializedAs("renderTexture")]
+        RenderTexture m_RenderTexture;
+
+        public RenderTexture renderTexture
+        {
+            get { return m_RenderTexture;  }
+            set { m_RenderTexture = value;  }
+        }
+
+        [HideInInspector, SerializeField, FormerlySerializedAs("sensorName")]
+        string m_SensorName = "RenderTextureSensor";
-        /// Name of the sensor.
+        /// Name of the generated <see cref="RenderTextureSensor"/>.
-        public string sensorName = "RenderTextureSensor";
+        public string sensorName
+        {
+            get { return m_SensorName;  }
+            internal set { m_SensorName = value;  }
+        }
+
+        [HideInInspector, SerializeField, FormerlySerializedAs("grayscale")]
+        public bool m_Grayscale;
-        public bool grayscale;
+        public bool grayscale
+        {
+            get { return m_Grayscale;  }
+            internal set { m_Grayscale = value;  }
+        }
+
+        [HideInInspector, SerializeField, FormerlySerializedAs("compression")]
+        SensorCompressionType m_Compression = SensorCompressionType.PNG;
-        public SensorCompressionType compression = SensorCompressionType.PNG;
+        public SensorCompressionType compression
+        {
+            get { return m_Compression;  }
+            set { m_Compression = value; UpdateSensor(); }
+        }
-            return new RenderTextureSensor(renderTexture, grayscale, sensorName, compression);
+            m_Sensor = new RenderTextureSensor(renderTexture, grayscale, sensorName, compression);
+            return m_Sensor;
         }
 
         /// <inheritdoc/>
             var height = renderTexture != null ? renderTexture.height : 0;
 
             return new[] { height, width, grayscale ? 1 : 3 };
+        }
+
+        /// <summary>
+        /// Update fields that are safe to change on the Sensor at runtime.
+        /// </summary>
+        internal void UpdateSensor()
+        {
+            if (m_Sensor != null)
+            {
+                m_Sensor.compressionType = m_Compression;
+            }
         }
     }
 }

com.unity.ml-agents/Editor/CameraSensorComponentEditor.cs

+using UnityEngine;
+using UnityEditor;
+using MLAgents.Sensors;
+
+namespace MLAgents.Editor
+{
+    [CustomEditor(typeof(CameraSensorComponent))]
+    [CanEditMultipleObjects]
+    internal class CameraSensorComponentEditor : UnityEditor.Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            var so = serializedObject;
+            so.Update();
+
+            // Drawing the CameraSensorComponent
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.PropertyField(so.FindProperty("m_Camera"), true);
+            EditorGUI.BeginDisabledGroup(Application.isPlaying);
+            {
+                // These fields affect the sensor order or observation size,
+                // So can't be changed at runtime.
+                EditorGUILayout.PropertyField(so.FindProperty("m_SensorName"), true);
+                EditorGUILayout.PropertyField(so.FindProperty("m_Width"), true);
+                EditorGUILayout.PropertyField(so.FindProperty("m_Height"), true);
+                EditorGUILayout.PropertyField(so.FindProperty("m_Grayscale"), true);
+            }
+            EditorGUI.EndDisabledGroup();
+            EditorGUILayout.PropertyField(so.FindProperty("m_Compression"), true);
+
+            var requireSensorUpdate = EditorGUI.EndChangeCheck();
+            so.ApplyModifiedProperties();
+
+            if (requireSensorUpdate)
+            {
+                UpdateSensor();
+            }
+        }
+
+        void UpdateSensor()
+        {
+            var sensorComponent = serializedObject.targetObject as CameraSensorComponent;
+            sensorComponent?.UpdateSensor();
+        }
+
+    }
+}

com.unity.ml-agents/Editor/CameraSensorComponentEditor.cs.meta

+fileFormatVersion: 2
+guid: fdda773c024894cf0ae47d1b1396c38d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.ml-agents/Editor/RenderTextureSensorComponentEditor.cs

+using UnityEngine;
+using UnityEditor;
+using MLAgents.Sensors;
+namespace MLAgents.Editor
+{
+    [CustomEditor(typeof(RenderTextureSensorComponent))]
+    [CanEditMultipleObjects]
+    internal class RenderTextureSensorComponentEditor : UnityEditor.Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            var so = serializedObject;
+            so.Update();
+
+            // Drawing the RenderTextureComponent
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUI.BeginDisabledGroup(Application.isPlaying);
+            {
+                EditorGUILayout.PropertyField(so.FindProperty("m_RenderTexture"), true);
+                EditorGUILayout.PropertyField(so.FindProperty("m_SensorName"), true);
+                EditorGUILayout.PropertyField(so.FindProperty("m_Grayscale"), true);
+            }
+            EditorGUI.EndDisabledGroup();
+
+            EditorGUILayout.PropertyField(so.FindProperty("m_Compression"), true);
+
+            var requireSensorUpdate = EditorGUI.EndChangeCheck();
+            so.ApplyModifiedProperties();
+
+            if (requireSensorUpdate)
+            {
+                UpdateSensor();
+            }
+        }
+
+        void UpdateSensor()
+        {
+            var sensorComponent = serializedObject.targetObject as RenderTextureSensorComponent;
+            sensorComponent?.UpdateSensor();
+        }
+    }
+}

com.unity.ml-agents/Editor/RenderTextureSensorComponentEditor.cs.meta

+fileFormatVersion: 2
+guid: dab309e01d2964f0792de3ef914ca6b9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: