OpenVR and OpenXR symmetric and other projection matrix options

src/CommitHash.hpp

@@ -1,4 +1,4 @@
 #pragma once 
-#define UEVR_COMMIT_HASH "3997108934a41fdbb1c6a6e8ff59d7fcd63362ac" 
-#define UEVR_BUILD_DATE "13.02.2024" 
-#define UEVR_BUILD_TIME "00:00" 
+#define UEVR_COMMIT_HASH "3997108934a41fdbb1c6a6e8ff59d7fcd63362ac"
+#define UEVR_BUILD_DATE "13.02.2024"
+#define UEVR_BUILD_TIME "00:00"

src/mods/VR.cpp

@@ -2524,6 +2524,10 @@ void VR::on_draw_sidebar_entry(std::string_view name) {
             m_compatibility_skip_pip->draw("Skip PostInitProperties");
             m_sceneview_compatibility_mode->draw("SceneView Compatibility Mode");
             m_extreme_compat_mode->draw("Extreme Compatibility Mode");
+
+            m_horizontal_projection_override->draw("Horiztonal Projection");
+            m_vertical_projection_override->draw("Vertical Projection");
+            m_grow_rectangle_for_projection_cropping->draw("Scale Render Target");
             ImGui::TreePop();
         }
 

src/mods/VR.hpp

@@ -54,6 +54,18 @@ class VR : public Mod {
         GESTURE_HEAD_RIGHT,
     };
 
+    enum HORIZONTAL_PROJECTION_OVERRIDE : int32_t {
+        HORIZONTAL_DEFAULT,
+        HORIZONTAL_SYMMETRIC,
+        HORIZONTAL_MIRROR
+    };
+
+    enum VERTICAL_PROJECTION_OVERRIDE : int32_t {
+        VERTICAL_DEFAULT,
+        VERTICAL_SYMMETRIC,
+        VERTICAL_MATCHED
+    };
+
     static const inline std::string s_action_pose = "/actions/default/in/Pose";
     static const inline std::string s_action_grip_pose = "/actions/default/in/GripPose";
     static const inline std::string s_action_trigger = "/actions/default/in/Trigger";
@@ -102,6 +114,11 @@ class VR : public Mod {
         };
     }
 
+    // texture bounds to tell OpenVR which parts of the submitted texture to render (default - use the whole texture).
+    // Will be modified to accommodate forced symmetrical eye projection
+    vr::VRTextureBounds_t m_right_bounds{0.0f, 0.0f, 1.0f, 1.0f};
+    vr::VRTextureBounds_t m_left_bounds{0.0f, 0.0f, 1.0f, 1.0f};
+
     void on_config_load(const utility::Config& cfg, bool set_defaults) override;
     void on_config_save(utility::Config& cfg) override;
 
@@ -564,6 +581,18 @@ class VR : public Mod {
         return m_extreme_compat_mode->value();
     }
 
+    auto get_horiztonal_projection_override() const {
+        return m_horizontal_projection_override->value();
+    }
+
+    auto get_vertical_projection_override() const {
+        return m_vertical_projection_override->value();
+    }
+
+    bool should_grow_rectangle_for_projection_cropping() const {
+        return m_grow_rectangle_for_projection_cropping->value();
+    }
+
 private:
     Vector4f get_position_unsafe(uint32_t index) const;
     Vector4f get_velocity_unsafe(uint32_t index) const;
