first commit

TestProjects/PerceptionURP/Assets/Rotator.cs

-using UnityEngine;
+using System;
+using UnityEngine;
+using UnityEngine.Rendering;
-
+    DateTime prev = DateTime.Now;
+    double[] difs = new double[1000];
+    int count = 0;
+        var now = DateTime.Now;
+        var dif = now - prev;
+        prev = now;
+        if (count < difs.Length)
+        {
+            difs[count] = dif.TotalMilliseconds;
+        }
+        else
+        {
+            Debug.Log("DIFS==================");
+            for (int i = 0; i < difs.Length; i++)
+            {
+                Debug.Log(difs[i]+"\n");
+            }
+        }
+
+        count++;
     }
 }

TestProjects/PerceptionURP/Assets/Scenes/SampleScene.unity

     m_TrainingDataDestination: TrainingData
     m_LightProbeSampleCountMultiplier: 4
   m_LightingDataAsset: {fileID: 0}
-  m_UseShadowmask: 0
+  m_UseShadowmask: 1
 --- !u!196 &4
 NavMeshSettings:
   serializedVersion: 2
   m_EditorClassIdentifier: 
   labels:
   - Crate
+  useAutoLabeling: 0
+  autoLabelingSchemeType: 
 --- !u!65 &411238278
 BoxCollider:
   m_ObjectHideFlags: 0
   m_EditorClassIdentifier: 
   labels:
   - Cube
+  useAutoLabeling: 0
+  autoLabelingSchemeType: 
 --- !u!65 &934158984
 BoxCollider:
   m_ObjectHideFlags: 0
   - component: {fileID: 963194226}
   - component: {fileID: 963194230}
   - component: {fileID: 963194231}
+  - component: {fileID: 963194229}
   m_Layer: 0
   m_Name: Main Camera
   m_TagString: MainCamera
   m_Father: {fileID: 0}
   m_RootOrder: 4
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &963194229
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 963194225}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 172515602e62fb746b5d573b38a5fe58, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  isGlobal: 1
+  priority: 0
+  blendDistance: 0
+  weight: 1
+  sharedProfile: {fileID: 11400000, guid: f416044e9f33b4211898fb62f3da67d3, type: 2}
 --- !u!114 &963194230
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_Name: 
   m_EditorClassIdentifier: 
   description: The main camera
-  period: 0.0166
-  startTime: 0
+  period: 0.016
+  startTime: 4.4
+  scheduledCapture: 0
+  ControlSimulationTiming: 0
-  showVisualizations: 1
+  showVisualizations: 0
   references:
     version: 1
     00000000:
     serializedVersion: 2
     m_Bits: 1
   m_VolumeTrigger: {fileID: 0}
-  m_RenderPostProcessing: 0
+  m_RenderPostProcessing: 1
   m_Antialiasing: 0
   m_AntialiasingQuality: 2
   m_StopNaN: 0
   m_EditorClassIdentifier: 
   labels:
   - Box
+  useAutoLabeling: 0
+  autoLabelingSchemeType: 
 --- !u!65 &1640252280
 BoxCollider:
   m_ObjectHideFlags: 0
   m_EditorClassIdentifier: 
   labels:
   - Terrain
+  useAutoLabeling: 0
+  autoLabelingSchemeType: 

