overlay: change active option color to green

## Link to GitHub Issue, if one exists
n/a

## Description of change

In Options (and in Advanced/API/Search tabs), remove the help marker
`(?)` and instead add a tooltip to the option name label and the control
widgets like the checkbox, text input, and combo. This is to help with
discoverability as many users failed to discover the `(?)` widget.

Similarly, update the Patches tab to remove `(?)` and add tooltips to
widgets. Patches with warnings `(!)` will continue to show it to
distinguish it from other patches.

Update styling for the tooltip (dark red background -> dark gray) so
that it stands out from other widgets.

Remove the purple option text used for game-specific options.

## Compiling
👍 

## Testing
Tested in spicecfg, and in-game overlay.

src/spice2x/cfg/screen_resize.cpp

@@ -81,16 +81,12 @@ namespace cfg {
         load_bool_value(doc, root + "enable_linear_filter", this->enable_linear_filter);
         for (size_t i = 0; i < std::size(this->scene_settings); i++) {
             auto& scene = this->scene_settings[i];
-            std::string prefix = "";
-            if (0 < i) {
-                prefix += fmt::format("scenes/{}/", i-1);
-            }
+            const std::string prefix = fmt::format("scenes/{}/", i);
             load_int_value(doc, root + prefix + "offset_x", scene.offset_x);
             load_int_value(doc, root + prefix + "offset_y", scene.offset_y);
             load_float_value(doc, root + prefix + "scale_x", scene.scale_x);
             load_float_value(doc, root + prefix + "scale_y", scene.scale_y);
             load_bool_value(doc, root + prefix + "keep_aspect_ratio", scene.keep_aspect_ratio);
-            load_bool_value(doc, root + prefix + "centered", scene.centered);
         }
 
         // windowed settings are always under game settings
@@ -201,16 +197,12 @@ namespace cfg {
         rapidjson::Pointer(root + "enable_linear_filter").Set(doc, this->enable_linear_filter);
         for (size_t i = 0; i < std::size(this->scene_settings); i++) {
             auto& scene = this->scene_settings[i];
-            std::string prefix = "";
-            if (0 < i) {
-                prefix += fmt::format("scenes/{}/", i-1);
-            }
+            const std::string prefix = fmt::format("scenes/{}/", i);
             rapidjson::Pointer(root + prefix + "offset_x").Set(doc, scene.offset_x);
             rapidjson::Pointer(root + prefix + "offset_y").Set(doc, scene.offset_y);
             rapidjson::Pointer(root + prefix + "scale_x").Set(doc, scene.scale_x);
             rapidjson::Pointer(root + prefix + "scale_y").Set(doc, scene.scale_y);
             rapidjson::Pointer(root + prefix + "keep_aspect_ratio").Set(doc, scene.keep_aspect_ratio);
-            rapidjson::Pointer(root + prefix + "centered").Set(doc, scene.centered);
         }
 
         // windowed mode settings

src/spice2x/cfg/screen_resize.h

@@ -20,7 +20,6 @@ namespace cfg {
         float scale_x = 1.0;
         float scale_y = 1.0;
         bool keep_aspect_ratio = true;
-        bool centered = true;
     };
 
     extern std::optional<std::string> SCREEN_RESIZE_CFG_PATH_OVERRIDE;

src/spice2x/changelog.txt

@@ -1,3 +1,8 @@
+03/29/2025 [spice2x]
+    Add SDVX landscape mode, -forceresswap option
+    Fix bugs in image scaler
+    Configurator UI tweaks
+
 03/25/2025 [spice2x]
     Add Mahjong Fight Girl support
     Add option for custom full screen resolution (-forceres)

src/spice2x/games/sdvx/sdvx.h

@@ -11,7 +11,9 @@ namespace games::sdvx {
     enum SdvxOverlayPosition {
         SDVX_OVERLAY_TOP,
         SDVX_OVERLAY_MIDDLE,
-        SDVX_OVERLAY_BOTTOM
+        SDVX_OVERLAY_BOTTOM,
+        SDVX_OVERLAY_BOTTOM_LEFT,
+        SDVX_OVERLAY_BOTTOM_RIGHT
     };
 
     // settings

src/spice2x/hooks/graphics/backends/d3d9/d3d9_backend.cpp

@@ -681,10 +681,27 @@ HRESULT STDMETHODCALLTYPE WrappedIDirect3D9::CreateDevice(
     // dump presentation parameters
     for (size_t i = 0; i < num_adapters; i++) {
         auto *params = &pPresentationParameters[i];
-
-        if (!GRAPHICS_WINDOWED && i == 0 && GRAPHICS_FS_CUSTOM_RESOLUTION.has_value()) {
-            params->BackBufferWidth = GRAPHICS_FS_CUSTOM_RESOLUTION.value().first;
-            params->BackBufferHeight = GRAPHICS_FS_CUSTOM_RESOLUTION.value().second;
+        if (!GRAPHICS_WINDOWED && i == 0) {
+            GRAPHICS_FS_ORIGINAL_WIDTH = params->BackBufferWidth;
+            GRAPHICS_FS_ORIGINAL_HEIGHT = params->BackBufferHeight;
+            log_misc("graphics::d3d9", "original resolution: {}x{}", GRAPHICS_FS_ORIGINAL_WIDTH, GRAPHICS_FS_ORIGINAL_HEIGHT);
+            if (GRAPHICS_FS_CUSTOM_RESOLUTION.has_value()) {
+                log_misc(
+                    "graphics::d3d9",
+                    "use custom resolution {}x{} => {}x{}",
+                    params->BackBufferWidth, params->BackBufferHeight,
+                    GRAPHICS_FS_CUSTOM_RESOLUTION.value().first,
+                    GRAPHICS_FS_CUSTOM_RESOLUTION.value().second);
+                params->BackBufferWidth = GRAPHICS_FS_CUSTOM_RESOLUTION.value().first;
+                params->BackBufferHeight = GRAPHICS_FS_CUSTOM_RESOLUTION.value().second;
+            } else if (GRAPHICS_FS_ORIENTATION_SWAP) {
+                log_misc(
+                    "graphics::d3d9",
+                    "swap full orientation {}x{} => {}x{}",
+                    params->BackBufferWidth, params->BackBufferHeight,
+                    params->BackBufferHeight, params->BackBufferWidth);
+                std::swap(params->BackBufferWidth, params->BackBufferHeight);
+            }
         }
 
         log_info("graphics::d3d9",
@@ -852,10 +869,27 @@ HRESULT STDMETHODCALLTYPE WrappedIDirect3D9::CreateDeviceEx(
 
     for (size_t i = 0; i < num_adapters; i++) {
         auto *params = &pPresentationParameters[i];
-
-        if (!GRAPHICS_WINDOWED && i == 0 && GRAPHICS_FS_CUSTOM_RESOLUTION.has_value()) {
-            params->BackBufferWidth = GRAPHICS_FS_CUSTOM_RESOLUTION.value().first;
-            params->BackBufferHeight = GRAPHICS_FS_CUSTOM_RESOLUTION.value().second;
+        if (!GRAPHICS_WINDOWED && i == 0) {
+            GRAPHICS_FS_ORIGINAL_WIDTH = params->BackBufferWidth;
+            GRAPHICS_FS_ORIGINAL_HEIGHT = params->BackBufferHeight;
+            log_misc("graphics::d3d9", "original resolution: {}x{}", GRAPHICS_FS_ORIGINAL_WIDTH, GRAPHICS_FS_ORIGINAL_HEIGHT);
+            if (GRAPHICS_FS_CUSTOM_RESOLUTION.has_value()) {
+                log_misc(
+                    "graphics::d3d9",
+                    "use custom resolution {}x{} => {}x{}",
+                    params->BackBufferWidth, params->BackBufferHeight,
+                    GRAPHICS_FS_CUSTOM_RESOLUTION.value().first,
+                    GRAPHICS_FS_CUSTOM_RESOLUTION.value().second);
+                params->BackBufferWidth = GRAPHICS_FS_CUSTOM_RESOLUTION.value().first;
+                params->BackBufferHeight = GRAPHICS_FS_CUSTOM_RESOLUTION.value().second;
+            } else if (GRAPHICS_FS_ORIENTATION_SWAP) {
+                log_misc(
+                    "graphics::d3d9",
+                    "swap full orientation {}x{} => {}x{}",
+                    params->BackBufferWidth, params->BackBufferHeight,
+                    params->BackBufferHeight, params->BackBufferWidth);
+                std::swap(params->BackBufferWidth, params->BackBufferHeight);
+            }
         }
 
         log_info("graphics::d3d9",
@@ -882,9 +916,13 @@ HRESULT STDMETHODCALLTYPE WrappedIDirect3D9::CreateDeviceEx(
         for (size_t i = 0; i < num_adapters; i++) {
             auto *fullscreen_display_mode = &pFullscreenDisplayMode[i];
 
-            if (!GRAPHICS_WINDOWED && i == 0 && GRAPHICS_FS_CUSTOM_RESOLUTION.has_value()) {
-                fullscreen_display_mode->Width = GRAPHICS_FS_CUSTOM_RESOLUTION.value().first;
-                fullscreen_display_mode->Height = GRAPHICS_FS_CUSTOM_RESOLUTION.value().second;
+            if (!GRAPHICS_WINDOWED && i == 0) {
+                if (GRAPHICS_FS_CUSTOM_RESOLUTION.has_value()) {
+                    fullscreen_display_mode->Width = GRAPHICS_FS_CUSTOM_RESOLUTION.value().first;
+                    fullscreen_display_mode->Height = GRAPHICS_FS_CUSTOM_RESOLUTION.value().second;
+                } else if (GRAPHICS_FS_ORIENTATION_SWAP) {
+                    std::swap(fullscreen_display_mode->Width, fullscreen_display_mode->Height);
+                }
             }
 
             log_info("graphics::d3d9",

src/spice2x/hooks/graphics/backends/d3d9/d3d9_device.cpp

@@ -7,6 +7,7 @@
 #include "hooks/graphics/graphics.h"
 #include "overlay/overlay.h"
 #include "util/flags_helper.h"
+#include "util/utils.h"
 #include "cfg/screen_resize.h"
 
 #include "d3d9_backend.h"
@@ -692,89 +693,181 @@ static IDirect3DSurface9 *backbuffer = nullptr;
 static LPDIRECT3DSWAPCHAIN9 mSwapChain = nullptr;
 static IDirect3DTexture9* tex;
 
+static UINT topSurface_width = 0;
+static UINT topSurface_height = 0;
+static float topSurface_aspect_ratio = 1.f;
+
 void SurfaceHook(IDirect3DDevice9 *pReal) {
-    // log_misc("graphics::d3d9", "SurfaceHook called");
     D3DPRESENT_PARAMETERS param {};
 
     pReal->GetSwapChain(0, &mSwapChain);
     mSwapChain->GetPresentParameters(&param);
+
+    // phase 0 - create a surface that has the same aspect ratio as the original back buffer
+    //           but larger in size. this is needed to ensure that when the user zooms out, we have
+    //           sufficient buffer space (black border) around the original image
+    //
+    //           (only done once)
     if (!topSurface) {
-        if (pReal->CreateTexture(4096, 4096, 1,
+        topSurface_width = param.BackBufferWidth * 3;
+        topSurface_height = param.BackBufferHeight * 3;
+        topSurface_aspect_ratio = (float)topSurface_width / (float)topSurface_height;
+        if (pReal->CreateTexture(topSurface_width, topSurface_height, 1,
             D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8,
             D3DPOOL_DEFAULT, &tex, NULL) != D3D_OK) {
-            log_misc("graphics::d3d9", "create texture failed");
-
+            log_warning("graphics::d3d9", "SurfaceHook - create texture failed");
         }
-        log_misc("graphics::d3d9", "Backbuffer: {} {} {}",
-                param.BackBufferWidth, param.BackBufferHeight, param.BackBufferCount);
-        tex->GetSurfaceLevel(0, &topSurface);
 
+        log_misc(
+            "graphics::d3d9", "SurfaceHook - Backbuffer: {} {} {}",
+            param.BackBufferWidth, param.BackBufferHeight, param.BackBufferCount);
+
+        tex->GetSurfaceLevel(0, &topSurface);
         if (mSwapChain->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &backbuffer) != D3D_OK) {
-            log_misc("graphics::d3d9", "GetBackBuffer failed");
+            log_warning("graphics::d3d9", "SurfaceHook - GetBackBuffer failed");
         }
     }
 
-    const int rectLeft = 1024;
-    const int rectTop = 576;
+    // pre-calculate dimensions used for phase 1
+    const int rectLeft = param.BackBufferWidth;
+    const int rectTop = param.BackBufferHeight;
     const int w = param.BackBufferWidth;
     const int h = param.BackBufferHeight;
+    
     D3DLOCKED_RECT rect;
+    HRESULT hr;
+    topSurface->LockRect(&rect, NULL, D3DLOCK_DONOTWAIT);
 
+    // phase 1 - copy the original back buffer onto the new surface.
+    //           we draw it 1:1 in the center of the surface.
+    //           if orientation is swapped, fix up the rect and draw it in the center.
+    //
+    //           for this phase we always render with the same rect so that it's always overwritten
+    //           by a new frame on the same spot.
+    RECT originRect {
+        rectLeft,
+        rectTop,
+        (LONG)(rectLeft + w),
+        (LONG)(rectTop + h),
+    };
+    if (GRAPHICS_FS_ORIENTATION_SWAP) {
+        originRect.left = (topSurface_width / 2) - (GRAPHICS_FS_ORIGINAL_WIDTH / 2);
+        originRect.top = (topSurface_height / 2) - (GRAPHICS_FS_ORIGINAL_HEIGHT / 2);
+        originRect.right = originRect.left + GRAPHICS_FS_ORIGINAL_WIDTH;
+        originRect.bottom = originRect.top + GRAPHICS_FS_ORIGINAL_HEIGHT;
+    }
+
+    // log_misc(
+    //     "graphics::d3d9", "originRect: {} {} {} {}",
+    //     originRect.left, originRect.top, originRect.right, originRect.bottom);
+
+    hr = pReal->StretchRect(
+            backbuffer, nullptr,
+            topSurface, &originRect,
+            D3DTEXF_LINEAR);
+    if (hr != D3D_OK) {
+        log_warning(
+            "graphics::d3d9",
+            "SurfaceHook - StretchRect backbuffer failed, rect: {} {} {} {}",
+            originRect.left, originRect.top, originRect.right, originRect.bottom);
+    }
+    topSurface->UnlockRect();
+
+    // phase 2 - viewport calculation - do the actual zoom / offset math
+    //           figure out what region of the surface to copy back to the back buffer.
     RECT targetRect {
         rectLeft,
         rectTop,
         (LONG)(rectLeft + w),
         (LONG)(rectTop + h),
     };
+    if (cfg::SCREENRESIZE->enable_screen_resize) {
+        auto& scene = cfg::SCREENRESIZE->scene_settings[cfg::SCREENRESIZE->screen_resize_current_scene];
+        auto w_new = w / scene.scale_x;
+        auto h_new = h / scene.scale_y;
 
-    // stretch to add top/left offset to avoid going negative
-    topSurface->LockRect(&rect, NULL, D3DLOCK_DONOTWAIT);
-    auto hr = pReal->StretchRect(
-        backbuffer, nullptr,
-        topSurface, &targetRect,
-        D3DTEXF_LINEAR);
+        // make sure the scaling is within bounds
+        if (cfg::SCREENRESIZE->client_keep_aspect_ratio) {
+            if (w_new > topSurface_width || h_new > topSurface_height) {
+                w_new = topSurface_width;
+                h_new = topSurface_height;
+            }
+        } else {
+            w_new = MIN(w_new, topSurface_width);
+            h_new = MIN(h_new, topSurface_height);
+        }
 
-    if (hr != D3D_OK) {
-        log_misc("graphics::d3d9", "StretchRect backbuffer failed");
-    }
-    topSurface->UnlockRect();
+        targetRect.left = (topSurface_width / 2) - (w_new / 2) - scene.offset_x;
+        targetRect.top = (topSurface_height / 2) - (h_new / 2) - scene.offset_y;
+        targetRect.right = targetRect.left + w_new;
+        targetRect.bottom = targetRect.top + h_new;
 
-    // do the actual zoom / offset math
-    auto& scene = cfg::SCREENRESIZE->scene_settings[cfg::SCREENRESIZE->screen_resize_current_scene];
-    if (scene.centered) {
-        targetRect.right = (w + rectLeft) / scene.scale_x;
-        targetRect.bottom = (h + rectTop) / scene.scale_y;
-        const LONG deltaH = ((targetRect.bottom - targetRect.top) - h) / 2;
-        const LONG deltaW = ((targetRect.right - targetRect.left) - w) / 2;
-        targetRect.top -= deltaH;
-        targetRect.bottom -= deltaH;
-        targetRect.left -= deltaW;
-        targetRect.right -= deltaW;
-    } else {
-        targetRect.left -= scene.offset_x;
-        targetRect.top += scene.offset_y;
-        targetRect.right = -scene.offset_x;
-        targetRect.right += (w + rectLeft) / scene.scale_x;
-        targetRect.bottom = scene.offset_y;
-        targetRect.bottom += (h + rectTop) / scene.scale_y;
+        // boundary check to prevent StretchRect failures
+        if (targetRect.left < 0) {
+            targetRect.left = 0;
+            targetRect.right = w_new;
+        } else if (targetRect.right > (LONG)topSurface_width) {
+            targetRect.left = topSurface_width - w_new;
+            targetRect.right = topSurface_width;
+        }
+        if (targetRect.top < 0) {
+            targetRect.top = 0;
+            targetRect.bottom = h_new;
+        } else if (targetRect.bottom > (LONG)topSurface_height) {
+            targetRect.top = topSurface_height - h_new;
+            targetRect.bottom = topSurface_height;
+        }
+
+    } else if (GRAPHICS_FS_ORIENTATION_SWAP) {
+        // increase the viewport to fit the image on screen (effectively, zoom out a little)
+        if (GRAPHICS_FS_ORIGINAL_WIDTH < GRAPHICS_FS_ORIGINAL_HEIGHT) {
+            // portrait game on landscape display
+            // height should match the original image
+            targetRect.top = originRect.top;
+            targetRect.bottom = originRect.bottom;
+
+            // width of viewport should be wider, effectively shrinking the image on x-axis when rendered
+            const auto w_new = GRAPHICS_FS_ORIGINAL_HEIGHT * topSurface_aspect_ratio;
+            targetRect.left = (topSurface_width / 2) - (w_new / 2);
+            targetRect.right = targetRect.left + w_new;
+        } else {
+            // landscape game on portrait display
+            targetRect.left = originRect.left;
+            targetRect.right = originRect.right;
+
+            // height of viewport should be taller, effectively shrinking the image on y-axis when rendered
+            const auto h_new = GRAPHICS_FS_ORIGINAL_WIDTH / topSurface_aspect_ratio;
+            targetRect.top = (topSurface_height / 2) - (h_new / 2);
+            targetRect.bottom = targetRect.top + h_new;
+        }
     }
 
-    // draw to back buffer
+    // log_misc("graphics::d3d9", "targetRect: {} {} {} {}",
+    //     targetRect.left, targetRect.top, targetRect.right, targetRect.bottom);
+
+    // phase 3 - draw the surface to back buffer
     backbuffer->LockRect(&rect, NULL, D3DLOCK_DONOTWAIT);
+    bool use_linear_filter = true;
+    if (cfg::SCREENRESIZE->enable_screen_resize) {
+        use_linear_filter = cfg::SCREENRESIZE->enable_linear_filter;
+    }
     hr = pReal->StretchRect(
         topSurface, &targetRect,
         backbuffer, nullptr,
-        cfg::SCREENRESIZE->enable_linear_filter ? D3DTEXF_LINEAR : D3DTEXF_NONE);
+        use_linear_filter ? D3DTEXF_LINEAR : D3DTEXF_NONE);
     backbuffer->UnlockRect();
     if (hr != D3D_OK) {
-        log_misc("graphics::d3d9", "StretchRect targetRect failed");
+        log_warning(
+            "graphics::d3d9",
+            "SurfaceHook - StretchRect targetRect failed, you must reset image scaling to default values! rect: {} {} {} {}",
+            targetRect.left, targetRect.top, targetRect.right, targetRect.bottom);
     }
 }
 
 HRESULT STDMETHODCALLTYPE WrappedIDirect3DDevice9::EndScene() {
     WRAP_DEBUG;
 
-    if (cfg::SCREENRESIZE->enable_screen_resize) {
+    if (cfg::SCREENRESIZE->enable_screen_resize || GRAPHICS_FS_ORIENTATION_SWAP) {
         SurfaceHook(pReal);
     }
 

src/spice2x/hooks/graphics/graphics.cpp

@@ -68,6 +68,9 @@ bool GRAPHICS_9_ON_12_REQUESTED_BY_GAME = false;
 bool SUBSCREEN_FORCE_REDRAW = false;
 bool D3D9_DEVICE_HOOK_DISABLE = false;
 std::optional<std::pair<uint32_t, uint32_t>> GRAPHICS_FS_CUSTOM_RESOLUTION;
+bool GRAPHICS_FS_ORIENTATION_SWAP = false;
+uint32_t GRAPHICS_FS_ORIGINAL_WIDTH = 0;
+uint32_t GRAPHICS_FS_ORIGINAL_HEIGHT = 0;
 
 // settings
 std::string GRAPHICS_DEVICEID = "PCI\\VEN_1002&DEV_7146";

src/spice2x/hooks/graphics/graphics.h

@@ -36,6 +36,9 @@ extern std::optional<int> GRAPHICS_FORCE_VSYNC_BUFFER;
 extern bool GRAPHICS_FORCE_SINGLE_ADAPTER;
 extern bool GRAPHICS_PREVENT_SECONDARY_WINDOW;
 extern std::optional<std::pair<uint32_t, uint32_t>> GRAPHICS_FS_CUSTOM_RESOLUTION;
+extern bool GRAPHICS_FS_ORIENTATION_SWAP;
+extern uint32_t GRAPHICS_FS_ORIGINAL_WIDTH;
+extern uint32_t GRAPHICS_FS_ORIGINAL_HEIGHT;
 
 extern graphics_dx9on12_state GRAPHICS_9_ON_12_STATE;
 extern bool GRAPHICS_9_ON_12_REQUESTED_BY_GAME;

src/spice2x/launcher/launcher.cpp

@@ -367,15 +367,6 @@ int main_implementation(int argc, char *argv[]) {
         GRAPHICS_FORCE_SINGLE_ADAPTER = false;
     }
 
-    if (options[launcher::Options::FullscreenResolution].is_active()) {
-        std::pair<uint32_t, uint32_t> result;
-        if (parse_width_height(options[launcher::Options::FullscreenResolution].value_text(), result)) {
-            GRAPHICS_FS_CUSTOM_RESOLUTION = result;
-        } else {
-            log_warning("launcher", "failed to parse -forceres");
-        }
-    }
-
     if (options[launcher::Options::spice2x_NvapiProfile].value_bool() && !cfg::CONFIGURATOR_STANDALONE) {
         nvapi::ADD_PROFILE = true;
     }
@@ -448,7 +439,12 @@ int main_implementation(int argc, char *argv[]) {
             games::sdvx::OVERLAY_POS = games::sdvx::SDVX_OVERLAY_TOP;
         } else if (txt == "center") {
             games::sdvx::OVERLAY_POS = games::sdvx::SDVX_OVERLAY_MIDDLE;
+        } else if (txt == "bottomleft") {
+            games::sdvx::OVERLAY_POS = games::sdvx::SDVX_OVERLAY_BOTTOM_LEFT;
+        } else if (txt == "bottomright") {
+            games::sdvx::OVERLAY_POS = games::sdvx::SDVX_OVERLAY_BOTTOM_RIGHT;
         }
+        // else - bottom
     }
     if (options[launcher::Options::spice2x_SDVXSubRedraw].value_bool()) {
         SUBSCREEN_FORCE_REDRAW = true;
@@ -1160,6 +1156,26 @@ int main_implementation(int argc, char *argv[]) {
     }
     log_info("launcher", "arguments:\n{}", arguments.str());
 
+    if (options[launcher::Options::FullscreenResolution].is_active()) {
+        std::pair<uint32_t, uint32_t> result;
+        if (parse_width_height(options[launcher::Options::FullscreenResolution].value_text(), result)) {
+            GRAPHICS_FS_CUSTOM_RESOLUTION = result;
+        } else {
+            log_warning("launcher", "failed to parse -forceres");
+        }
+    }
+
+    if (options[launcher::Options::SDVXFullscreenLandscape].value_bool() && !GRAPHICS_WINDOWED) {
+#if SPICE64
+        GRAPHICS_FS_ORIENTATION_SWAP = true;
+#else
+        log_warning("launcher", "-sdvxlandscape is not supported in 32-bit SDVX, ignoring...");
+#endif
+    }
+    if (options[launcher::Options::FullscreenOrientationFlip].value_bool() && !GRAPHICS_WINDOWED) {
+        GRAPHICS_FS_ORIENTATION_SWAP = true;
+    }
+
     // deleted options
     if (options[launcher::Options::OpenKFControl].value_bool()) {
         log_fatal("launcher", "KFControl has been removed from spice2x; please use an older version.");

src/spice2x/launcher/options.cpp

@@ -19,6 +19,7 @@ static const std::vector<std::string> CATEGORY_ORDER_BASIC = {
     "Network",
     "Overlay",
     "Graphics (Common)",
+    "Graphics (Full Screen)",
     "Graphics (Windowed)",
     "Audio",
 };
@@ -195,7 +196,7 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .desc = "Force the graphics device to be opened utilizing only one adapter in multi-monitor systems.\n\n"
             "May cause unstable framerate and desyncs, especially if monitors have different refresh rates!",
         .type = OptionType::Bool,
-        .category = "Graphics (Common)",
+        .category = "Graphics (Full Screen)",
     },
     {
         .title = "Force Refresh Rate",
@@ -211,10 +212,22 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .desc =
             "For full screen mode, forcibly set a custom resolution.\n\n"
             "Works great for some games, but can COMPLETELY BREAK other games - YMMV!\n\n"
+            "If you are using -sdvxlandscape, put the TARGET monitor resolution in this field.\n\n"
             "This should only be used as last resort if your GPU/monitor can't display the resolution required by the game",
         .type = OptionType::Text,
         .setting_name = "1280,720",
-        .category = "Graphics (Common)"
+        .category = "Graphics (Full Screen)"
+    },
+    {
+        // FullscreenOrientationFlip
+        .title = "Full Screen Orientation Swap",
+        .name = "forceresswap",
+        .desc =
+            "Allows you to play portrait games in in landscape (and vice versa) by transposing resolution and applying image scaling.\n\n"
+            "Works great for some games, but can COMPLETELY BREAK other games - YMMV!\n\n"
+            "Strongly consider combining this with -forceres option to render at monitor native resolution",
+        .type = OptionType::Bool,
+        .category = "Graphics (Full Screen)"
     },
     {
         // Graphics9On12
@@ -745,7 +758,13 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .type = OptionType::Enum,
         .game_name = "Sound Voltex",
         .category = "Overlay",
-        .elements = {{"top", ""}, {"center", ""}, {"bottom", ""}},
+        .elements = {
+            {"top", ""},
+            {"center", ""},
+            {"bottom", ""},
+            {"bottomleft", "for landscape"},
+            {"bottomright", "for landscape"},
+        },
     },
     {
         // spice2x_SDVXSubRedraw
@@ -2025,6 +2044,18 @@ static const std::vector<OptionDefinition> OPTION_DEFINITIONS = {
         .game_name = "Sound Voltex",
         .category = "Game Options",
     },
+    {
+        // SDVXFullscreenLandscape
+        .title = "SDVX Landscape Mode (SDVX5+)",
+        .name = "sdvxlandscape",
+        .desc =
+            "Allows you to play in landscape by transposing resolution and applying image scaling.\n\n"
+            "Works only for SDVX5 and above! This is identical to -forceorientation.\n\n"
+            "Will launch at 1080p by default; strongly consider combining this with -forceres option to render at monitor native resolution",
+        .type = OptionType::Bool,
+        .game_name = "Sound Voltex",
+        .category = "Game Options"
+    },
     {
         // spice2x_EnableSMXStage
         .title = "StepManiaX Stage Lighting Support",

src/spice2x/launcher/options.h

@@ -30,6 +30,7 @@ namespace launcher {
             GraphicsForceSingleAdapter,
             GraphicsForceRefresh,
             FullscreenResolution,
+            FullscreenOrientationFlip,
             Graphics9On12,
             spice2x_Dx9On12,
             NoLegacy,
@@ -222,6 +223,7 @@ namespace launcher {
             spice2x_NoNVAPI,
             spice2x_NoD3D9DeviceHook,
             spice2x_SDVXNoSub,
+            SDVXFullscreenLandscape,
             spice2x_EnableSMXStage,
             spice2x_EnableSMXDedicab,
             IIDXRecQuality,

src/spice2x/overlay/imgui/extensions.cpp

@@ -6,36 +6,61 @@
 
 namespace ImGui {
 
+    const auto fg = ImVec4(0.910f, 0.914f, 0.922f, 1.0f);
+    const auto bg = ImVec4(0.192f, 0.212f, 0.220f, 1.0f);
+
+    void HelpTooltip(const char* desc) {
+        ImGui::PushStyleColor(ImGuiCol_Border, bg);
+        ImGui::PushStyleColor(ImGuiCol_BorderShadow, bg);
+        ImGui::PushStyleColor(ImGuiCol_PopupBg, bg);
+        ImGui::PushStyleColor(ImGuiCol_Text, fg);
+
+        ImGui::BeginTooltip();
+        ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
+        ImGui::TextUnformatted(desc);
+        ImGui::PopTextWrapPos();
+        ImGui::EndTooltip();
+
+        ImGui::PopStyleColor(4);
+    }
+
     void HelpMarker(const char* desc) {
         ImGui::TextDisabled("(?)");
         if (ImGui::IsItemHovered()) {
-            ImGui::BeginTooltip();
-            ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
-            ImGui::TextUnformatted(desc);
-            ImGui::PopTextWrapPos();
-            ImGui::EndTooltip();
+            HelpTooltip(desc);
         }
     }
 
+    void WarnTooltip(const char* desc, const char* warn) {
+        ImGui::PushStyleColor(ImGuiCol_Border, bg);
+        ImGui::PushStyleColor(ImGuiCol_BorderShadow, bg);
+        ImGui::PushStyleColor(ImGuiCol_PopupBg, bg);
+        ImGui::PushStyleColor(ImGuiCol_Text, fg);
+
+        ImGui::BeginTooltip();
+        ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
+        if (desc) {
+            ImGui::TextUnformatted(desc);
+            ImGui::TextUnformatted("");
+        }
+        ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.f, 1.f, 0.f, 1.f));
+        if (warn) {
+            ImGui::TextUnformatted("WARNING:");
+            ImGui::TextUnformatted(warn);
+        }
+        ImGui::PopStyleColor();
+        ImGui::PopTextWrapPos();
+        ImGui::EndTooltip();
+
+        ImGui::PopStyleColor(4);
+    }
+
     void WarnMarker(const char* desc, const char* warn) {
         ImGui::PushStyleColor(ImGuiCol_TextDisabled, ImVec4(1.f, 1.f, 0.f, 1.f));
         ImGui::TextDisabled("(!)");
         ImGui::PopStyleColor();
         if (ImGui::IsItemHovered()) {
-            ImGui::BeginTooltip();
-            ImGui::PushTextWrapPos(ImGui::GetFontSize() * 35.0f);
-            if (desc) {
-                ImGui::TextUnformatted(desc);
-                ImGui::TextUnformatted("");
-            }
-            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.f, 1.f, 0.f, 1.f));
-            if (warn) {
-                ImGui::TextUnformatted("WARNING:");
-                ImGui::TextUnformatted(warn);
-            }
-            ImGui::PopStyleColor();
-            ImGui::PopTextWrapPos();
-            ImGui::EndTooltip();
+            WarnTooltip(desc, warn);
         }
     }
 

src/spice2x/overlay/imgui/extensions.h

@@ -2,7 +2,9 @@
 
 namespace ImGui {
 
+    void HelpTooltip(const char* desc);
     void HelpMarker(const char* desc);
+    void WarnTooltip(const char* desc, const char* warn);
     void WarnMarker(const char* desc, const char* warn);
     void DummyMarker();
     void Knob(float fraction, float size, float thickness = 2.f,

src/spice2x/overlay/windows/config.cpp

@@ -2629,28 +2629,30 @@ namespace overlay::windows {
             // list entry
             ImGui::PushID(&option);
             ImGui::AlignTextToFramePadding();
-            ImGui::HelpMarker(definition.desc.c_str());
-            ImGui::SameLine();
             if (option.is_active()) {
+                // active option
                 if (option.disabled || definition.disabled) {
                     ImGui::TextColored(ImVec4(1.f, 0.4f, 0.f, 1.f), "%s", definition.title.c_str());
                 } else {
-                    ImGui::TextColored(ImVec4(1.f, 0.7f, 0.f, 1.f), "%s", definition.title.c_str());
+                    ImGui::TextColored(ImVec4(0.f, 1.f, 0.f, 1.f), "%s", definition.title.c_str());
                 }
             } else if (definition.hidden
             || (!definition.game_name.empty() && definition.game_name != this->games_selected_name)) {
+                // wrong game - grayed out
                 ImGui::TextColored(ImVec4(0.5f, 0.5f, 0.5f, 1.f), "%s", definition.title.c_str());
-            } else if (definition.game_name == this->games_selected_name) {
-                ImGui::TextColored(ImVec4(0.8f, 0, 0.8f, 1.f), "%s", definition.title.c_str());
             } else {
+                // normal text
                 ImGui::Text("%s", definition.title.c_str());
             }
+            if (ImGui::IsItemHovered()) {
+                ImGui::HelpTooltip(definition.desc.c_str());
+            }
             ImGui::NextColumn();
             ImGui::AlignTextToFramePadding();
             if (definition.display_name.empty()) {
-                ImGui::Text("-%s", definition.name.c_str());
+                ImGui::TextDisabled("-%s", definition.name.c_str());
             } else {
-                ImGui::Text("-%s", definition.display_name.c_str());
+                ImGui::TextDisabled("-%s", definition.display_name.c_str());
             }
             ImGui::NextColumn();
             if (option.disabled || definition.disabled) {
@@ -2665,6 +2667,9 @@ namespace overlay::windows {
                         option.value = state ? "/ENABLED" : "";
                         ::Config::getInstance().updateBinding(games_list[games_selected], option);
                     }
+                    if (ImGui::IsItemHovered()) {
+                        ImGui::HelpTooltip(definition.desc.c_str());
+                    }
                     break;
                 }
                 case OptionType::Integer: {
@@ -2691,6 +2696,9 @@ namespace overlay::windows {
                         option.value = buffer;
                         ::Config::getInstance().updateBinding(games_list[games_selected], option);
                     }
+                    if (ImGui::IsItemHovered()) {
+                        ImGui::HelpTooltip(definition.desc.c_str());
+                    }
                     break;
                 }
                 case OptionType::Hex: {
@@ -2724,6 +2732,9 @@ namespace overlay::windows {
                         option.value = buffer;
                         ::Config::getInstance().updateBinding(games_list[games_selected], option);
                     }
+                    if (ImGui::IsItemHovered()) {
+                        ImGui::HelpTooltip(definition.desc.c_str());
+                    }
                     break;
                 }
                 case OptionType::Text: {
@@ -2741,6 +2752,9 @@ namespace overlay::windows {
                         option.value = buffer;
                         ::Config::getInstance().updateBinding(games_list[games_selected], option);
                     }
+                    if (ImGui::IsItemHovered()) {
+                        ImGui::HelpTooltip(definition.desc.c_str());
+                    }
                     break;
                 }
                 case OptionType::Enum: {
@@ -2771,6 +2785,9 @@ namespace overlay::windows {
                         }
                         ImGui::EndCombo();
                     }
+                    if (ImGui::IsItemHovered()) {
+                        ImGui::HelpTooltip(definition.desc.c_str());
+                    }
                     break;
                 }
                 default: {

src/spice2x/overlay/windows/patch_manager.cpp

@@ -649,17 +649,9 @@ namespace overlay::windows {
 
                     // first column, part 1: help / caution marker
                     ImGui::TableNextColumn();
-                    const std::string description = patch.description;
-                    const std::string caution = patch.caution;
-                    if (!description.empty() && !caution.empty()) {
+                    if (!patch.caution.empty()) {
                         ImGui::AlignTextToFramePadding();
-                        ImGui::WarnMarker(description.c_str(), caution.c_str());
-                    } else if (!description.empty()) {
-                        ImGui::AlignTextToFramePadding();
-                        ImGui::HelpMarker(description.c_str());
-                    } else if (!caution.empty()) {
-                        ImGui::AlignTextToFramePadding();
-                        ImGui::WarnMarker(nullptr, caution.c_str());
+                        ImGui::WarnMarker(nullptr, patch.caution.c_str());
                     } else {
                         ImGui::DummyMarker();
                     }
@@ -705,6 +697,11 @@ namespace overlay::windows {
                     if (style_color_pushed) {
                         ImGui::PopStyleColor(style_color_pushed);
                     }
+                    if (ImGui::IsItemHovered()) {
+                        show_patch_tooltip(patch);
+                    }
+
+                    // show range after label for integer patches
                     if (patch.type == PatchType::Integer) {
                         ImGui::SameLine();
                         auto& numpatch = patch.patch_number;
@@ -741,6 +738,9 @@ namespace overlay::windows {
                         patch.last_status = is_patch_active(patch);
                     }
                     ImGui::EndDisabled();
+                    if (ImGui::IsItemHovered()) {
+                        show_patch_tooltip(patch);
+                    }
 
                     // second column, part 2: additional options UI (dropdown, text input)
                     ImGui::SameLine();
@@ -767,6 +767,9 @@ namespace overlay::windows {
                                     }
                                     ImGui::EndCombo();
                                 }
+                                if (ImGui::IsItemHovered()) {
+                                    show_patch_tooltip(patch);
+                                }
                             } else if (patch.type == PatchType::Integer) {
                                 ImGui::SetNextItemWidth(200.0f);
                                 auto& numpatch = patch.patch_number;
@@ -780,6 +783,9 @@ namespace overlay::windows {
                                     apply_patch(patch, true);
                                     config_dirty = true;
                                 }
+                                if (ImGui::IsItemHovered()) {
+                                    show_patch_tooltip(patch);
+                                }
                             }
                         } else if (patch_status == PatchStatus::Disabled) {
                             ImGui::SetNextItemWidth(200.0f);
@@ -794,6 +800,9 @@ namespace overlay::windows {
                                 ImGui::InputInt("##dummy_int_input", &patch.patch_number.value);
                             }
                             ImGui::EndDisabled();
+                            if (ImGui::IsItemHovered()) {
+                                show_patch_tooltip(patch);
+                            }
                         }
                     } else {
                         ImGui::AlignTextToFramePadding();
@@ -822,6 +831,14 @@ namespace overlay::windows {
         }
     }
 
+    void PatchManager::show_patch_tooltip(const PatchData& patch) {
+        if (!patch.caution.empty()) {
+            ImGui::WarnTooltip(patch.description.c_str(), patch.caution.c_str());
+        } else if (!patch.description.empty()) {
+            ImGui::HelpTooltip(patch.description.c_str());
+        }
+    }
+
     void PatchManager::hard_apply_patches() {
         std::vector<std::string> written_list;
         for (auto& patch : patches) {

src/spice2x/overlay/windows/patch_manager.h

@@ -142,6 +142,7 @@ namespace overlay::windows {
             std::function<bool(const PatchData&)> filter = std::function<bool(const PatchData&)>(),
             std::string pe_identifier_for_patch = "");
 
+        void show_patch_tooltip(const PatchData& patch);
     };
 
     PatchStatus is_patch_active(PatchData &patch);

src/spice2x/overlay/windows/screen_resize.cpp

@@ -51,7 +51,6 @@ namespace overlay::windows {
         for (size_t i = 0; i < std::size(cfg::SCREENRESIZE->scene_settings); i++) {
             auto& scene = cfg::SCREENRESIZE->scene_settings[i];
             scene.keep_aspect_ratio = true;
-            scene.centered = true;
             scene.offset_x = 0;
             scene.offset_y = 0;
             scene.scale_x = 1.f;
@@ -126,21 +125,28 @@ namespace overlay::windows {
         auto& scene = cfg::SCREENRESIZE->scene_settings[cfg::SCREENRESIZE->screen_resize_current_scene];
 
         // general settings
-        ImGui::Checkbox("Centered", &scene.centered);
-        if (!scene.centered) {
-            ImGui::InputInt("X Offset", &scene.offset_x);
-            ImGui::InputInt("Y Offset", &scene.offset_y);
-        }
+        ImGui::InputInt("X Offset", &scene.offset_x);
+        ImGui::SameLine();
+        ImGui::HelpMarker("Hint: ctrl + click on +/- buttons to move quickly.");
+        ImGui::InputInt("Y Offset", &scene.offset_y);
+        ImGui::SameLine();
+        ImGui::HelpMarker("Hint: ctrl + click on +/- buttons to move quickly.");
 
         // aspect ratio
         ImGui::Checkbox("Keep Aspect Ratio", &scene.keep_aspect_ratio);
         if (scene.keep_aspect_ratio) {
-            if (ImGui::SliderFloat("Scale", &scene.scale_x, 0.65f, 2.0f)) {
+            if (ImGui::SliderFloat("Scale", &scene.scale_x, 0.5f, 2.5f)) {
                 scene.scale_y = scene.scale_x;
             }
+            ImGui::SameLine();
+            ImGui::HelpMarker("Hint: ctrl + click on the slider to type in a numeric value.");
         } else {
-            ImGui::SliderFloat("Width Scale", &scene.scale_x, 0.65f, 2.0f);
-            ImGui::SliderFloat("Height Scale", &scene.scale_y, 0.65f, 2.0f);
+            ImGui::SliderFloat("Width Scale", &scene.scale_x, 0.5f, 2.5f);
+            ImGui::SameLine();
+            ImGui::HelpMarker("Hint: ctrl + click on the slider to type in a numeric value.");
+            ImGui::SliderFloat("Height Scale", &scene.scale_y, 0.5f, 2.5f);
+            ImGui::SameLine();
+            ImGui::HelpMarker("Hint: ctrl + click on the slider to type in a numeric value.");
         }
 
         ImGui::EndDisabled();

src/spice2x/overlay/windows/sdvx_sub.cpp

@@ -23,11 +23,35 @@ namespace overlay::windows {
 
         const auto padding = ImGui::GetFrameHeight() / 2;
 
-        this->init_size = ImVec2(ImGui::GetIO().DisplaySize.x - (padding * 2), 0.f);
-        this->init_size.y = (this->init_size.x * 9 / 16) + ImGui::GetFrameHeight();
+        switch (games::sdvx::OVERLAY_POS) {
+            case games::sdvx::SDVX_OVERLAY_BOTTOM_LEFT:
+            case games::sdvx::SDVX_OVERLAY_BOTTOM_RIGHT:
+                this->init_size.x = (ImGui::GetIO().DisplaySize.x - (ImGui::GetIO().DisplaySize.y * 9 / 16)) / 2 - padding;
+                this->init_size.y = (this->init_size.x * 9 / 16) + ImGui::GetFrameHeight();
+                break;
+            case games::sdvx::SDVX_OVERLAY_TOP:
+            case games::sdvx::SDVX_OVERLAY_BOTTOM:
+            case games::sdvx::SDVX_OVERLAY_MIDDLE:
+            default:
+                this->init_size = ImVec2(ImGui::GetIO().DisplaySize.x - (padding * 2), 0.f);
+                this->init_size.y = (this->init_size.x * 9 / 16) + ImGui::GetFrameHeight();
+                if (GRAPHICS_FS_ORIENTATION_SWAP) {
+                    this->init_size.x /= 2;
+                    this->init_size.y /= 2;
+                }
+                break;
+        }
 
         this->init_pos = ImVec2(ImGui::GetIO().DisplaySize.x / 2 - this->init_size.x / 2, 0);
         switch (games::sdvx::OVERLAY_POS) {
+            case games::sdvx::SDVX_OVERLAY_BOTTOM_LEFT:
+                this->init_pos.x = 0;
+                this->init_pos.y = ImGui::GetIO().DisplaySize.y - this->init_size.y;
+                break;
+            case games::sdvx::SDVX_OVERLAY_BOTTOM_RIGHT:
+                this->init_pos.x = ImGui::GetIO().DisplaySize.x - this->init_size.x;
+                this->init_pos.y = ImGui::GetIO().DisplaySize.y - this->init_size.y;
+                break;
             case games::sdvx::SDVX_OVERLAY_TOP:
                 this->init_pos.y = padding;
                 break;