XR/OpenXrVk changes related to the new RPI sample added to AtomSampleViewer (#22)

* Added a new XR level that tests a proper VR multi-view pipeline. It creates a render pipeline for each eye and runs than consecutively with a pipeline for PC. The two XR pipelines themselves are a variant of low end render pipeline as a start but in future they will be modified for performance and memory improvements. For example currently we are doing the ShadowMap passes for both the pipelines. This sample adds a ground plane and a few meshes on top of the plane. It also added support for rendering and updating Quest 2 controller related meshes. There is support to switch through different lighting presets for testing purposes as well as support for iterating through differnt ground materials in order to test shadows, reflections, etc.

The sample  supports Quest 2 controllers to fly around the world. It has support to use button presses for specific functionality in the scene. The schema for each controller is below
    - Left controller
             Joystick - Camera movement, Button X - Camera Up (View space y-axis), Button Y - Camera Down (View space Y axis), Squeeze - Scales Controller model
    - Right controller
             Joystick - View Orientation if Trigger button is pressed, otherwise it will use device for view tracking,
             Button A - Iterate through lighting preset, Button B - Iterate through ground plane material, Squeeze - Scales Controller model

Signed-off-by: moudgils <[email protected]>

* Address feedback

Signed-off-by: moudgils <[email protected]>

* Address feedback

Signed-off-by: moudgils <[email protected]>

* Removing const before uint32_t types

Signed-off-by: moudgils <[email protected]>

* Addressed feedback

Signed-off-by: moudgils <[email protected]>

Signed-off-by: moudgils <[email protected]>

Author: moudgils

Gems/OpenXRVk/Code/Include/OpenXRVk/OpenXRVkDevice.h

@@ -30,9 +30,9 @@ namespace OpenXRVk
         // Create the xr specific native device object and populate the XRDeviceDescriptor with it.
         AZ::RHI::ResultCode InitDeviceInternal(AZ::RHI::XRDeviceDescriptor* instanceDescriptor) override;
         //! Get the Fov data  of the view specified by view index
-        AZ::RPI::FovData GetViewFov(AZ::u32 viewIndex) const override;
+        AZ::RHI::ResultCode GetViewFov(AZ::u32 viewIndex, AZ::RPI::FovData& outFovData) const override;
         //! Get the Pose data  of the view specified by view index
-        AZ::RPI::PoseData GetViewPose(AZ::u32 viewIndex) const override;
+        AZ::RHI::ResultCode GetViewPose(AZ::u32 viewIndex, AZ::RPI::PoseData& outPoseData) const override;
         //////////////////////////////////////////////////////////////////////////
 
         //! Returns true if rendering data is valid for the current frame.

Gems/OpenXRVk/Code/Include/OpenXRVk/OpenXRVkInput.h

@@ -43,16 +43,16 @@ namespace OpenXRVk
         void LocateVisualizedSpace(XrTime predictedDisplayTime, XrSpace space, XrSpace baseSpace, OpenXRVk::SpaceType visualizedSpaceType);
 
         //! Return Pose data for a controller attached to a view index
-        AZ::RPI::PoseData GetControllerPose(AZ::u32 viewIndex) const;
+        AZ::RHI::ResultCode GetControllerPose(AZ::u32 handIndex, AZ::RPI::PoseData& outPoseData) const;
 
         //! Return scale for a controller attached to a view index
         float GetControllerScale(AZ::u32 viewIndex) const;
 
         //! Return Pose data for a tracked space type (i.e visualizedSpaceType)
-        AZ::RPI::PoseData GetVisualizedSpacePose(OpenXRVk::SpaceType visualizedSpaceType) const;
+        AZ::RHI::ResultCode GetVisualizedSpacePose(OpenXRVk::SpaceType visualizedSpaceType, AZ::RPI::PoseData& outPoseData) const;
 
-        //! Get the Grab action
-        XrAction GetGrabAction() const;
+        //! Get the Pose action
+        XrAction GetSqueezeAction() const;
 
         //! Get the Pose action
         XrAction GetPoseAction() const;
@@ -62,8 +62,51 @@ namespace OpenXRVk
 
         //! Get the Quit action
         XrAction GetQuitAction() const;
+
+        //! Get the X button state
+        float GetXButtonState() const;
+
+        //! Get the Y button state
+        float GetYButtonState() const;
+
+        //! Get the A button state
+        float GetAButtonState() const;
+
+        //! Get the B button state
+        float GetBButtonState() const;
+
+        //! Get the joystick state for x-axis
+        float GetXJoyStickState(AZ::u32 handIndex) const;
+
+        //! Get the joystick state for y-axis
+        float GetYJoyStickState(AZ::u32 handIndex) const;
+
+        //! Get the Squeeze action
+        float GetSqueezeState(AZ::u32 handIndex) const;
+
+        //! Get the Squeeze action
+        float GetTriggerState(AZ::u32 handIndex) const;
+
     private:
 
+        struct SingleActionData
+        {
+            XrAction m_actionHandle{ XR_NULL_HANDLE };
+            float m_actionState = 0.0f;
+        };
+
+        struct DualActionData
+        {
+            XrAction m_actionHandle{ XR_NULL_HANDLE };
+            AZStd::array<float, AZ::RPI::XRMaxNumControllers> m_actionState = { { 0.0f, 0.0f } };
+        };
+
+        struct ControllerActionData
+        {
+            SingleActionData m_actionData;
+            uint16_t m_handIndex = 0;
+        };
+
         //! Create a XrAction
         void CreateAction(XrAction& action, XrActionType actionType,
                           const char* actionName, const char* localizedActionName,
@@ -72,17 +115,31 @@ namespace OpenXRVk
         //! Destroy native objects
         void ShutdownInternal() override;
 
+        bool GetActionState(XrSession xrSession, XrAction xrAction, uint16_t handIndex, float& outputSate);
+        bool UpdateActionState(XrSession xrSession, SingleActionData& actionData, uint16_t handIndex);
+        bool UpdateActionState(XrSession xrSession, DualActionData& actionData, uint16_t handIndex);
+
         XrActionSet m_actionSet{ XR_NULL_HANDLE };
-        XrAction m_grabAction{ XR_NULL_HANDLE };
         XrAction m_poseAction{ XR_NULL_HANDLE };
         XrAction m_vibrateAction{ XR_NULL_HANDLE };
         XrAction m_quitAction{ XR_NULL_HANDLE };
-        AZStd::array<XrPath, 2> m_handSubactionPath;
-        AZStd::array<XrSpace, 2> m_handSpace;
-        AZStd::array<float, 2> m_handScale = { { 1.0f, 1.0f } };
-        AZStd::array<XrBool32, 2> m_handActive;
+        DualActionData m_squeezeAction{ XR_NULL_HANDLE, 0.0f };
+        DualActionData m_triggerAction{ XR_NULL_HANDLE, 0.0f };
 
-        AZStd::array<XrSpaceLocation, 2> m_handSpaceLocation;
+        AZStd::array<XrPath, AZ::RPI::XRMaxNumControllers> m_handSubactionPath;
+        AZStd::array<XrSpace, AZ::RPI::XRMaxNumControllers> m_handSpace;
+        AZStd::array<float, AZ::RPI::XRMaxNumControllers> m_handScale = { { 1.0f, 1.0f } };
+        AZStd::array<XrBool32, AZ::RPI::XRMaxNumControllers> m_handActive;
+
+        AZStd::array<XrSpaceLocation, AZ::RPI::XRMaxNumControllers> m_handSpaceLocation;
         AZStd::array<XrSpaceLocation, SpaceType::Count> m_xrVisualizedSpaceLocations;
+
+        //Todo: This is assuming Quest 2 controller. Needs better abstraction to cover other types of controllers
+        SingleActionData m_xButtonAction{XR_NULL_HANDLE, 0.0f};
+        SingleActionData m_yButtonAction{XR_NULL_HANDLE, 0.0f};
+        SingleActionData m_aButtonAction{XR_NULL_HANDLE, 0.0f};
+        SingleActionData m_bButtonAction{XR_NULL_HANDLE, 0.0f};
+        DualActionData m_joyStickXAction{ XR_NULL_HANDLE, 0.0f };
+        DualActionData m_joyStickYAction{ XR_NULL_HANDLE, 0.0f };
     };
 }