TestProjects/PerceptionURP/Packages/packages-lock.json

 {
   "dependencies": {
     "com.unity.burst": {
-      "version": "1.3.0-preview.5",
-      "depth": 2,
+      "version": "1.3.9",
+      "depth": 1,
-        "com.unity.mathematics": "1.1.0"
+        "com.unity.mathematics": "1.2.1"
       },
       "url": "https://packages.unity.com"
     },
       "url": "https://packages.unity.com"
     },
     "com.unity.mathematics": {
-      "version": "1.1.0",
+      "version": "1.2.1",
       "depth": 2,
       "source": "registry",
       "dependencies": {},
       "dependencies": {
         "com.unity.nuget.newtonsoft-json": "1.1.2",
         "com.unity.render-pipelines.core": "7.1.6",
+        "com.unity.burst": "1.3.9",
-        "com.unity.simulation.capture": "0.0.10-preview.13",
-        "com.unity.simulation.core": "0.0.10-preview.19"
+        "com.unity.simulation.capture": "0.0.10-preview.14",
+        "com.unity.simulation.core": "0.0.10-preview.20"
       }
     },
     "com.unity.platforms": {
       "url": "https://packages.unity.com"
     },
     "com.unity.simulation.capture": {
-      "version": "0.0.10-preview.13",
-      "depth": 0,
+      "version": "0.0.10-preview.14",
+      "depth": 1,
       "source": "registry",
       "dependencies": {
         "com.unity.simulation.core": "0.0.10-preview.19"
       "url": "https://packages.unity.com"
     },
     "com.unity.simulation.core": {
-      "version": "0.0.10-preview.19",
-      "depth": 0,
+      "version": "0.0.10-preview.20",
+      "depth": 1,
       "source": "registry",
       "dependencies": {},
       "url": "https://packages.unity.com"

TestProjects/PerceptionURP/ProjectSettings/QualitySettings.asset

     skinWeights: 2
     textureQuality: 0
     anisotropicTextures: 1
-    antiAliasing: 2
+    antiAliasing: 0
     softParticles: 0
     softVegetation: 1
     realtimeReflectionProbes: 1

com.unity.perception/Editor/GroundTruth/PerceptionCameraEditor.cs

                 EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(perceptionCamera.startTime)), new GUIContent("Start Time","Time at which this perception camera starts rendering and capturing (seconds)."));
                 EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(perceptionCamera.showVisualizations)), new GUIContent("Show Labeler Visualizations", "Display realtime visualizations for labelers that are currently active on this perception camera."));
                 EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(perceptionCamera.captureRgbImages)),new GUIContent("Save Camera Output to Disk", "For each captured frame, save an RGB image of the perception camera's output to disk."));
+                EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(perceptionCamera.scheduledCapture)),new GUIContent("Scheduled Capture", ""));
+                EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(perceptionCamera.affectSimulationTiming)),new GUIContent("Affect Simulation Timings", ""));
                 serializedObject.ApplyModifiedProperties();
 
                 //EditorGUILayout.PropertyField(serializedObject.FindProperty(nameof(PerceptionCamera.labelers)));

com.unity.perception/Runtime/GroundTruth/DatasetCapture.cs

         /// <param name="description">A human-readable description of the sensor (ex. "front-left rgb camera")</param>
         /// <param name="period">The period, in seconds, on which the sensor should capture. Frames will be scheduled in the simulation such that each sensor is triggered every _period_ seconds.</param>
         /// <param name="firstCaptureTime">The time, in seconds, from the start of the sequence on which this sensor should first be scheduled.</param>
