Merge pull request #32 from amwatson/lubos_immersive_mode

Lubos VR180 immersive mode

Author: amwatson

src/android/app/src/main/java/org/citra/citra_emu/features/settings/model/view/CheckBoxSetting.java

@@ -10,13 +10,15 @@
 public final class CheckBoxSetting extends SettingsItem {
     private boolean mDefaultValue;
     private boolean mShowPerformanceWarning;
+    private boolean mShowGraphicsWarning;
     private SettingsFragmentView mView;
 
     public CheckBoxSetting(String key, String section, int titleId, int descriptionId,
                            boolean defaultValue, Setting setting) {
         super(key, section, setting, titleId, descriptionId);
         mDefaultValue = defaultValue;
         mShowPerformanceWarning = false;
+        mShowGraphicsWarning = false;
     }
 
     public CheckBoxSetting(String key, String section, int titleId, int descriptionId,
@@ -27,6 +29,15 @@ public CheckBoxSetting(String key, String section, int titleId, int descriptionI
         mShowPerformanceWarning = show_performance_warning;
     }
 
+    public CheckBoxSetting(String key, String section, int titleId, int descriptionId,
+        boolean defaultValue, Setting setting, boolean show_performance_warning, boolean show_graphics_warning, SettingsFragmentView view) {
+      super(key, section, setting, titleId, descriptionId);
+      mDefaultValue = defaultValue;
+      mView = view;
+      mShowPerformanceWarning = show_performance_warning;
+      mShowGraphicsWarning = show_graphics_warning;
+    }
+
     public boolean isChecked() {
         if (getSetting() == null) {
             return mDefaultValue;
@@ -61,6 +72,9 @@ public IntSetting setChecked(boolean checked) {
         if (mShowPerformanceWarning && !checked) {
             mView.showToastMessage(CitraApplication.getAppContext().getString(R.string.performance_warning), true);
         }
+        if (mShowGraphicsWarning && checked) {
+            mView.showToastMessage(CitraApplication.getAppContext().getString(R.string.vr_graphics_warning_short), true);
+        }
 
         if (getSetting() == null) {
             IntSetting setting = new IntSetting(getKey(), getSection(), checked ? 1 : 0);

src/android/app/src/main/java/org/citra/citra_emu/features/settings/ui/SettingsFragmentPresenter.java

@@ -432,9 +432,10 @@ private void addVRSettings(ArrayList<SettingsItem> sl) {
         Setting vrEnvironment = vrSection.getSetting(SettingsFile.KEY_VR_ENVIRONMENT);
         Setting vrExtraPerformanceMode = vrSection.getSetting(SettingsFile.KEY_VR_EXTRA_PERFORMANCE_MODE);
         Setting vrCpuLevel = vrSection.getSetting(SettingsFile.KEY_VR_CPU_LEVEL);
+        Setting vrImmersiveMode = vrSection.getSetting(SettingsFile.KEY_VR_IMMERSIVE_MODE);
         sl.add(new SingleChoiceSetting(SettingsFile.KEY_VR_ENVIRONMENT, Settings.SECTION_VR, R.string.vr_background, 0, R.array.vrBackgroundNames, R.array.vrBackgroundValues, VRUtils.getHMDType() == VRUtils.HMDType.QUEST3.getValue() ? 1 : 2, vrEnvironment));
         sl.add(new CheckBoxSetting(SettingsFile.KEY_VR_EXTRA_PERFORMANCE_MODE, Settings.SECTION_VR, R.string.vr_extra_performance_mode, R.string.vr_extra_performance_mode_description, false, vrExtraPerformanceMode));
         sl.add(new SingleChoiceSetting(SettingsFile.KEY_VR_CPU_LEVEL, Settings.SECTION_VR, R.string.vr_cpu_level, R.string.vr_cpu_level_description, R.array.vrCpuLevelNames, R.array.vrCpuLevelValues, 3, vrCpuLevel));
-
+        sl.add(new CheckBoxSetting(SettingsFile.KEY_VR_IMMERSIVE_MODE, Settings.SECTION_VR, R.string.vr_immersive_mode_title, R.string.vr_immersive_mode_description, false, vrImmersiveMode, false, true, mView));   
     }
 }

src/android/app/src/main/java/org/citra/citra_emu/features/settings/utils/SettingsFile.java

@@ -133,9 +133,9 @@ public final class SettingsFile {
     public static final String KEY_CAMERA_INNER_FLIP = "camera_inner_flip";
     public static final String KEY_VR_ENVIRONMENT = "vr_environment";
     public static final String KEY_VR_EXTRA_PERFORMANCE_MODE = "vr_extra_performance_mode";
-
     public static final String KEY_VR_CPU_LEVEL = "vr_cpu_level";
 
+    public static final String KEY_VR_IMMERSIVE_MODE = "vr_immersive_mode";
     public static final String KEY_LOG_FILTER = "log_filter";
 
     private static BiMap<String, String> sectionsMap = new BiMap<>();

src/android/app/src/main/java/org/citra/citra_emu/ui/main/MainActivity.java

@@ -184,6 +184,10 @@ protected void onCreate(Bundle savedInstanceState) {
                 requestNotificationPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS);
             }
         }
+        if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
+            // Request permission if it's not granted
+            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.RECORD_AUDIO}, 0);
+        }
         // Check for the TWO_INSTANCES string extra
         if (getIntent().getBooleanExtra(VrActivity.EXTRA_ERROR_TWO_INSTANCES, false)) {
           Log.error("Error: two instances of CitraVr::VrActivity were running at the same time!");
@@ -214,10 +218,6 @@ protected void onSaveInstanceState(@NonNull Bundle outState) {
     @Override
     protected void onResume() {
         super.onResume();
-        if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
-            // Request permission if it's not granted
-            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.RECORD_AUDIO}, 0);
-        }
         mPresenter.addDirIfNeeded(new AddDirectoryHelper(this));
 
         ThemeUtil.setSystemBarMode(this, ThemeUtil.getIsLightMode(getResources()));

src/android/app/src/main/jni/config.cpp

@@ -301,11 +301,25 @@ void Config::ReadValues() {
           "VR", "vr_environment",
           static_cast<long>(VRSettings::values.hmd_type == VRSettings::HMDType::QUEST3 ?
             VRSettings::VREnvironmentType::PASSTHROUGH : VRSettings::VREnvironmentType::VOID));
-
     VRSettings::values.cpu_level =
       VRSettings::values.extra_performance_mode_enabled ? XR_HIGHEST_CPU_PERF_LEVEL
       : VRSettings::CPUPrefToPerfSettingsLevel(sdl2_config->GetInteger(
-            "VR", "vr_cpu_level", 3));
+           "VR", "vr_cpu_level", 3));
+    Settings::values.vr_use_immersive_mode = sdl2_config->GetBoolean(
+        "VR", "vr_immersive_mode", false);
+
+    if (Settings::values.vr_use_immersive_mode) {
+      LOG_INFO(Config, "VR immersive mode enabled");
+
+      // no point rendering passthrough in immersive mode
+      VRSettings::values.vr_environment =
+        static_cast<uint32_t>(VRSettings::VREnvironmentType::VOID);
+      // We originally had two immersive modes, but I cut them down to fit in
+      // the shader map's bitfield.
+      VRSettings::values.vr_immersive_mode = 2;
+      // When immersive mode is enabled, only OpenGL is supported.
+      Settings::values.graphics_api = Settings::GraphicsAPI::OpenGL;
+    }
 
     // Miscellaneous
     ReadSetting("Miscellaneous", Settings::values.log_filter);