@@ -646,9 +675,6 @@ class VR : public Mod {
     std::vector<int32_t> m_controllers{};
     std::unordered_set<int32_t> m_controllers_set{};
 
-    vr::VRTextureBounds_t m_right_bounds{ 0.0f, 0.0f, 1.0f, 1.0f };
-    vr::VRTextureBounds_t m_left_bounds{ 0.0f, 0.0f, 1.0f, 1.0f };
-
     glm::vec3 m_overlay_rotation{-1.550f, 0.0f, -1.330f};
     glm::vec4 m_overlay_position{0.0f, 0.06f, -0.07f, 1.0f};
 
@@ -772,6 +798,18 @@ class VR : public Mod {
         "Gesture (Head) + Right Joystick",
     };
 
+    static const inline std::vector<std::string> s_horizontal_projection_override_names{
+        "Raw / default",
+        "Symmetrical",
+        "Mirrored",
+    };
+
+    static const inline std::vector<std::string> s_vertical_projection_override_names{
+        "Raw / default",
+        "Symmetrical",
+        "Matched",
+    };
+
     const ModCombo::Ptr m_rendering_method{ ModCombo::create(generate_name("RenderingMethod"), s_rendering_method_names) };
     const ModCombo::Ptr m_synced_afr_method{ ModCombo::create(generate_name("SyncedSequentialMethod"), s_synced_afr_method_names, 1) };
     const ModToggle::Ptr m_extreme_compat_mode{ ModToggle::create(generate_name("ExtremeCompatibilityMode"), false, true) };
@@ -789,6 +827,9 @@ class VR : public Mod {
     const ModToggle::Ptr m_2d_screen_mode{ ModToggle::create(generate_name("2DScreenMode"), false) };
     const ModToggle::Ptr m_roomscale_movement{ ModToggle::create(generate_name("RoomscaleMovement"), false) };
     const ModToggle::Ptr m_swap_controllers{ ModToggle::create(generate_name("SwapControllerInputs"), false) };
+    const ModCombo::Ptr m_horizontal_projection_override{ModCombo::create(generate_name("HorizontalProjectionOverride"), s_horizontal_projection_override_names)};
+    const ModCombo::Ptr m_vertical_projection_override{ModCombo::create(generate_name("VerticalProjectionOverride"), s_vertical_projection_override_names)};
+    const ModToggle::Ptr m_grow_rectangle_for_projection_cropping{ModToggle::create(generate_name("GrowRectangleForProjectionCropping"), false)};
 
     // Snap turn settings and globals
     void gamepad_snapturn(XINPUT_STATE& state);
@@ -918,6 +959,9 @@ class VR : public Mod {
         *m_2d_screen_mode,
         *m_roomscale_movement,
         *m_swap_controllers,
+        *m_horizontal_projection_override,
+        *m_vertical_projection_override,
+        *m_grow_rectangle_for_projection_cropping,
         *m_snapturn,
         *m_snapturn_joystick_deadzone,
         *m_snapturn_angle,
@@ -1094,4 +1138,4 @@ class VR : public Mod {
     friend class vrmod::D3D12Component;
     friend class vrmod::OverlayComponent;
     friend class FFakeStereoRenderingHook;
-};
+};

src/mods/vr/D3D11Component.cpp

@@ -559,8 +559,9 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
                 (void*)m_left_eye_tex.Get(), vr::TextureType_DirectX, vr::ColorSpace_Auto,
                 submit_pose
             };
-
-            const auto e = vr::VRCompositor()->Submit(vr::Eye_Left, &left_eye, &vr->m_left_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
+            auto const left_bounds = vr::VRTextureBounds_t{runtime->m_view_bounds[0][0], runtime->m_view_bounds[0][2],
+                                                           runtime->m_view_bounds[0][1], runtime->m_view_bounds[0][3]};
+            const auto e = vr::VRCompositor()->Submit(vr::Eye_Left, &left_eye, &left_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
 
             if (e != vr::VRCompositorError_None) {
                 spdlog::error("[VR] VRCompositor failed to submit left eye: {}", (int)e);
@@ -710,8 +711,9 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
                     (void*)m_left_eye_tex.Get(), vr::TextureType_DirectX, vr::ColorSpace_Auto,
                     submit_pose
                 };
-
-                e = vr::VRCompositor()->Submit(vr::Eye_Left, &left_eye, &vr->m_left_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
+                auto const left_bounds = vr::VRTextureBounds_t{runtime->m_view_bounds[0][0], runtime->m_view_bounds[0][2],
+                                                               runtime->m_view_bounds[0][1], runtime->m_view_bounds[0][3]};
+                e = vr::VRCompositor()->Submit(vr::Eye_Left, &left_eye, &left_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
 
                 if (e != vr::VRCompositorError_None) {
                     spdlog::error("[VR] VRCompositor failed to submit left eye: {}", (int)e);
@@ -760,8 +762,9 @@ vr::EVRCompositorError D3D11Component::on_frame(VR* vr) {
                 (void*)m_right_eye_tex.Get(), vr::TextureType_DirectX, vr::ColorSpace_Auto,
                 submit_pose
             };
-
-            e = vr::VRCompositor()->Submit(vr::Eye_Right, &right_eye, &vr->m_right_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
+            auto const right_bounds = vr::VRTextureBounds_t{runtime->m_view_bounds[1][0], runtime->m_view_bounds[1][2],
+                                                            runtime->m_view_bounds[1][1], runtime->m_view_bounds[1][3]};
+            e = vr::VRCompositor()->Submit(vr::Eye_Right, &right_eye, &right_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
             runtime->frame_synced = false;
 
             bool submitted = true;

src/mods/vr/D3D12Component.cpp

@@ -398,8 +398,9 @@ vr::EVRCompositorError D3D12Component::on_frame(VR* vr) {
                 (void*)&left, vr::TextureType_DirectX12, vr::ColorSpace_Auto,
                 submit_pose
             };
-
-            auto e = vr::VRCompositor()->Submit(vr::Eye_Left, &left_eye, &vr->m_left_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
+            auto const left_bounds = vr::VRTextureBounds_t{runtime->m_view_bounds[0][0], runtime->m_view_bounds[0][2],
+                                                           runtime->m_view_bounds[0][1], runtime->m_view_bounds[0][3]};
+            auto e = vr::VRCompositor()->Submit(vr::Eye_Left, &left_eye, &left_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
 
             if (e != vr::VRCompositorError_None) {
                 spdlog::error("[VR] VRCompositor failed to submit left eye: {}", (int)e);
@@ -496,8 +497,9 @@ vr::EVRCompositorError D3D12Component::on_frame(VR* vr) {
                     (void*)&left, vr::TextureType_DirectX12, vr::ColorSpace_Auto,
                     submit_pose
                 };
-
-                auto e = vr::VRCompositor()->Submit(vr::Eye_Left, &left_eye, &vr->m_left_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
+                auto const left_bounds = vr::VRTextureBounds_t{runtime->m_view_bounds[0][0], runtime->m_view_bounds[0][2],
+                                                               runtime->m_view_bounds[0][1], runtime->m_view_bounds[0][3]};
+                auto e = vr::VRCompositor()->Submit(vr::Eye_Left, &left_eye, &left_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
 
                 if (e != vr::VRCompositorError_None) {
                     spdlog::error("[VR] VRCompositor failed to submit left eye: {}", (int)e);
@@ -521,8 +523,9 @@ vr::EVRCompositorError D3D12Component::on_frame(VR* vr) {
                 (void*)&right, vr::TextureType_DirectX12, vr::ColorSpace_Auto,
                 submit_pose
             };
-
-            auto e = vr::VRCompositor()->Submit(vr::Eye_Right, &right_eye, &vr->m_right_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
+            auto const right_bounds = vr::VRTextureBounds_t{runtime->m_view_bounds[1][0], runtime->m_view_bounds[1][2],
+                                                            runtime->m_view_bounds[1][1], runtime->m_view_bounds[1][3]};
+            auto e = vr::VRCompositor()->Submit(vr::Eye_Right, &right_eye, &right_bounds, vr::EVRSubmitFlags::Submit_TextureWithPose);
             runtime->frame_synced = false;
 
             if (e != vr::VRCompositorError_None) {

src/mods/vr/OverlayComponent.cpp

@@ -327,6 +327,8 @@ void OverlayComponent::update_slate_openvr() {
 
     const auto is_d3d11 = g_framework->get_renderer_type() == Framework::RendererType::D3D11;
 
+    // TODO: do the sizing / scaling calculations below need to take into account non-standard VRTextureBounds_t
+    // when we force a symmetrical eye projection matrix?
     vr::VRTextureBounds_t bounds{};
     bounds.uMin = 0.0f;
     bounds.uMax = 1.0f;
@@ -424,6 +426,8 @@ bool OverlayComponent::update_wrist_overlay_openvr() {
         // so it doesn't become too intrusive during gameplay
         const auto scale = m_closed_ui ? 0.25f : 1.0f;
 
+        // TODO: do the sizing / scaling calculations below need to take into account non-standard VRTextureBounds_t
+        // when we force a symmetrical eye projection matrix?
         vr::VRTextureBounds_t bounds{};
         bounds.uMin = last_window_pos.x / render_target_width ;
         bounds.uMax = (last_window_pos.x + last_window_size.x) / render_target_width;
@@ -667,6 +671,8 @@ void OverlayComponent::update_overlay_openvr() {
         vr::VROverlay()->ShowOverlay(m_overlay_handle);
 
         // Show the entire texture
+        // TODO: do the sizing / scaling calculations below need to take into account non-standard VRTextureBounds_t
+        // when we force a symmetrical eye projection matrix?
         vr::VRTextureBounds_t bounds{};
         bounds.uMin = 0.0f;
         bounds.uMax = 1.0f;

src/mods/vr/runtimes/OpenVR.cpp

@@ -136,11 +136,25 @@ VRRuntime::Error OpenVR::update_render_target_size() {
 }
 
 uint32_t OpenVR::get_width() const {
-    return this->w;
+    auto width = this->w;
+    // if we've altered the default projection matrix we'll be cropping the image - if the image bounds are non-standard and
+    // the setting's enabled, scale the recommended width so the cropped width is the same as the recommended width
+    if (!(m_view_bounds[0][0] == 0 && m_view_bounds[0][1] == 1 && m_view_bounds[1][0] == 0 && m_view_bounds[1][1] == 1) &&
+        VR::get()->should_grow_rectangle_for_projection_cropping()) {
+        width = width / std::max(m_view_bounds[0][1] - m_view_bounds[0][0], m_view_bounds[1][1] - m_view_bounds[1][0]);
+    }
+    return width;
 }
 
 uint32_t OpenVR::get_height() const {
-    return this->h;
+    auto height = this->h;
+    // if we've altered the default projection matrix we'll be cropping the image - if the image bounds are non-standard and
+    // the setting's enabled, scale the recommended height so the cropped width is the same as the recommended height
+    if (!(m_view_bounds[0][2] == 0 && m_view_bounds[0][3] == 1 && m_view_bounds[1][2] == 0 && m_view_bounds[1][3] == 1) &&
+        VR::get()->should_grow_rectangle_for_projection_cropping()) {
+        height = height / std::max(m_view_bounds[0][3] - m_view_bounds[0][2], m_view_bounds[1][3] - m_view_bounds[1][2]);
+    }
+    return height;
 }
 
 VRRuntime::Error OpenVR::consume_events(std::function<void(void*)> callback) {
@@ -178,6 +192,7 @@ VRRuntime::Error OpenVR::consume_events(std::function<void(void*)> callback) {
     return VRRuntime::Error::SUCCESS;
 }
 
+// TODO: this is called 6 times per tick, which seems a bit generous
 VRRuntime::Error OpenVR::update_matrices(float nearz, float farz){
     std::unique_lock __{ this->eyes_mtx };
     const auto local_left = this->hmd->GetEyeToHeadTransform(vr::Eye_Left);
@@ -194,12 +209,55 @@ VRRuntime::Error OpenVR::update_matrices(float nearz, float farz){
 
     this->hmd->GetProjectionRaw(vr::Eye_Left, &this->raw_projections[vr::Eye_Left][0], &this->raw_projections[vr::Eye_Left][1], &this->raw_projections[vr::Eye_Left][2], &this->raw_projections[vr::Eye_Left][3]);
     this->hmd->GetProjectionRaw(vr::Eye_Right, &this->raw_projections[vr::Eye_Right][0], &this->raw_projections[vr::Eye_Right][1], &this->raw_projections[vr::Eye_Right][2], &this->raw_projections[vr::Eye_Right][3]);
+    // SPDLOG_INFO("Original left  {}, {}, {}, {}", this->raw_projections[0][0], this->raw_projections[0][1],this->raw_projections[0][2], this->raw_projections[0][3]);
+    // SPDLOG_INFO("Original right {}, {}, {}, {}", this->raw_projections[1][0], this->raw_projections[1][1],this->raw_projections[1][2], this->raw_projections[1][3]);
 
+    auto& vr = VR::get();
     auto get_mat = [&](vr::EVREye eye) {
-        const auto left =   this->raw_projections[eye][0] * -1.0f;
-        const auto right =  this->raw_projections[eye][1] * -1.0f;
-        const auto top =    this->raw_projections[eye][2] * -1.0f;
-        const auto bottom = this->raw_projections[eye][3] * -1.0f;
+        const auto tan_half_fov = new float[4];
+
+        if (vr->get_horiztonal_projection_override() == VR::HORIZONTAL_PROJECTION_OVERRIDE::HORIZONTAL_SYMMETRIC) {
+            // TODO: don't need to repeat this calculation for each eye?
+            tan_half_fov[0] = std::max(std::max(-this->raw_projections[0][0], this->raw_projections[0][1]),
+                                       std::max(-this->raw_projections[1][0], this->raw_projections[1][1]));
+            tan_half_fov[1] = -tan_half_fov[0];
+        } else if (vr->get_horiztonal_projection_override() == VR::HORIZONTAL_PROJECTION_OVERRIDE::HORIZONTAL_MIRROR) {
+            float max_outer = std::max(-this->raw_projections[0][0], this->raw_projections[1][1]);
+            float max_inner = std::max(this->raw_projections[0][1], -this->raw_projections[1][0]);
+            tan_half_fov[0] = eye == 0 ? max_outer : max_inner;
+            tan_half_fov[1] = eye == 0 ? -max_inner : -max_outer;
+        } else {
+            tan_half_fov[0] = -this->raw_projections[eye][0];
+            tan_half_fov[1] = -this->raw_projections[eye][1];
+        }
+
+        if (vr->get_vertical_projection_override() == VR::VERTICAL_PROJECTION_OVERRIDE::VERTICAL_SYMMETRIC) {
+            // TODO: don't need to repeat this calculation for each eye?
+            tan_half_fov[2] = std::max(std::max(-this->raw_projections[0][2], this->raw_projections[0][3]),
+                                       std::max(-this->raw_projections[1][2], this->raw_projections[1][3]));
+            tan_half_fov[3] = -tan_half_fov[2];
+        } else if (vr->get_vertical_projection_override() == VR::VERTICAL_PROJECTION_OVERRIDE::VERTICAL_MATCHED) {
+
+            float max_top = std::max(-this->raw_projections[0][2], -this->raw_projections[1][2]);
+            float max_bottom = std::max(this->raw_projections[0][3], this->raw_projections[1][3]);
+            tan_half_fov[2] = max_top;
+            tan_half_fov[3] = -max_bottom;
+        } else {
+            tan_half_fov[2] = -this->raw_projections[eye][2];
+            tan_half_fov[3] = -this->raw_projections[eye][3];
+        }
+        m_view_bounds[eye][0] = 0.5f + 0.5f * this->raw_projections[eye][0] / tan_half_fov[0];
+        m_view_bounds[eye][1] = 0.5f - 0.5f * this->raw_projections[eye][1] / tan_half_fov[1];
+        m_view_bounds[eye][2] = 0.5f + 0.5f * this->raw_projections[eye][2] / tan_half_fov[2];
+        m_view_bounds[eye][3] = 0.5f - 0.5f * this->raw_projections[eye][3] / tan_half_fov[3];
+        const auto left =   tan_half_fov[0];
+        const auto right =  tan_half_fov[1];
+        const auto top =    tan_half_fov[2];
+        const auto bottom = tan_half_fov[3];
+
+        // signs : at this point we expect right [1] and bottom [3] to be negative
+        // SPDLOG_INFO("derived for eye {} {}, {}, {}, {}", eye, left, right, top, bottom);
+        // SPDLOG_INFO("derived bounds eye {} {}, {}, {}, {}", eye, m_view_bounds[eye][0], m_view_bounds[eye][1], m_view_bounds[eye][2], m_view_bounds[eye][3]);
         float sum_rl = (left + right);
         float sum_tb = (top + bottom);
         float inv_rl = (1.0f / (left - right));