+        /// <param name="autoCapture"></param>
+        /// <param name="controlSimulationTiming"></param>
-        public static SensorHandle RegisterSensor(EgoHandle egoHandle, string modality, string description, float period, float firstCaptureTime)
+        public static SensorHandle RegisterSensor(EgoHandle egoHandle, string modality, string description, float period, float firstCaptureTime, bool autoCapture, bool controlSimulationTiming)
-            SimulationState.AddSensor(egoHandle, modality, description, period, firstCaptureTime, sensor);
+            SimulationState.AddSensor(egoHandle, modality, description, period, firstCaptureTime, autoCapture, controlSimulationTiming, sensor);
             return sensor;
         }
 
         /// <exception cref="ArgumentException">Thrown if the given AnnotationDefinition is invalid.</exception>
         public Annotation ReportAnnotationFile(AnnotationDefinition annotationDefinition, string filename)
         {
-            if (!ShouldCaptureThisFrame)
-                throw new InvalidOperationException("Annotation reported on SensorHandle in frame when its ShouldCaptureThisFrame is false.");
+            // if (!ShouldCaptureThisFrame)
+            //     throw new InvalidOperationException("Annotation reported on SensorHandle in frame when its ShouldCaptureThisFrame is false.");
             if (!annotationDefinition.IsValid)
                 throw new ArgumentException("The given annotationDefinition is invalid", nameof(annotationDefinition));
 
         /// <exception cref="ArgumentException">Thrown if the given AnnotationDefinition is invalid.</exception>
         public Annotation ReportAnnotationValues<T>(AnnotationDefinition annotationDefinition, T[] values)
         {
-            if (!ShouldCaptureThisFrame)
-                throw new InvalidOperationException("Annotation reported on SensorHandle in frame when its ShouldCaptureThisFrame is false.");
+            // if (!ShouldCaptureThisFrame)
+            //     throw new InvalidOperationException("Annotation reported on SensorHandle in frame when its ShouldCaptureThisFrame is false.");
             if (!annotationDefinition.IsValid)
                 throw new ArgumentException("The given annotationDefinition is invalid", nameof(annotationDefinition));
 
         /// <exception cref="ArgumentException">Thrown if the given AnnotationDefinition is invalid.</exception>
         public AsyncAnnotation ReportAnnotationAsync(AnnotationDefinition annotationDefinition)
         {
-            if (!ShouldCaptureThisFrame)
-                throw new InvalidOperationException("Annotation reported on SensorHandle in frame when its ShouldCaptureThisFrame is false.");
+            // if (!ShouldCaptureThisFrame)
+            //     throw new InvalidOperationException("Annotation reported on SensorHandle in frame when its ShouldCaptureThisFrame is false.");
             if (!annotationDefinition.IsValid)
                 throw new ArgumentException("The given annotationDefinition is invalid", nameof(annotationDefinition));
 
         /// <exception cref="InvalidOperationException">Thrown if ReportCapture is being called when ShouldCaptureThisFrame is false or it has already been called this frame.</exception>
         public void ReportCapture(string filename, SensorSpatialData sensorSpatialData, params(string, object)[] additionalSensorValues)
         {
-            if (!ShouldCaptureThisFrame)
-            {
-                throw new InvalidOperationException("Capture reported in frame when ShouldCaptureThisFrame is false.");
-            }
+            // if (!ShouldCaptureThisFrame)
+            // {
+            //     throw new InvalidOperationException("Capture reported in frame when ShouldCaptureThisFrame is false.");
+            // }
 
             DatasetCapture.SimulationState.ReportCapture(this, filename, sensorSpatialData, additionalSensorValues);
         }
         /// </summary>
         public bool ShouldCaptureThisFrame => DatasetCapture.SimulationState.ShouldCaptureThisFrame(this);
 
+        public void CaptureOnNextUpdate()
+        {
+            DatasetCapture.SimulationState.ExternalCaptureRequestForSensor(this);
+        }
+
         /// <summary>
         /// Report a metric regarding this sensor in the current frame.
         /// </summary>
             if (values == null)
                 throw new ArgumentNullException(nameof(values));
 
-            if (!ShouldCaptureThisFrame)
-                throw new InvalidOperationException($"Sensor-based metrics may only be reported when SensorHandle.ShouldCaptureThisFrame is true");
+            // if (!ShouldCaptureThisFrame)
+            //     throw new InvalidOperationException($"Sensor-based metrics may only be reported when SensorHandle.ShouldCaptureThisFrame is true");
 
             DatasetCapture.SimulationState.ReportMetric(metricDefinition, values, this, default);
         }
         /// <exception cref="InvalidOperationException">Thrown if <see cref="ShouldCaptureThisFrame"/> is false.</exception>
         public void ReportMetric(MetricDefinition metricDefinition, [NotNull] string valuesJsonArray)
         {
-            if (!ShouldCaptureThisFrame)
-                throw new InvalidOperationException($"Sensor-based metrics may only be reported when SensorHandle.ShouldCaptureThisFrame is true");
+            // if (!ShouldCaptureThisFrame)
+            //     throw new InvalidOperationException($"Sensor-based metrics may only be reported when SensorHandle.ShouldCaptureThisFrame is true");
 
             DatasetCapture.SimulationState.ReportMetric(metricDefinition, new JRaw(valuesJsonArray), this, default);
         }
         /// <returns>An <see cref="AsyncMetric"/> which should be used to report the metric values, potentially in a later frame</returns>
         public AsyncMetric ReportMetricAsync(MetricDefinition metricDefinition)
         {
-            if (!ShouldCaptureThisFrame)
-                throw new InvalidOperationException($"Sensor-based metrics may only be reported when SensorHandle.ShouldCaptureThisFrame is true");
+            // if (!ShouldCaptureThisFrame)
+            //     throw new InvalidOperationException($"Sensor-based metrics may only be reported when SensorHandle.ShouldCaptureThisFrame is true");
 
             return DatasetCapture.SimulationState.CreateAsyncMetric(metricDefinition, this);
         }

com.unity.perception/Runtime/GroundTruth/Labelers/Visualization/OverlayPanel.cs

             m_BackgroundTransparency = GUILayout.HorizontalSlider(m_BackgroundTransparency, 0.0f, 1.0f, m_SliderStyle, GUI.skin.horizontalSliderThumb);
             GUI.skin.label.padding.left = 0;
 
+            if (GUILayout.Button("Capture"))
+            {
+                perceptionCamera.SensorHandle.CaptureOnNextUpdate();
+            }
+
             // Grab the overlay image from the active provider
             m_OverlayImage.texture = m_ActiveProvider?.overlayImage;
 

com.unity.perception/Runtime/GroundTruth/PerceptionCamera.cs

         /// </summary>
         public Camera attachedCamera => m_AttachedCamera;
 
+        public bool scheduledCapture;
+
+        public bool affectSimulationTiming;
+
         /// <summary>
         /// Event invoked after the camera finishes rendering during a frame.
         /// </summary>
             {
                 m_EgoMarker = GetComponentInParent<Ego>();
                 var ego = m_EgoMarker == null ? DatasetCapture.RegisterEgo("") : m_EgoMarker.EgoHandle;
-                SensorHandle = DatasetCapture.RegisterSensor(ego, "camera", description, period, startTime);
+                SensorHandle = DatasetCapture.RegisterSensor(ego, "camera", description, period, startTime, scheduledCapture, affectSimulationTiming);
             }
         }
 
             if (!SensorHandle.IsValid)
                 return;
 
-            m_AttachedCamera.enabled = SensorHandle.ShouldCaptureThisFrame;
+            //m_AttachedCamera.enabled = SensorHandle.ShouldCaptureThisFrame;
 
             bool anyVisualizing = false;
             foreach (var labeler in m_Labelers)
                 return;
 #endif
             CaptureRgbData(cam);
+            Debug.Log("===================== CAPTURING");
 
             foreach (var labeler in m_Labelers)
             {

com.unity.perception/Runtime/GroundTruth/SimulationState.cs

             public string description;
             public float period;
             public float firstCaptureTime;
+            public bool autoCapture;
+            public bool controlSimulationTiming;
-            public float sequenceTimeNextCapture;
+            public bool externalCaptureRequestPending;
+            public float sequenceTimeOfNextCapture;
             public int lastCaptureFrameCount;
             public EgoHandle egoHandle;
         }
             foreach (var kvp in m_Sensors.ToArray())
             {
                 var sensorData = kvp.Value;
-                sensorData.sequenceTimeNextCapture = SequenceTimeOfNextCapture(sensorData);
+                sensorData.sequenceTimeOfNextCapture = GetSequenceTimeOfNextCapture(sensorData);
                 m_Sensors[kvp.Key] = sensorData;
             }
 
             m_LastTimeScale = Time.timeScale;
         }
 