src/android/app/src/main/jni/vr/layers/GameSurfaceLayer.cpp

@@ -14,6 +14,8 @@ License     :   Licensed under GPLv3 or any later version.
 
 #include "GameSurfaceLayer.h"
 
+#include "../vr_settings.h"
+
 #include "../utils/JniUtils.h"
 #include "../utils/LogUtils.h"
 #include "../utils/SyspropUtils.h"
@@ -29,6 +31,9 @@ License     :   Licensed under GPLv3 or any later version.
 namespace {
 
 constexpr float lowerPanelScaleFactor = 0.75f;
+
+const std::vector<float> immersiveLevelFactor = {1.0f, 5.0f, 3.0f};
+
 /** Used to translate texture coordinates into the corresponding coordinates
  * on the Android Activity Window.
  *
@@ -223,9 +228,16 @@ GameSurfaceLayer::GameSurfaceLayer(const XrVector3f&& position, JNIEnv* env, job
                                    const XrSession& session, const uint32_t resolutionFactor)
     : session_(session), topPanelFromWorld_(CreateTopPanelFromWorld(position)),
       lowerPanelFromWorld_(CreateLowerPanelFromWorld(topPanelFromWorld_)),
-      resolutionFactor_(resolutionFactor), env_(env), activityObject_(activityObject)
+      resolutionFactor_(resolutionFactor), immersiveMode_(VRSettings::values.vr_immersive_mode),
+      env_(env), activityObject_(activityObject)
 
 {
+    assert(immersiveMode_ == 0 || immersiveMode_ == 1);
+    if (immersiveMode_ > 0) {
+        ALOGI("Using VR immersive mode {}", immersiveMode_);
+        topPanelFromWorld_.position.z = lowerPanelFromWorld_.position.z;
+        lowerPanelFromWorld_.position.y = -1.0f - (0.5f * (immersiveMode_ - 1));
+    }
     const int32_t initializationStatus = Init(activityObject, position, session);
     if (initializationStatus < 0) {
         FAIL("Could not initialize GameSurfaceLayer -- error '%d'", initializationStatus);
@@ -252,8 +264,8 @@ void GameSurfaceLayer::Frame(const XrSpace& space, std::vector<XrCompositionLaye
         static_cast<double>(2 * panelWidth) / static_cast<double>(panelHeight);
     // Prevent a seam between the top and bottom view
     constexpr uint32_t verticalBorderTex = 1;
-    const int32_t useCylinder = GetCylinderSysprop();
-    if (useCylinder == 1) {
+    const bool useCylinder = (GetCylinderSysprop() != 0) || (immersiveMode_ > 0);
+    if (useCylinder) {
 
         // Create the Top Display Panel (Curved display)
         for (uint32_t eye = 0; eye < NUM_EYES; eye++) {
@@ -284,7 +296,9 @@ void GameSurfaceLayer::Frame(const XrSpace& space, std::vector<XrCompositionLaye
             // scale of the texture.
             const float radius = GetRadiusSysprop();
             layer.radius = radius;
-            layer.centralAngle = GetCentralAngleSysprop() * MATH_FLOAT_PI / 180.0f;
+            layer.centralAngle = (!immersiveMode_ ? GetCentralAngleSysprop()
+                                                  : 55.0f * immersiveLevelFactor[immersiveMode_]) *
+                                 MATH_FLOAT_PI / 180.0f;
             layer.aspectRatio = -aspectRatio;
             layers[layerCount++].mCylinder = layer;
         }
@@ -343,10 +357,15 @@ void GameSurfaceLayer::Frame(const XrSpace& space, std::vector<XrCompositionLaye
         layer.eyeVisibility = XR_EYE_VISIBILITY_BOTH;
         memset(&layer.subImage, 0, sizeof(XrSwapchainSubImage));
         layer.subImage.swapchain = swapchain_.Handle;
-        layer.subImage.imageRect.offset.x = cropHoriz / 2;
-        layer.subImage.imageRect.offset.y = panelHeight + verticalBorderTex;
-        layer.subImage.imageRect.extent.width = panelWidth - cropHoriz;
-        layer.subImage.imageRect.extent.height = panelHeight;
+        layer.subImage.imageRect.offset.x =
+            (cropHoriz / 2) / immersiveLevelFactor[immersiveMode_] +
+            panelWidth * (0.5f - (0.5f / immersiveLevelFactor[immersiveMode_]));
+        layer.subImage.imageRect.offset.y =
+            panelHeight + verticalBorderTex +
+            panelHeight * (0.5f - (0.5f / immersiveLevelFactor[immersiveMode_]));
+        layer.subImage.imageRect.extent.width =
+            (panelWidth - cropHoriz) / immersiveLevelFactor[immersiveMode_];
+        layer.subImage.imageRect.extent.height = panelHeight / immersiveLevelFactor[immersiveMode_];
         layer.subImage.imageArrayIndex = 0;
         layer.pose = lowerPanelFromWorld_;
         const auto scale = GetDensityScaleForSize(panelWidth - cropHoriz, -panelHeight,

src/android/app/src/main/jni/vr/layers/GameSurfaceLayer.h

@@ -158,6 +158,18 @@ class GameSurfaceLayer {
     // resolution.
     const uint32_t resolutionFactor_;
 
+    // EXPERIMENTAL: When true, the top screen + its extents
+    // (previously-unseen parts of the scene) are projected onto a 275-degree
+    // cylinder. Note that the perceived resolution is lower,
+    // as the output image is larger, both in texture size and perceived layer
+    // size.
+    //
+    // Rendering a higher-resolution image would likely require
+    // performance optimizations to avoid maxing out the GPU, e.g.:
+    //   - Multiview (requires a merged Citra/CitraVR renderer)
+    //   - Rendering the top-screen and bottom screen separately.
+    const uint32_t immersiveMode_;
+
     //============================
     // JNI objects
     JNIEnv* env_ = nullptr;

src/android/app/src/main/jni/vr/vr_main.cpp

@@ -206,9 +206,14 @@ class VRApp {
             const uint32_t defaultResolutionFactor =
                 GetDefaultGameResolutionFactorForHmd(VRSettings::values.hmd_type);
             const uint32_t resolutionFactorFromPreferences = VRSettings::values.resolution_factor;
-            const uint32_t resolutionFactor = resolutionFactorFromPreferences > 0
+            // add a couple factors to resolution with immersive mode so users
+            // aren't resetting their default settings to get higher res. min
+            // resolution factor for immersive is 3x.
+            const uint32_t immersiveModeOffset = (VRSettings::values.vr_immersive_mode > 0) ? 2 : 0;
+            const uint32_t resolutionFactor = (resolutionFactorFromPreferences > 0
                                                   ? resolutionFactorFromPreferences
-                                                  : defaultResolutionFactor;
+                                                  : defaultResolutionFactor) + immersiveModeOffset;
+
             if (resolutionFactor != defaultResolutionFactor) {
                 ALOGI("Using resolution factor of {}x instead of HMD default {}x", resolutionFactor,
                       defaultResolutionFactor);

src/android/app/src/main/jni/vr/vr_settings.h

@@ -37,11 +37,12 @@ std::string GetHMDTypeStr();
 HMDType HmdTypeFromStr(const std::string& hmdType);
 
 struct Values {
-    bool extra_performance_mode_enabled = false;
-    int32_t vr_environment = 0;
     XrPerfSettingsLevelEXT cpu_level = XR_PERF_SETTINGS_LEVEL_SUSTAINED_HIGH_EXT;
-    uint32_t resolution_factor = 0;
     HMDType hmd_type = HMDType::UNKNOWN;
+    uint32_t resolution_factor = 0;
+    int32_t vr_environment = 0;
+    int32_t vr_immersive_mode = 0;
+    bool extra_performance_mode_enabled = false;
 } extern values;
 
 } // namespace VRSettings

src/android/app/src/main/res/values-de/strings.xml

@@ -173,4 +173,8 @@
     <string name="vr_extra_performance_mode">VR zusätzlicher Leistungsmodus</string>
     <string name="vr_cpu_level">CPU -Ebene</string>
     <string name="vr_cpu_level_description">Höhere Werte können die Audio-/Emulationsleistung verbessern, die Batterie jedoch schneller abtropfen lassen</string>
+    <string name="vr_immersive_mode_title">[Warnung: Grafikartefakte] Immersive Modus (experimentell)</string>
+    <string name="vr_immersive_mode_description">Erweitert den oberen Bildschirm um einen Zylinder für ein immersives Gameplay</string>
+    <string name="vr_graphics_warning">Gefahr: Nicht alle Spiele/Levels sehen im beeindruckenden Modus gut aus. Große visuelle Artefakte sind häufig, wenn diese Option ausgewählt ist</string>
+    <string name="vr_graphics_warning_short">Warnung: Dies führt zu visuellen Artefakten in den meisten Inhalten</string>
 </resources>