Add screen scale settings

Author: Grarak

src/main.rs

@@ -505,8 +505,13 @@ pub fn actual_main() {
                     key_map.store(keymap, Ordering::Relaxed);
                     false
                 }
-                PresentEvent::CycleScreenLayout { offset, swap } => {
-                    screen_layout = screen_layout.apply_settings_event(offset, swap);
+                PresentEvent::CycleScreenLayout {
+                    offset,
+                    swap,
+                    top_screen_scale_offset,
+                    bottom_screen_scale_offset,
+                } => {
+                    screen_layout = screen_layout.apply_settings_event(offset, swap, top_screen_scale_offset, bottom_screen_scale_offset);
                     false
                 }
                 PresentEvent::Pause => true,

src/presenter/mod.rs

@@ -18,8 +18,16 @@ pub const PRESENTER_SCREEN_WIDTH: u32 = 960;
 pub const PRESENTER_SCREEN_HEIGHT: u32 = 544;
 
 pub enum PresentEvent {
-    Inputs { keymap: u32, touch: Option<(i16, i16)> },
-    CycleScreenLayout { offset: i8, swap: bool },
+    Inputs {
+        keymap: u32,
+        touch: Option<(i16, i16)>,
+    },
+    CycleScreenLayout {
+        offset: i8,
+        swap: bool,
+        top_screen_scale_offset: i8,
+        bottom_screen_scale_offset: i8,
+    },
     Pause,
     Quit,
 }

src/presenter/vita.rs

@@ -141,10 +141,52 @@ impl Presenter {
             self.pressed_btn = pressed.buttons;
 
             if pressed.buttons & SCE_CTRL_PSBUTTON != 0 {
-                const SHORTCUT_EVENTS: [(PresentEvent, SceCtrlButtons); 3] = [
-                    (PresentEvent::CycleScreenLayout { offset: -1, swap: false }, SCE_CTRL_LTRIGGER),
-                    (PresentEvent::CycleScreenLayout { offset: 1, swap: false }, SCE_CTRL_RTRIGGER),
-                    (PresentEvent::CycleScreenLayout { offset: 0, swap: true }, SCE_CTRL_CROSS),
+                const SHORTCUT_EVENTS: [(PresentEvent, SceCtrlButtons); 5] = [
+                    (
+                        PresentEvent::CycleScreenLayout {
+                            offset: -1,
+                            swap: false,
+                            top_screen_scale_offset: 0,
+                            bottom_screen_scale_offset: 0,
+                        },
+                        SCE_CTRL_LTRIGGER,
+                    ),
+                    (
+                        PresentEvent::CycleScreenLayout {
+                            offset: 1,
+                            swap: false,
+                            top_screen_scale_offset: 0,
+                            bottom_screen_scale_offset: 0,
+                        },
+                        SCE_CTRL_RTRIGGER,
+                    ),
+                    (
+                        PresentEvent::CycleScreenLayout {
+                            offset: 0,
+                            swap: true,
+                            top_screen_scale_offset: 0,
+                            bottom_screen_scale_offset: 0,
+                        },
+                        SCE_CTRL_CROSS,
+                    ),
+                    (
+                        PresentEvent::CycleScreenLayout {
+                            offset: 0,
+                            swap: false,
+                            top_screen_scale_offset: 0,
+                            bottom_screen_scale_offset: 1,
+                        },
+                        SCE_CTRL_CIRCLE,
+                    ),
+                    (
+                        PresentEvent::CycleScreenLayout {
+                            offset: 0,
+                            swap: false,
+                            top_screen_scale_offset: 1,
+                            bottom_screen_scale_offset: 0,
+                        },
+                        SCE_CTRL_SQUARE,
+                    ),
                 ];
 
                 for (event, button) in SHORTCUT_EVENTS {

src/screen_layouts.rs

@@ -4,30 +4,59 @@ use crate::presenter::{PRESENTER_SCREEN_HEIGHT, PRESENTER_SCREEN_WIDTH};
 use crate::settings::SettingValue;
 use screenlayouts::SCREEN_LAYOUTS;
 
+const SCALE_FACTORS: [f32; 8] = [0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0];
+
 pub struct ScreenLayout {
     pub index: usize,
     pub swap: bool,
+    top_scale_index: usize,
+    bottom_scale_index: usize,
     overlap: bool,
     screen_top: [f32; 16],
     screen_bottom: [f32; 16],
+    bottom_inverse_mtx: [f32; 9],
 }
 
 impl ScreenLayout {
     pub fn settings_value() -> SettingValue {
         SettingValue::List(0, SCREEN_LAYOUTS.iter().map(|(name, _)| name.to_string()).collect())
     }
 
-    pub fn new(index: usize, swap: bool) -> Self {
+    pub fn scale_settings_value() -> SettingValue {
+        SettingValue::List(3, SCALE_FACTORS.iter().map(|factor| format!("{}%", (factor * 100.0) as u8)).collect())
+    }
+
+    fn scale_matrix(factor: f32) -> [f32; 9] {
+        [factor, 0.0, 0.0, 0.0, factor, 0.0, 0.0, 0.0, 1.0]
+    }
+
+    pub fn new(index: usize, swap: bool, top_scale_index: usize, bottom_scale_index: usize) -> Self {
         const GUEST_DISPLAY_DIM_MTX: [[f32; 3]; 4] = [
             [-(DISPLAY_WIDTH as f32 / 2.0), -(DISPLAY_HEIGHT as f32 / 2.0), 1.0],
             [DISPLAY_WIDTH as f32 / 2.0, -(DISPLAY_HEIGHT as f32 / 2.0), 1.0],
             [DISPLAY_WIDTH as f32 / 2.0, DISPLAY_HEIGHT as f32 / 2.0, 1.0],
             [-(DISPLAY_WIDTH as f32 / 2.0), DISPLAY_HEIGHT as f32 / 2.0, 1.0],
         ];
-        let a_mtx = &SCREEN_LAYOUTS[index].1[0];
-        let b_mtx = &SCREEN_LAYOUTS[index].1[1];
+        let mut a_mtx = SCREEN_LAYOUTS[index].1[0];
+        let mut b_mtx = SCREEN_LAYOUTS[index].1[1];
+
+        let top_scale_mtx = Self::scale_matrix(SCALE_FACTORS[top_scale_index]);
+        let bottom_scale_mtx = Self::scale_matrix(SCALE_FACTORS[bottom_scale_index]);
+
+        unsafe {
+            math::neon::matmul3_neon(a_mtx.as_ptr() as _, top_scale_mtx.as_ptr() as _, a_mtx.as_mut_ptr());
+            math::neon::matmul3_neon(b_mtx.as_ptr() as _, bottom_scale_mtx.as_ptr() as _, b_mtx.as_mut_ptr());
+        }
+
         let mut screen_top = [[0.0; 3]; 4];
         let mut screen_bottom = [[0.0; 3]; 4];
+        let mut bottom_inverse_mtx = SCREEN_LAYOUTS[index].1[if swap { 2 } else { 3 }];
+
+        unsafe {
+            let inverse_scale_mtx = Self::scale_matrix(1.0 / SCALE_FACTORS[if swap { top_scale_index } else { bottom_scale_index }]);
+            math::neon::matmul3_neon(inverse_scale_mtx.as_ptr() as _, bottom_inverse_mtx.as_ptr() as _, bottom_inverse_mtx.as_mut_ptr());
+        }
+
         let overlap = unsafe {
             for i in 0..GUEST_DISPLAY_DIM_MTX.len() {
                 math::neon::matvec3_neon(a_mtx.as_ptr() as _, GUEST_DISPLAY_DIM_MTX[i].as_ptr() as _, screen_top[i].as_mut_ptr());
@@ -52,9 +81,12 @@ impl ScreenLayout {
 
             overlap
         };
+
         ScreenLayout {
             index,
             swap,
+            top_scale_index,
+            bottom_scale_index,
             overlap,
             screen_top: [
                 screen_top[0][0],
@@ -92,23 +124,22 @@ impl ScreenLayout {
                 0.0,
                 0.0,
             ],
+            bottom_inverse_mtx,
         }
     }
 
-    pub fn apply_settings_event(&self, offset: i8, swap: bool) -> ScreenLayout {
+    pub fn apply_settings_event(&self, offset: i8, swap: bool, top_screen_scale_offset: i8, bottom_screen_scale_offset: i8) -> ScreenLayout {
         ScreenLayout::new(
             ((SCREEN_LAYOUTS.len() as isize + (self.index as isize + offset as isize)) % SCREEN_LAYOUTS.len() as isize) as usize,
             self.swap ^ swap,
+            ((SCALE_FACTORS.len() as isize + (self.top_scale_index as isize + top_screen_scale_offset as isize)) % SCALE_FACTORS.len() as isize) as usize,
+            ((SCALE_FACTORS.len() as isize + (self.bottom_scale_index as isize + bottom_screen_scale_offset as isize)) % SCALE_FACTORS.len() as isize) as usize,
         )
     }
 
-    pub fn get_bottom_inverse_mtx(&self) -> &[f32; 9] {
-        &SCREEN_LAYOUTS[self.index].1[if self.swap { 2 } else { 3 }]
-    }
-
     pub fn normalize_touch_points(&self, x: i16, y: i16) -> (i16, i16) {
         let mut touch_points = [x as f32, y as f32, 1.0];
-        unsafe { math::neon::matvec3_neon(self.get_bottom_inverse_mtx().as_ptr() as _, touch_points.as_ptr() as _, touch_points.as_mut_ptr() as _) };
+        unsafe { math::neon::matvec3_neon(self.bottom_inverse_mtx.as_ptr() as _, touch_points.as_ptr() as _, touch_points.as_mut_ptr() as _) };
         (touch_points[0] as i16 + DISPLAY_WIDTH as i16 / 2, touch_points[1] as i16 + DISPLAY_HEIGHT as i16 / 2)
     }
 

src/settings.rs

@@ -159,7 +159,9 @@ lazy_static! {
     pub static ref DEFAULT_SETTINGS: Settings = Settings(
         [
             Setting::new("Screen Layout", "Press PS + L Trigger or PS + R Trigger to cycle through layouts in game.", ScreenLayout::settings_value(), true),
-            Setting::new("Swap screens", "Press PS + X to swap screens in game.", SettingValue::Bool(false), true),
+            Setting::new("Swap screens", "Press PS + Cross to swap screens in game.", SettingValue::Bool(false), true),
+            Setting::new("Top screen scale", "Press PS + Square to cycle screen sizes.", ScreenLayout::scale_settings_value(), true),
+            Setting::new("Bottom screen scale", "Press PS + Circle to cycle screen sizes", ScreenLayout::scale_settings_value(), true),
             Setting::new("Language", "Some ROMs only come with one language. Make sure yours is multilingual.", Language::iter().into(), false),
             Setting::new("Joystick as D-Pad", "", SettingValue::Bool(true), true),
             Setting::new("Framelimit", "Limits gamespeed to 60fps", SettingValue::Bool(true), true),
@@ -181,23 +183,27 @@ lazy_static! {
 }
 
 #[derive(Clone)]
-pub struct Settings([Setting; 8]);
+pub struct Settings([Setting; 10]);
 
 const SCREEN_LAYOUT_SETTING: usize = 0;
 const SWAP_SCREEN_SETTING: usize = 1;
-const LANGUAGE_SETTING: usize = 2;
-const JOYSTICK_AS_DPAD_SETTING: usize = 3;
-const FRAMELIMIT_SETTING: usize = 4;
-const AUDIO_SETTING: usize = 5;
-const ARM7_EMU_SETTING: usize = 6;
-const ARM7_BLOCK_VALIDATION_SETTING: usize = 7;
+const TOP_SCREEN_SCALE_SETTING: usize = 2;
+const BOTTOM_SCREEN_SCALE_SETTING: usize = 3;
+const LANGUAGE_SETTING: usize = 4;
+const JOYSTICK_AS_DPAD_SETTING: usize = 5;
+const FRAMELIMIT_SETTING: usize = 6;
+const AUDIO_SETTING: usize = 7;
+const ARM7_EMU_SETTING: usize = 8;
+const ARM7_BLOCK_VALIDATION_SETTING: usize = 9;
 
 impl Settings {
     pub fn screen_layout(&self) -> ScreenLayout {
         unsafe {
             ScreenLayout::new(
                 self.0[SCREEN_LAYOUT_SETTING].value.as_list().unwrap_unchecked().0,
                 self.0[SWAP_SCREEN_SETTING].value.as_bool().unwrap_unchecked(),
+                self.0[TOP_SCREEN_SCALE_SETTING].value.as_list().unwrap_unchecked().0,
+                self.0[BOTTOM_SCREEN_SCALE_SETTING].value.as_list().unwrap_unchecked().0,
             )
         }
     }
@@ -247,7 +253,7 @@ impl Settings {
         *self.0[ARM7_BLOCK_VALIDATION_SETTING].value.as_bool_mut().unwrap() = value;
     }
 
-    pub fn get_all_mut(&mut self) -> &mut [Setting; 8] {
+    pub fn get_all_mut(&mut self) -> &mut [Setting; 10] {
         &mut self.0
     }
 }