-        public void AddSensor(EgoHandle egoHandle, string modality, string description, float period, float firstCaptureTime, SensorHandle sensor)
+        public void AddSensor(EgoHandle egoHandle, string modality, string description, float period, float firstCaptureTime, bool autoCapture, bool controlSimulationTiming, SensorHandle sensor)
         {
             var sensorData = new SensorData()
             {
                 firstCaptureTime = firstCaptureTime,
+                autoCapture = autoCapture,
+                controlSimulationTiming = controlSimulationTiming,
-            sensorData.sequenceTimeNextCapture = SequenceTimeOfNextCapture(sensorData);
+            sensorData.externalCaptureRequestPending = false;
+            sensorData.sequenceTimeOfNextCapture = GetSequenceTimeOfNextCapture(sensorData);
-        float SequenceTimeOfNextCapture(SensorData sensorData)
+        float GetSequenceTimeOfNextCapture(SensorData sensorData)
-            return sensorData.sequenceTimeNextCapture;
+            return sensorData.sequenceTimeOfNextCapture;
         }
 
         public bool Contains(Guid id) => m_Ids.Contains(id);
                 m_HasStarted = true;
             }
 
+            EnsureSequenceTimingsUpdated();
+
-                if (!activeSensor.ShouldCaptureThisFrame)
-                    continue;
+                if (sensorData.autoCapture)
+                {
+                    if (!activeSensor.ShouldCaptureThisFrame)
+                        continue;
-                // TODO: AISV-845 This is an errant modification of this record that can lead to undefined behavior
-                // Leaving as-is for now because too many components depend on this logic
-                sensorData.sequenceTimeNextCapture += sensorData.period;
-                Debug.Assert(sensorData.sequenceTimeNextCapture > UnscaledSequenceTime,
-                    $"Next scheduled capture should be after {UnscaledSequenceTime} but is {sensorData.sequenceTimeNextCapture}");
-                // sensorData.sequenceTimeNextCapture = SequenceTimeOfNextCapture(sensorData);
-                sensorData.lastCaptureFrameCount = Time.frameCount;
-                m_Sensors[activeSensor] = sensorData;
+                    // TODO: AISV-845 This is an errant modification of this record that can lead to undefined behavior
+                    // Leaving as-is for now because too many components depend on this logic
+                    sensorData.sequenceTimeOfNextCapture += sensorData.period;
+                    Debug.Assert(sensorData.sequenceTimeOfNextCapture > UnscaledSequenceTime,
+                        $"Next scheduled capture should be after {UnscaledSequenceTime} but is {sensorData.sequenceTimeOfNextCapture}");
+                    // sensorData.sequenceTimeNextCapture = SequenceTimeOfNextCapture(sensorData);
+                    sensorData.lastCaptureFrameCount = Time.frameCount;
+                    m_Sensors[activeSensor] = sensorData;
+                }
             }
 
             //find the deltatime required to land on the next active sensor that needs simulation
                 var sensorData = m_Sensors[activeSensor];
