Camera System Refactor

XRTK-Core/Packages/com.xrtk.core/Definitions/MixedRealityCameraProfile.cs → XRTK-Core/Packages/com.xrtk.core/Definitions/CameraSystem/BaseMixedRealityCameraDataProviderProfile.cs

@@ -1,31 +1,29 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) XRTK. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 using UnityEngine;
 using XRTK.Attributes;
 using XRTK.Definitions.Utilities;
-using XRTK.Interfaces;
+using XRTK.Interfaces.CameraSystem;
 using XRTK.Services.CameraSystem;
 
-namespace XRTK.Definitions
+namespace XRTK.Definitions.CameraSystem
 {
     /// <summary>
-    /// This <see cref="ScriptableObject"/> tells you if your head mounted display (HMD)
-    /// is a transparent device or an occluded device.
-    /// Based on those values, you can customize your camera and quality settings.
+    /// Provides additional configuration options for camera data providers.
     /// </summary>
-    [CreateAssetMenu(menuName = "Mixed Reality Toolkit/Camera Profile", fileName = "MixedRealityCameraProfile", order = (int)CreateProfileMenuItemIndices.Camera)]
-    public class MixedRealityCameraProfile : BaseMixedRealityProfile
+    public class BaseMixedRealityCameraDataProviderProfile : BaseMixedRealityProfile
     {
         [SerializeField]
-        private bool isCameraPersistent = false;
+        private bool isCameraPersistent = true;
 
         /// <summary>
         /// Should the camera be reused in each scene?
         /// If so, then the camera's root will be flagged so it is not destroyed when the scene is unloaded.
         /// </summary>
         public bool IsCameraPersistent => isCameraPersistent;
 
+
         [SerializeField]
         [Tooltip("The near clipping plane distance for an opaque display.")]
         private float nearClipPlaneOpaqueDisplay = 0.1f;

XRTK-Core/Packages/com.xrtk.core/Definitions/CameraSystem/MixedRealityCameraDataProvidersProfile.cs

@@ -0,0 +1,14 @@
+// Copyright (c) XRTK. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using UnityEngine;
+using XRTK.Definitions.Utilities;
+using XRTK.Interfaces.CameraSystem;
+
+namespace XRTK.Definitions.CameraSystem
+{
+    [CreateAssetMenu(menuName = "Mixed Reality Toolkit/Camera System/Data Providers Profile", fileName = "MixedRealityCameraDataProvidersProfile", order = (int)CreateProfileMenuItemIndices.Camera)]
+    public class MixedRealityCameraDataProvidersProfile : BaseMixedRealityServiceProfile<IMixedRealityCameraDataProvider>
+    {
+    }
+}

XRTK-Core/Packages/com.xrtk.core/Definitions/CameraSystem/MixedRealityCameraSystemProfile.cs

@@ -0,0 +1,156 @@
+// Copyright (c) XRTK. All rights reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+using UnityEngine;
+using XRTK.Attributes;
+using XRTK.Definitions.Utilities;
+using XRTK.Services.CameraSystem;
+using XRTK.Interfaces.CameraSystem;
+
+namespace XRTK.Definitions.CameraSystem
+{
+    /// <summary>
+    /// This <see cref="BaseMixedRealityProfile"/> tells you if your head mounted display (HMD)
+    /// is a transparent device or an occluded device.
+    /// Based on those values, you can customize your camera and quality settings.
+    /// </summary>
+    [CreateAssetMenu(menuName = "Mixed Reality Toolkit/Camera System Profile", fileName = "MixedRealityCameraSystemProfile", order = (int)CreateProfileMenuItemIndices.Camera)]
+    public class MixedRealityCameraSystemProfile : BaseMixedRealityProfile
+    {
+        [SerializeField]
+        [Tooltip("The list of registered Camera Data Providers for each platform.")]
+        private MixedRealityCameraDataProvidersProfile cameraDataProvidersProfile = null;
+
+        /// <summary>
+        /// The The list of registered <see cref="IMixedRealityCameraDataProvider"/>s for each platform.
+        /// </summary>
+        public MixedRealityCameraDataProvidersProfile CameraDataProvidersProfile => cameraDataProvidersProfile;
+
+        [SerializeField]
+        private bool isCameraPersistent = false;
+
+        /// <summary>
+        /// Should the camera be reused in each scene?
+        /// If so, then the camera's root will be flagged so it is not destroyed when the scene is unloaded.
+        /// </summary>
+        public bool IsCameraPersistent => isCameraPersistent;
+
+        [SerializeField]
+        [Tooltip("The near clipping plane distance for an opaque display.")]
+        private float nearClipPlaneOpaqueDisplay = 0.1f;
+
+        /// <summary>
+        /// The near clipping plane distance for an opaque display.
+        /// </summary>
+        public float NearClipPlaneOpaqueDisplay
+        {
+            get => nearClipPlaneOpaqueDisplay;
+            internal set => nearClipPlaneOpaqueDisplay = value;
+        }
+
+        [SerializeField]
+        [Tooltip("Values for Camera.clearFlags, determining what to clear when rendering a Camera for an opaque display.")]
+        private CameraClearFlags cameraClearFlagsOpaqueDisplay = CameraClearFlags.Skybox;
+
+        /// <summary>
+        /// Values for Camera.clearFlags, determining what to clear when rendering a Camera for an opaque display.
+        /// </summary>
+        public CameraClearFlags CameraClearFlagsOpaqueDisplay => cameraClearFlagsOpaqueDisplay;
+
+        [SerializeField]
+        [Tooltip("Background color for a transparent display.")]
+        private Color backgroundColorOpaqueDisplay = Color.black;
+
+        /// <summary>
+        /// Background color for a transparent display.
+        /// </summary>
+        public Color BackgroundColorOpaqueDisplay => backgroundColorOpaqueDisplay;
+
+        [SerializeField]
+        [Tooltip("Set the desired quality for your application for opaque display.")]
+        private int opaqueQualityLevel = 0;
+
+        /// <summary>
+        /// Set the desired quality for your application for opaque display.
+        /// </summary>
+        public int OpaqueQualityLevel => opaqueQualityLevel;
+
+        [SerializeField]
+        [Tooltip("The near clipping plane distance for a transparent display.")]
+        private float nearClipPlaneTransparentDisplay = 0.85f;
+
+        /// <summary>
+        /// The near clipping plane distance for a transparent display.
+        /// </summary>
+        public float NearClipPlaneTransparentDisplay => nearClipPlaneTransparentDisplay;
+
+        [SerializeField]
+        [Tooltip("Values for Camera.clearFlags, determining what to clear when rendering a Camera for an opaque display.")]
+        private CameraClearFlags cameraClearFlagsTransparentDisplay = CameraClearFlags.SolidColor;
+
+        /// <summary>
+        /// Values for Camera.clearFlags, determining what to clear when rendering a Camera for an opaque display.
+        /// </summary>
+        public CameraClearFlags CameraClearFlagsTransparentDisplay => cameraClearFlagsTransparentDisplay;
+
+        [SerializeField]
+        [Tooltip("Background color for a transparent display.")]
+        private Color backgroundColorTransparentDisplay = Color.clear;
+
+        /// <summary>
+        /// Background color for a transparent display.
+        /// </summary>
+        public Color BackgroundColorTransparentDisplay => backgroundColorTransparentDisplay;
+
+        [SerializeField]
+        [Tooltip("Set the desired quality for your application for transparent display.")]
+        private int transparentQualityLevel = 0;
+
+        /// <summary>
+        /// Set the desired quality for your application for transparent display.
+        /// </summary>
+        public int TransparentQualityLevel => transparentQualityLevel;
+
+        [SerializeField]
+        [Tooltip("The concrete type to use for the camera rig.")]
+        [Implements(typeof(IMixedRealityCameraRig), TypeGrouping.ByNamespaceFlat)]
+        private SystemType cameraRigType = new SystemType(typeof(DefaultCameraRig));
+
+        /// <summary>
+        /// The concrete type to use for the camera rig.
+        /// </summary>
+        public SystemType CameraRigType
+        {
+            get => cameraRigType;
+            internal set => cameraRigType = value;
+        }
+
+        [SerializeField]
+        [Tooltip("The default head height the rig will start at if a platform doesn't automatically adjust the height for you.")]
+        private float defaultHeadHeight = 1.6f;
+
+        /// <summary>
+        /// The default head height the rig will start at if a platform doesn't automatically adjust the height for you.
+        /// </summary>
+        public float DefaultHeadHeight => defaultHeadHeight;
+
+        [SerializeField]
+        [UnityEngine.Range(0f, 180f)]
+        [Tooltip("This is the angle that will be used to adjust the player's body rotation in relation to their head position.")]
+        private float bodyAdjustmentAngle = 60f;
+
+        /// <summary>
+        /// /// This is the angle that will be used to adjust the player's body rotation in relation to their head position.
+        /// </summary>
+        public float BodyAdjustmentAngle => bodyAdjustmentAngle;
+
+        [SerializeField]
+        [Tooltip("The speed at which the body transform will sync it's rotation with the head transform.")]
+        private float bodyAdjustmentSpeed = 1f;
+
+        /// <summary>
+        /// The speed at which the body transform will sync it's rotation with the head transform.
+        /// </summary>
+        public float BodyAdjustmentSpeed => bodyAdjustmentSpeed;
+    }
+}

XRTK-Core/Packages/com.xrtk.core/Definitions/Controllers/Simulation/Hands/SimulatedHandControllerPose.cs

@@ -151,7 +151,7 @@ private static void OffsetJointsRelativeToOpenPosePalmPosition(SimulatedHandCont
         /// </summary>
         public void ComputeJointPoses(Handedness handedness, Quaternion rotation, Vector3 position, MixedRealityPose[] jointsOut)
         {
-            Quaternion cameraRotation = MixedRealityToolkit.CameraSystem.CameraRig.PlayerCamera.transform.rotation;
+            Quaternion cameraRotation = MixedRealityToolkit.CameraSystem.MainCameraRig.PlayerCamera.transform.rotation;
 
             for (int i = 0; i < HandData.JointCount; i++)
             {
@@ -185,7 +185,7 @@ public void ComputeJointPoses(Handedness handedness, Quaternion rotation, Vector
         public void ParseFromJointPoses(MixedRealityPose[] joints, Handedness handedness, Quaternion rotation, Vector3 position)
         {
             var invRotation = Quaternion.Inverse(rotation);
-            var invCameraRotation = Quaternion.Inverse(MixedRealityToolkit.CameraSystem.CameraRig.PlayerCamera.transform.rotation);
+            var invCameraRotation = Quaternion.Inverse(MixedRealityToolkit.CameraSystem.MainCameraRig.PlayerCamera.transform.rotation);
 
             for (int i = 0; i < HandData.JointCount; i++)
             {

XRTK-Core/Packages/com.xrtk.core/Definitions/MixedRealityToolkitRootProfile.cs

@@ -2,8 +2,10 @@
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
 using UnityEngine;
+using UnityEngine.Serialization;
 using XRTK.Attributes;
 using XRTK.Definitions.BoundarySystem;
+using XRTK.Definitions.CameraSystem;
 using XRTK.Definitions.DiagnosticsSystem;
 using XRTK.Definitions.InputSystem;
 using XRTK.Definitions.NetworkingSystem;
@@ -38,7 +40,7 @@ public sealed class MixedRealityToolkitRootProfile : BaseMixedRealityProfile
         /// </summary>
         public bool IsCameraSystemEnabled
         {
-            get => CameraProfile != null && cameraSystemType != null && cameraSystemType.Type != null && enableCameraSystem;
+            get => CameraSystemProfile != null && cameraSystemType != null && cameraSystemType.Type != null && enableCameraSystem;
             internal set => enableCameraSystem = value;
         }
 
@@ -57,17 +59,18 @@ public SystemType CameraSystemType
         }
 
         [SerializeField]
-        [Tooltip("Camera profile.")]
-        private MixedRealityCameraProfile cameraProfile;
+        [Tooltip("Camera system profile.")]
+        [FormerlySerializedAs("cameraProfile")]
+        private MixedRealityCameraSystemProfile cameraSystemProfile;
 
         /// <summary>
         /// Profile for customizing your camera and quality settings based on if your 
         /// head mounted display (HMD) is a transparent device or an occluded device.
         /// </summary>
-        public MixedRealityCameraProfile CameraProfile
+        public MixedRealityCameraSystemProfile CameraSystemProfile
         {
-            get => cameraProfile;
-            internal set => cameraProfile = value;
+            get => cameraSystemProfile;
+            internal set => cameraSystemProfile = value;
         }
 
         #endregion Camera System Properties

XRTK-Core/Packages/com.xrtk.core/Definitions/Utilities/TrackedObjectType.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
-using XRTK.Interfaces;
+using XRTK.Interfaces.CameraSystem;
 
 namespace XRTK.Definitions.Utilities
 {