add new resolutions and frame rates

gamercade_console/src/main.rs

@@ -9,7 +9,7 @@ use std::{
 };
 
 use clap::Parser;
-use gamercade_core::Resolution;
+use gamercade_core::{Resolution, ResolutionRatio, ResolutionSize};
 use ggrs::{GgrsError, P2PSession, SessionState};
 use gilrs::Gilrs;
 use pixels::{wgpu::PresentMode, Pixels, PixelsBuilder, SurfaceTexture};
@@ -249,7 +249,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     });
 }
 
-const DEFAULT_WINDOW_RESOLUTION: Resolution = Resolution::High;
+const DEFAULT_WINDOW_RESOLUTION: Resolution = Resolution {
+    size: ResolutionSize::Medium,
+    ratio: ResolutionRatio::Standard,
+};
 
 fn init_window(event_loop: &EventLoop<()>) -> Window {
     let size = LogicalSize::new(

gamercade_core/src/graphics/frame_rate.rs

@@ -1,39 +1,52 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Default, Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 pub enum FrameRate {
-    SuperSlow,
+    UltraSlow,
+    VerySlow,
     Slow,
+    Moderate,
+    #[default]
     Normal,
     Fast,
-    SuperFast,
+    UltraFast,
 }
 
-impl Default for FrameRate {
-    fn default() -> Self {
-        Self::Normal
+impl FrameRate {
+    pub const fn as_str(&self) -> &str {
+        match self {
+            FrameRate::UltraSlow => "Ultra Slow",
+            FrameRate::VerySlow => "Very Slow",
+            FrameRate::Slow => "Slow",
+            FrameRate::Moderate => "Moderate",
+            FrameRate::Normal => "Normal",
+            FrameRate::Fast => "Fast",
+            FrameRate::UltraFast => "Ultra Fast",
+        }
     }
-}
 
-impl FrameRate {
     pub const fn frames_per_second(self) -> usize {
         match self {
-            FrameRate::SuperSlow => 24,
+            FrameRate::UltraSlow => 12,
+            FrameRate::VerySlow => 24,
             FrameRate::Slow => 30,
+            FrameRate::Moderate => 48,
             FrameRate::Normal => 60,
             FrameRate::Fast => 120,
-            FrameRate::SuperFast => 240,
+            FrameRate::UltraFast => 240,
         }
     }
 
     pub const fn default_input_delay(self) -> usize {
         match self {
-            FrameRate::SuperSlow => 0,
+            FrameRate::UltraSlow => 0,
+            FrameRate::VerySlow => 0,
             FrameRate::Slow => 0,
+            FrameRate::Moderate => 1,
             FrameRate::Normal => 1,
             FrameRate::Fast => 2,
-            FrameRate::SuperFast => 3,
+            FrameRate::UltraFast => 3,
         }
     }
 

gamercade_core/src/graphics/resolution.rs

@@ -1,50 +1,106 @@
 use serde::{Deserialize, Serialize};
 
-#[non_exhaustive]
+const fn standard_resolution(size: ResolutionSize) -> (i32, i32) {
+    match size {
+        ResolutionSize::UltraLow => (128, 72),
+        ResolutionSize::VeryLow => (160, 90),
+        ResolutionSize::Low => (320, 180),
+        ResolutionSize::Medium => (480, 270),
+        ResolutionSize::High => (640, 360),
+        ResolutionSize::VeryHigh => (1280, 720),
+        ResolutionSize::UltraHigh => (1920, 1080),
+    }
+}
+
+const fn square_resolution(size: ResolutionSize) -> (i32, i32) {
+    match size {
+        ResolutionSize::UltraLow => (64, 64),
+        ResolutionSize::VeryLow => (128, 128),
+        ResolutionSize::Low => (256, 256),
+        ResolutionSize::Medium => (384, 384),
+        ResolutionSize::High => (512, 512),
+        ResolutionSize::VeryHigh => (768, 768),
+        ResolutionSize::UltraHigh => (1024, 1024),
+    }
+}
+
+const fn classic_resolution(size: ResolutionSize) -> (i32, i32) {
+    match size {
+        ResolutionSize::UltraLow => (120, 90),
+        ResolutionSize::VeryLow => (160, 120),
+        ResolutionSize::Low => (240, 180),
+        ResolutionSize::Medium => (360, 270),
+        ResolutionSize::High => (480, 360),
+        ResolutionSize::VeryHigh => (960, 720),
+        ResolutionSize::UltraHigh => (1440, 1080),
+    }
+}
+
 #[derive(Default, Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
-pub enum Resolution {
-    UltraLow, // 128 x 72
-    VeryLow,  // 160 x 90
+pub enum ResolutionSize {
+    UltraLow,
+    VeryLow,
+    Low,
     #[default]
-    Low, // 320 x 180
-    Medium,   // 480 x 270
-    High,     // 640 x 360
-    VeryHigh, // 1280 x 720
-    UltraHigh, // 1920 x 1080
+    Medium,
+    High,
+    VeryHigh,
+    UltraHigh,
+}
+impl ResolutionSize {
+    pub const fn as_str(&self) -> &str {
+        match self {
+            ResolutionSize::UltraLow => "Ultra Low",
+            ResolutionSize::VeryLow => "Very Low",
+            ResolutionSize::Low => "Low",
+            ResolutionSize::Medium => "Medium",
+            ResolutionSize::High => "High",
+            ResolutionSize::VeryHigh => "Very High",
+            ResolutionSize::UltraHigh => "Ultra High",
+        }
+    }
 }
 
-impl Resolution {
-    // Width, Height
-    pub const ULTRALOW: (i32, i32) = (128, 72);
-    pub const VERYLOW: (i32, i32) = (160, 90);
-    pub const LOW: (i32, i32) = (320, 180);
-    pub const MEDIUM: (i32, i32) = (480, 270);
-    pub const HIGH: (i32, i32) = (640, 360);
-    pub const VERYHIGH: (i32, i32) = (1280, 720);
-    pub const ULTRAHIGH: (i32, i32) = (1920, 1080);
+#[derive(Default, Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ResolutionRatio {
+    #[default]
+    Standard,
+    Square,
+    Classic,
+}
 
-    pub const fn width(&self) -> i32 {
+impl ResolutionRatio {
+    pub const fn as_str(&self) -> &str {
         match self {
-            Self::UltraLow => Self::ULTRALOW.0,
-            Self::VeryLow => Self::VERYLOW.0,
-            Self::Low => Self::LOW.0,
-            Self::Medium => Self::MEDIUM.0,
-            Self::High => Self::HIGH.0,
-            Self::VeryHigh => Self::VERYHIGH.0,
-            Self::UltraHigh => Self::ULTRAHIGH.0,
+            ResolutionRatio::Standard => "Standard (16:9)",
+            ResolutionRatio::Square => "Square (1:1)",
+            ResolutionRatio::Classic => "Classic (4:3)",
         }
     }
+}
+
+#[derive(Default, Clone, Copy, Debug, Serialize, Deserialize)]
+pub struct Resolution {
+    pub size: ResolutionSize,
+    pub ratio: ResolutionRatio,
+}
+
+impl Resolution {
+    pub const fn width(&self) -> i32 {
+        self.ratio_helper().0
+    }
 
     pub const fn height(&self) -> i32 {
-        match self {
-            Self::UltraLow => Self::ULTRALOW.1,
-            Self::VeryLow => Self::VERYLOW.1,
-            Self::Low => Self::LOW.1,
-            Self::Medium => Self::MEDIUM.1,
-            Self::High => Self::HIGH.1,
-            Self::VeryHigh => Self::VERYHIGH.1,
-            Self::UltraHigh => Self::ULTRAHIGH.1,
+        self.ratio_helper().1
+    }
+
+    const fn ratio_helper(&self) -> (i32, i32) {
+        match self.ratio {
+            ResolutionRatio::Standard => standard_resolution(self.size),
+            ResolutionRatio::Square => square_resolution(self.size),
+            ResolutionRatio::Classic => classic_resolution(self.size),
         }
     }
 

gamercade_editor/src/ui/rom_editor.rs

@@ -1,10 +1,7 @@
 use std::fs;
 
 use eframe::egui::{self, Button, Ui};
-use gamercade_core::{
-    FrameRate,
-    Resolution::{High, Low, Medium, UltraHigh, UltraLow, VeryHigh, VeryLow},
-};
+use gamercade_core::{FrameRate, ResolutionRatio, ResolutionSize};
 use gamercade_fs::{DataPack, EditorRom};
 
 #[derive(Debug, Clone, Default)]
@@ -14,18 +11,64 @@ impl RomEditor {
     pub fn draw_contents(&self, ui: &mut Ui, rom: &mut EditorRom) {
         ui.group(|ui| {
             ui.label(format!(
-                "Resolution: {} x {}",
+                "Resolution: {} x {} {}",
                 rom.resolution.width(),
-                rom.resolution.height()
+                rom.resolution.height(),
+                rom.resolution.ratio.as_str(),
             ));
             ui.horizontal(|ui| {
-                ui.selectable_value(&mut rom.resolution, UltraLow, "Ultra Low");
-                ui.selectable_value(&mut rom.resolution, VeryLow, "Very Low");
-                ui.selectable_value(&mut rom.resolution, Low, "Low");
-                ui.selectable_value(&mut rom.resolution, Medium, "Medium");
-                ui.selectable_value(&mut rom.resolution, High, "High");
-                ui.selectable_value(&mut rom.resolution, VeryHigh, "Very High");
-                ui.selectable_value(&mut rom.resolution, UltraHigh, "Ultra High");
+                ui.selectable_value(
+                    &mut rom.resolution.ratio,
+                    ResolutionRatio::Standard,
+                    ResolutionRatio::Standard.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.resolution.ratio,
+                    ResolutionRatio::Square,
+                    ResolutionRatio::Square.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.resolution.ratio,
+                    ResolutionRatio::Classic,
+                    ResolutionRatio::Classic.as_str(),
+                );
+            });
+            ui.horizontal(|ui| {
+                ui.selectable_value(
+                    &mut rom.resolution.size,
+                    ResolutionSize::UltraLow,
+                    ResolutionSize::UltraLow.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.resolution.size,
+                    ResolutionSize::VeryLow,
+                    ResolutionSize::VeryLow.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.resolution.size,
+                    ResolutionSize::Low,
+                    ResolutionSize::Low.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.resolution.size,
+                    ResolutionSize::Medium,
+                    ResolutionSize::Medium.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.resolution.size,
+                    ResolutionSize::High,
+                    ResolutionSize::High.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.resolution.size,
+                    ResolutionSize::VeryHigh,
+                    ResolutionSize::VeryHigh.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.resolution.size,
+                    ResolutionSize::UltraHigh,
+                    ResolutionSize::UltraHigh.as_str(),
+                );
             });
         });
 
@@ -35,11 +78,41 @@ impl RomEditor {
                 rom.frame_rate.frames_per_second()
             ));
             ui.horizontal(|ui| {
-                ui.selectable_value(&mut rom.frame_rate, FrameRate::SuperSlow, "Super Slow");
-                ui.selectable_value(&mut rom.frame_rate, FrameRate::Slow, "Slow");
-                ui.selectable_value(&mut rom.frame_rate, FrameRate::Normal, "Normal");
-                ui.selectable_value(&mut rom.frame_rate, FrameRate::Fast, "Fast");
-                ui.selectable_value(&mut rom.frame_rate, FrameRate::SuperFast, "Super Fast");
+                ui.selectable_value(
+                    &mut rom.frame_rate,
+                    FrameRate::UltraSlow,
+                    FrameRate::UltraSlow.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.frame_rate,
+                    FrameRate::VerySlow,
+                    FrameRate::VerySlow.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.frame_rate,
+                    FrameRate::Slow,
+                    FrameRate::Slow.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.frame_rate,
+                    FrameRate::Moderate,
+                    FrameRate::Moderate.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.frame_rate,
+                    FrameRate::Normal,
+                    FrameRate::Normal.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.frame_rate,
+                    FrameRate::Fast,
+                    FrameRate::Fast.as_str(),
+                );
+                ui.selectable_value(
+                    &mut rom.frame_rate,
+                    FrameRate::UltraFast,
+                    FrameRate::UltraFast.as_str(),
+                );
             });
         });