-                var thisSensorNextFrameDt = sensorData.sequenceTimeNextCapture - UnscaledSequenceTime;
+                if (sensorData.controlSimulationTiming)
+                {
+                    var thisSensorNextFrameDt = sensorData.sequenceTimeOfNextCapture - UnscaledSequenceTime;
+
+                    Debug.Assert(thisSensorNextFrameDt > 0f, "Sensor was scheduled to run in the past but got skipped over.");
+                    if (thisSensorNextFrameDt > 0f && thisSensorNextFrameDt < nextFrameDt)
+                        nextFrameDt = thisSensorNextFrameDt;
+                }
+            }
-                Debug.Assert(thisSensorNextFrameDt > 0f, "Sensor was scheduled to run in the past but got skipped over.");
-                if (thisSensorNextFrameDt > 0f && thisSensorNextFrameDt < nextFrameDt)
-                    nextFrameDt = thisSensorNextFrameDt;
+            if (Math.Abs(nextFrameDt - k_MaxDeltaTime) < 0.00001)
+            {
+                //means no sensor is controlling simulation timing, default to 60fps
+                nextFrameDt = 1f/60;
             }
 
             WritePendingCaptures();
         }
 
+        public void ExternalCaptureRequestForSensor(SensorHandle sensorHandle)
+        {
+            if (!m_Sensors.ContainsKey(sensorHandle))
+                return;
+
+            var data = m_Sensors[sensorHandle];
+            data.externalCaptureRequestPending = true;
+            m_Sensors[sensorHandle] = data;
+        }
+
         public bool ShouldCaptureThisFrame(SensorHandle sensorHandle)
         {
             if (!m_Sensors.ContainsKey(sensorHandle))
             if (data.lastCaptureFrameCount == Time.frameCount)
                 return true;
 
-            return (data.sequenceTimeNextCapture - UnscaledSequenceTime) < k_IncludeInFrameThreshold;
+            bool captureRequested = data.externalCaptureRequestPending;
+            if (captureRequested)
+            {
+                data.externalCaptureRequestPending = false;
+                m_Sensors[sensorHandle] = data;
+            }
+
+            return (data.autoCapture && (data.sequenceTimeOfNextCapture - UnscaledSequenceTime) < k_IncludeInFrameThreshold)
+                || captureRequested;
         }
 
         public void End()

com.unity.perception/Tests/Editor/DatasetCaptureEditorTests.cs

             yield return new EnterPlayMode();
             DatasetCapture.ResetSimulation();
             var ego = DatasetCapture.RegisterEgo("ego");
-            var sensor = DatasetCapture.RegisterSensor(ego, "camera", "", 0.1f, 0);
+            var sensor = DatasetCapture.RegisterSensor(ego, "camera", "", 0.1f, 0, true, true);
             sensor.ReportCapture("file.txt", new SensorSpatialData());
             expectedDatasetPath = DatasetCapture.OutputDirectory;
             yield return new ExitPlayMode();