Gems/OpenXRVk/Code/Include/OpenXRVk/OpenXRVkSession.h

@@ -11,6 +11,7 @@
 #include <AzCore/std/smart_ptr/intrusive_ptr.h>
 #include <OpenXRVk_Platform.h>
 #include <OpenXRVk/OpenXRVkSpace.h>
+#include <OpenXRVk/OpenXRVkInput.h>
 #include <XR/XRSession.h>
 
 namespace OpenXRVk
@@ -49,16 +50,27 @@ namespace OpenXRVk
         bool IsExitRenderLoopRequested() const override;
         void PollEvents() override;
         void LocateControllerSpace(AZ::u32 handIndex) override;
-        AZ::RPI::PoseData GetControllerPose(AZ::u32 handIndex) const override;
-        AZ::RPI::PoseData GetViewFrontPose() const override;
+        AZ::RHI::ResultCode GetControllerPose(AZ::u32 handIndex, AZ::RPI::PoseData& outPoseData) const override;
+        AZ::RHI::ResultCode GetControllerStagePose(AZ::u32 handIndex, AZ::RPI::PoseData& outPoseData) const override;
+        AZ::RHI::ResultCode GetViewFrontPose(AZ::RPI::PoseData& outPoseData) const override;
+        AZ::RHI::ResultCode GetViewLocalPose(AZ::RPI::PoseData& outPoseData) const override;
         float GetControllerScale(AZ::u32 handIndex) const override;