com.unity.perception/Tests/Runtime/GroundTruthTests/DatasetCaptureSensorSchedulingTests.cs

             var ego = DatasetCapture.RegisterEgo("ego");
             var firstCaptureTime = 1.5f;
             var period = .4f;
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "cam", "", period, firstCaptureTime);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "cam", "", period, firstCaptureTime, true, true);
 
             float[] sequenceTimesExpected =
             {
             var ego = DatasetCapture.RegisterEgo("ego");
             var firstCaptureTime = 1.5f;
             var period = .4f;
-            DatasetCapture.RegisterSensor(ego, "cam", "", period, firstCaptureTime);
+            DatasetCapture.RegisterSensor(ego, "cam", "", period, firstCaptureTime, true, true);
 
             float[] deltaTimeSamplesExpected =
             {
 
             var timeScale = 2;
             Time.timeScale = timeScale;
-            DatasetCapture.RegisterSensor(ego, "cam", "", period, firstCaptureTime);
+            DatasetCapture.RegisterSensor(ego, "cam", "", period, firstCaptureTime, true, true);
 
             float[] deltaTimeSamplesExpected =
             {
         public IEnumerator ChangingTimeScale_CausesDebugError()
         {
             var ego = DatasetCapture.RegisterEgo("ego");
-            DatasetCapture.RegisterSensor(ego, "cam", "", 1f, 2f);
+            DatasetCapture.RegisterSensor(ego, "cam", "", 1f, 2f, true, true);
 
             yield return null;
             Time.timeScale = 5;
         public IEnumerator ChangingTimeScale_DuringStartNewSequence_Succeeds()
         {
             var ego = DatasetCapture.RegisterEgo("ego");
-            DatasetCapture.RegisterSensor(ego, "cam", "", 1f, 2f);
+            DatasetCapture.RegisterSensor(ego, "cam", "", 1f, 2f, true, true);
 
             yield return null;
             Time.timeScale = 1;
                 .01f,
                 1f
             };
-            DatasetCapture.RegisterSensor(ego, "cam", "", period, firstCaptureTime);
+            DatasetCapture.RegisterSensor(ego, "cam", "", period, firstCaptureTime, true, true);
 
             float[] deltaTimeSamplesExpected =
             {
         public IEnumerator ResetSimulation_ResetsCaptureDeltaTime()
         {
             var ego = DatasetCapture.RegisterEgo("ego");
-            DatasetCapture.RegisterSensor(ego, "cam", "", 4, 10);
+            DatasetCapture.RegisterSensor(ego, "cam", "", 4, 10, true, true);
             yield return null;
             Assert.AreEqual(10, Time.captureDeltaTime);
             DatasetCapture.ResetSimulation();
             var ego = DatasetCapture.RegisterEgo("ego");
             var firstCaptureTime1 = 10;
             var frequencyInMs1 = 4;
-            var sensor1 = DatasetCapture.RegisterSensor(ego, "cam", "1", frequencyInMs1, firstCaptureTime1);
+            var sensor1 = DatasetCapture.RegisterSensor(ego, "cam", "1", frequencyInMs1, firstCaptureTime1, true, true);
-            var sensor2 = DatasetCapture.RegisterSensor(ego, "cam", "2", frequencyInMs2, firstCaptureTime2);
+            var sensor2 = DatasetCapture.RegisterSensor(ego, "cam", "2", frequencyInMs2, firstCaptureTime2, true, true);
-            var sensor3 = DatasetCapture.RegisterSensor(ego, "cam", "3", 1, 1);
+            var sensor3 = DatasetCapture.RegisterSensor(ego, "cam", "3", 1, 1, true, true);
             sensor3.Enabled = false;
 
             (float deltaTime, bool sensor1ShouldCapture, bool sensor2ShouldCapture)[] samplesExpected =
         [Test]
         public void Enabled_StartsTrue()
         {
-            var sensor1 = DatasetCapture.RegisterSensor(DatasetCapture.RegisterEgo(""), "cam", "1", 1, 1);
+            var sensor1 = DatasetCapture.RegisterSensor(DatasetCapture.RegisterEgo(""), "cam", "1", 1, 1, true, true);
             Assert.IsTrue(sensor1.Enabled);
         }
     }

com.unity.perception/Tests/Runtime/GroundTruthTests/DatasetCaptureTests.cs

 }}";
 
             var ego = DatasetCapture.RegisterEgo(egoDescription);
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, modality, sensorDescription, 1, 1);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, modality, sensorDescription, 1, 1, true, true);
             Assert.IsTrue(sensorHandle.IsValid);
             DatasetCapture.ResetSimulation();
             Assert.IsFalse(sensorHandle.IsValid);
 }}";
 
             var ego = DatasetCapture.RegisterEgo("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "camera", "", 1, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "camera", "", 1, 0, true, true);
             var sensorSpatialData = new SensorSpatialData(new Pose(egoPosition, egoRotation), new Pose(position, rotation), egoVelocity, null);
             sensorHandle.ReportCapture(filename, sensorSpatialData, ("camera_intrinsic", intrinsics));
 
             };
 
             var ego = DatasetCapture.RegisterEgo("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 2, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 2, 0, true, true);
             var sensorSpatialData = new SensorSpatialData(default, default, null, null);
             Assert.IsTrue(sensorHandle.ShouldCaptureThisFrame);
             sensorHandle.ReportCapture("f", sensorSpatialData);
       ]";
 
             var ego = DatasetCapture.RegisterEgo("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0, true, true);
             sensorHandle.ReportCapture(filename, default);
             var annotationDefinition = DatasetCapture.RegisterAnnotationDefinition("semantic segmentation", "pixel-wise semantic segmentation label", "PNG", annotationDefinitionGuid);
             sensorHandle.ReportAnnotationFile(annotationDefinition, "annotations/semantic_segmentation_000.png");
 
             var ego = DatasetCapture.RegisterEgo("");
             var annotationDefinition = DatasetCapture.RegisterAnnotationDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0, true, true);
 
             sensorHandle.ReportAnnotationValues(annotationDefinition, values);
             DatasetCapture.ResetSimulation();
         {
             var ego = DatasetCapture.RegisterEgo("");
             var annotationDefinition = DatasetCapture.RegisterAnnotationDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 100);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 100, true, true);
             Assert.Throws<InvalidOperationException>(() => sensorHandle.ReportAnnotationFile(annotationDefinition, ""));
         }
 
             var ego = DatasetCapture.RegisterEgo("");
             var annotationDefinition = DatasetCapture.RegisterAnnotationDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 100);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 100, true, true);
             Assert.Throws<InvalidOperationException>(() => sensorHandle.ReportAnnotationValues(annotationDefinition, new int[0]));
         }
 
             var ego = DatasetCapture.RegisterEgo("");
             var annotationDefinition = DatasetCapture.RegisterAnnotationDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 100);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 100, true, true);
             Assert.Throws<InvalidOperationException>(() => sensorHandle.ReportAnnotationAsync(annotationDefinition));
         }
 
             var ego = DatasetCapture.RegisterEgo("");
             var annotationDefinition = DatasetCapture.RegisterAnnotationDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0, true, true);
             sensorHandle.ReportAnnotationAsync(annotationDefinition);
             DatasetCapture.ResetSimulation();
             LogAssert.Expect(LogType.Error, new Regex("Simulation ended with pending .*"));
 
             var ego = DatasetCapture.RegisterEgo("");
             var annotationDefinition = DatasetCapture.RegisterAnnotationDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0, true, true);
             var asyncAnnotation = sensorHandle.ReportAnnotationAsync(annotationDefinition);
 
             Assert.IsTrue(asyncAnnotation.IsValid);
 
             var ego = DatasetCapture.RegisterEgo("");
             var annotationDefinition = DatasetCapture.RegisterAnnotationDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0, true, true);
             var asyncAnnotation = sensorHandle.ReportAnnotationAsync(annotationDefinition);
 
             Assert.IsTrue(asyncAnnotation.IsPending);
 
             var ego = DatasetCapture.RegisterEgo("");
             var annotationDefinition = DatasetCapture.RegisterAnnotationDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0, true, true);
             var asyncAnnotation = sensorHandle.ReportAnnotationAsync(annotationDefinition);
 
             Assert.IsTrue(asyncAnnotation.IsPending);
 
             var ego = DatasetCapture.RegisterEgo("");
             var annotationDefinition = DatasetCapture.RegisterAnnotationDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0, true, true);
 
             // Record one capture for this frame
             sensorHandle.ReportCapture(fileName, default);
         {
             var ego = DatasetCapture.RegisterEgo("");
             var metricDefinition = DatasetCapture.RegisterMetricDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 100);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 100, true, true);
             Assert.Throws<InvalidOperationException>(() => sensorHandle.ReportMetric(metricDefinition, new int[0]));
         }
 
             var ego = DatasetCapture.RegisterEgo("");
             var metricDefinition = DatasetCapture.RegisterMetricDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 100);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 100, true, true);
             Assert.Throws<InvalidOperationException>(() => sensorHandle.ReportMetricAsync(metricDefinition));
         }
 
             var ego = DatasetCapture.RegisterEgo("");
             var metricDefinition = DatasetCapture.RegisterMetricDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0, true, true);
             sensorHandle.ReportMetricAsync(metricDefinition);
             DatasetCapture.ResetSimulation();
             LogAssert.Expect(LogType.Error, new Regex("Simulation ended with pending .*"));
 
             var ego = DatasetCapture.RegisterEgo("");
             var metricDefinition = DatasetCapture.RegisterMetricDefinition("");
-            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0);
+            var sensorHandle = DatasetCapture.RegisterSensor(ego, "", "", 1, 0, true, true);
             var asyncMetric = sensorHandle.ReportMetricAsync(metricDefinition);
 
             Assert.IsTrue(asyncMetric.IsValid);
             var expectedLine = @"""step"": 0";
 
             var metricDefinition = DatasetCapture.RegisterMetricDefinition("");
-            DatasetCapture.RegisterSensor(DatasetCapture.RegisterEgo(""), "", "", 1, 0);
+            DatasetCapture.RegisterSensor(DatasetCapture.RegisterEgo(""), "", "", 1, 0, true, true);
 
             yield return null;
             yield return null;
             var expectedLine = @"""step"": 0";
 
             var metricDefinition = DatasetCapture.RegisterMetricDefinition("");
-            var sensor = DatasetCapture.RegisterSensor(DatasetCapture.RegisterEgo(""), "", "", 1, 0);
+            var sensor = DatasetCapture.RegisterSensor(DatasetCapture.RegisterEgo(""), "", "", 1, 0, true, true);
 
             yield return null;
             sensor.ReportMetric(metricDefinition, values);
 }}";
 
             var metricDefinition = DatasetCapture.RegisterMetricDefinition("");
-            var sensor = DatasetCapture.RegisterSensor(DatasetCapture.RegisterEgo(""), "", "", 1, 0);
+            var sensor = DatasetCapture.RegisterSensor(DatasetCapture.RegisterEgo(""), "", "", 1, 0, true, true);
             var annotation = sensor.ReportAnnotationFile(DatasetCapture.RegisterAnnotationDefinition(""), "");
             var valuesJsonArray = JArray.FromObject(values).ToString(Formatting.Indented);
             if (async)