+        float GetXButtonState() const override;
+        float GetYButtonState() const override;
+        float GetAButtonState() const override;
+        float GetBButtonState() const override;
+        float GetXJoyStickState(AZ::u32 handIndex) const override;
+        float GetYJoyStickState(AZ::u32 handIndex) const override;
+        float GetSqueezeState(AZ::u32 handIndex) const override;
+        float GetTriggerState(AZ::u32 handIndex) const override;
         //////////////////////////////////////////////////////////////////////////
 
     private:
 
         void ShutdownInternal() override;
         void LogActionSourceName(XrAction action, const AZStd::string_view actionName) const;
-        
+        Input* GetNativeInput() const;
+
         XrSession m_session = XR_NULL_HANDLE;
         XrSessionState m_sessionState = XR_SESSION_STATE_UNKNOWN;
         XrEventDataBuffer m_eventDataBuffer;

Gems/OpenXRVk/Code/Source/OpenXRVkDevice.cpp

@@ -243,35 +243,35 @@ namespace OpenXRVk
         return m_context;
     }
 
-    AZ::RPI::FovData Device::GetViewFov(AZ::u32 viewIndex) const
+    AZ::RHI::ResultCode Device::GetViewFov(AZ::u32 viewIndex, AZ::RPI::FovData& outFovData) const
     {
-        AZ::RPI::FovData viewFov;
         if(viewIndex < m_projectionLayerViews.size())
         { 
-            viewFov.m_angleLeft = m_projectionLayerViews[viewIndex].fov.angleLeft;
-            viewFov.m_angleRight = m_projectionLayerViews[viewIndex].fov.angleRight;
-            viewFov.m_angleUp = m_projectionLayerViews[viewIndex].fov.angleUp;
-            viewFov.m_angleDown = m_projectionLayerViews[viewIndex].fov.angleDown;     
+            outFovData.m_angleLeft = m_projectionLayerViews[viewIndex].fov.angleLeft;
+            outFovData.m_angleRight = m_projectionLayerViews[viewIndex].fov.angleRight;
+            outFovData.m_angleUp = m_projectionLayerViews[viewIndex].fov.angleUp;
+            outFovData.m_angleDown = m_projectionLayerViews[viewIndex].fov.angleDown;
+            return AZ::RHI::ResultCode::Success;
         }
-        return viewFov;
+        return AZ::RHI::ResultCode::Fail;
     }
 
-    AZ::RPI::PoseData Device::GetViewPose(AZ::u32 viewIndex) const
-    {
-        AZ::RPI::PoseData viewPose;
+    AZ::RHI::ResultCode Device::GetViewPose(AZ::u32 viewIndex, AZ::RPI::PoseData& outPoseData) const
+    { 
         if (viewIndex < m_projectionLayerViews.size())
         {
             const XrQuaternionf& orientation = m_projectionLayerViews[viewIndex].pose.orientation;
             const XrVector3f& position = m_projectionLayerViews[viewIndex].pose.position;
-            viewPose.orientation = AZ::Quaternion(orientation.x,
-                                                  orientation.y, 
-                                                  orientation.z, 
-                                                  orientation.w);
-            viewPose.position = AZ::Vector3(position.x, 
-                                            position.y, 
-                                            position.z);
-        }        
-        return viewPose;
+            outPoseData.m_orientation.Set(orientation.x,
+                                          orientation.y, 
+                                          orientation.z, 
+                                          orientation.w);
+            outPoseData.m_position.Set(position.x,
+                                       position.y, 
+                                       position.z);
+            return AZ::RHI::ResultCode::Success;
+        }
+        return AZ::RHI::ResultCode::Fail;
     }
 
     XrTime Device::GetPredictedDisplayTime() const