TestProjects/PerceptionURP/Assets/Scenes/SampleScene.meta

+fileFormatVersion: 2
+guid: 70cd7e25bc5b841a3aa2204cd9a4e4fd
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

TestProjects/PerceptionURP/Assets/Scenes/SampleScene/Main Camera Profile.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-483115452003982658
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: ccf1aba9553839d41ae37dd52e9ebcce, type: 3}
+  m_Name: MotionBlur
+  m_EditorClassIdentifier: 
+  active: 1
+  m_AdvancedMode: 0
+  mode:
+    m_OverrideState: 0
+    m_Value: 0
+  quality:
+    m_OverrideState: 1
+    m_Value: 1
+  intensity:
+    m_OverrideState: 1
+    m_Value: 1
+    min: 0
+    max: 1
+  clamp:
+    m_OverrideState: 1
+    m_Value: 0.2
+    min: 0
+    max: 0.2
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d7fd9488000d3734a9e00ee676215985, type: 3}
+  m_Name: Main Camera Profile
+  m_EditorClassIdentifier: 
+  components:
+  - {fileID: -483115452003982658}
+  - {fileID: 1588644373107956851}
+--- !u!114 &1588644373107956851
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0b2db86121404754db890f4c8dfe81b2, type: 3}
+  m_Name: Bloom
+  m_EditorClassIdentifier: 
+  active: 1
+  m_AdvancedMode: 0
+  threshold:
+    m_OverrideState: 1
+    m_Value: 0.69
+    min: 0
+  intensity:
+    m_OverrideState: 1
+    m_Value: 1.05
+    min: 0
+  scatter:
+    m_OverrideState: 0
+    m_Value: 0.7
+    min: 0
+    max: 1
+  clamp:
+    m_OverrideState: 0
+    m_Value: 65472
+    min: 0
+  tint:
+    m_OverrideState: 0
+    m_Value: {r: 1, g: 1, b: 1, a: 1}
+    hdr: 0
+    showAlpha: 0
+    showEyeDropper: 1
+  highQualityFiltering:
+    m_OverrideState: 0
+    m_Value: 0
+  dirtTexture:
+    m_OverrideState: 0
+    m_Value: {fileID: 0}
+  dirtIntensity:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0

TestProjects/PerceptionURP/Assets/Scenes/SampleScene/Main Camera Profile.asset.meta

+fileFormatVersion: 2
+guid: f416044e9f33b4211898fb62f3da67d3
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

TestProjects/PerceptionURP/Assets/StreamingAssets.meta

-fileFormatVersion: 2
-guid: 01c33d1bbfad749909de900dc92115a0
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: