Fixup vsync

src/application.rs

@@ -63,6 +63,7 @@ impl NeovideApplication {
                 format_and_log_error_message(err),
                 event_loop,
                 self.settings.clone(),
+                self.proxy.clone(),
             );
             self.current_window = Some(UpdateLoop::new(
                 Box::new(window),

src/renderer/d3d.rs

@@ -106,12 +106,12 @@ pub struct D3DSkiaRenderer {
     _target: IDCompositionTarget,
     _visual: IDCompositionVisual,
     window: Window,
-
     settings: Arc<Settings>,
+    vsync: VSync,
 }
 
 impl D3DSkiaRenderer {
-    pub fn new(window: Window, settings: Arc<Settings>) -> Self {
+    pub fn new(window: Window, settings: Arc<Settings>, proxy: EventLoopProxy<UserEvent>) -> Self {
         tracy_zone!("D3DSkiaRenderer::new");
         #[cfg(feature = "d3d_debug")]
         let dxgi_factory: IDXGIFactory2 = unsafe {
@@ -256,6 +256,8 @@ impl D3DSkiaRenderer {
             DirectContext::new_d3d(&backend_context, None).expect("Failed to create Skia context")
         };
 
+        let vsync = VSync::WindowsSwapChain(VSyncWinSwapChain::new(proxy, swap_chain_waitable));
+
         let mut ret = Self {
             _adapter: adapter,
             #[cfg(feature = "gpu_profiling")]
@@ -277,8 +279,8 @@ impl D3DSkiaRenderer {
             _target: target,
             _visual: visual,
             window,
-
             settings,
+            vsync,
         };
         ret.setup_surfaces();
 
@@ -451,8 +453,22 @@ impl SkiaRenderer for D3DSkiaRenderer {
         self.setup_surfaces();
     }
 
-    fn create_vsync(&self, proxy: EventLoopProxy<UserEvent>) -> VSync {
-        VSync::WindowsSwapChain(VSyncWinSwapChain::new(proxy, self.swap_chain_waitable))
+    fn refresh_interval(&self) -> f32 {
+        self.vsync.get_refresh_rate(self.window(), &self.settings)
+    }
+
+    fn request_redraw(&mut self) -> bool {
+        let window = self.window.as_ref().unwrap();
+        self.vsync.request_redraw(window)
+    }
+
+    fn update_vsync(&mut self) {
+        let window = self.window.as_ref().unwrap();
+        self.vsync.update(window);
+    }
+
+    fn wait_for_vsync(&mut self) {
+        self.vsync.wait_for_vsync();
     }
 
     #[cfg(feature = "gpu_profiling")]

src/renderer/metal.rs

@@ -83,6 +83,7 @@ pub struct MetalSkiaRenderer {
     context: DirectContext,
     metal_drawable_surface: Option<MetalDrawableSurface>,
     settings: Arc<Settings>,
+    vsync: VSync,
 }
 
 impl MetalSkiaRenderer {
@@ -135,6 +136,8 @@ impl MetalSkiaRenderer {
 
         let context = gpu::direct_contexts::make_metal(&backend, None).unwrap();
 
+        let vsync = VSync::MacosMetal();
+
         MetalSkiaRenderer {
             window,
             _device: device,
@@ -144,6 +147,7 @@ impl MetalSkiaRenderer {
             context,
             metal_drawable_surface: None,
             settings,
+            vsync,
         }
     }
 
@@ -219,7 +223,21 @@ impl SkiaRenderer for MetalSkiaRenderer {
         self.window.request_redraw();
     }
 
-    fn create_vsync(&self, _proxy: EventLoopProxy<UserEvent>) -> VSync {
-        VSync::MacosMetal()
+    fn refresh_interval(&self) -> f32 {
+        self.vsync.get_refresh_rate(self.window(), &self.settings)
+    }
+
+    fn request_redraw(&mut self) -> bool {
+        let window = self.window.as_ref().unwrap();
+        self.vsync.request_redraw(window)
+    }
+
+    fn update_vsync(&mut self) {
+        let window = self.window.as_ref().unwrap();
+        self.vsync.update(window);
+    }
+
+    fn wait_for_vsync(&mut self) {
+        self.vsync.wait_for_vsync();
     }
 }

src/renderer/mod.rs

@@ -27,7 +27,7 @@ use skia_safe::Canvas;
 
 use winit::{
     event::WindowEvent,
-    event_loop::ActiveEventLoop,
+    event_loop::{ActiveEventLoop, EventLoopProxy},
     window::{Window, WindowAttributes},
 };
 
@@ -39,7 +39,7 @@ use crate::{
     renderer::rendered_layer::{group_windows, FloatingLayer},
     settings::*,
     units::{to_skia_rect, GridRect, GridSize, PixelPos},
-    window::ShouldRender,
+    window::{ShouldRender, UserEvent},
     WindowSettings,
 };
 
@@ -576,6 +576,7 @@ pub fn create_skia_renderer(
     srgb: bool,
     vsync: bool,
     settings: Arc<Settings>,
+    #[allow(unused)] proxy: EventLoopProxy<UserEvent>,
 ) -> Box<dyn SkiaRenderer> {
     let renderer: Box<dyn SkiaRenderer> = match &window.config {
         WindowConfigType::OpenGL(..) => Box::new(opengl::OpenGLSkiaRenderer::new(
@@ -585,9 +586,10 @@ pub fn create_skia_renderer(
             settings.clone(),
         )),
         #[cfg(target_os = "windows")]
-        WindowConfigType::Direct3D => {
-            Box::new(d3d::D3DSkiaRenderer::new(window.window, settings.clone()))
-        }
+        WindowConfigType::Direct3D => Box::new(
+            d3d::D3DSkiaRenderer::new(window.window, settings.clone()),
+            proxy,
+        ),
         #[cfg(target_os = "macos")]
         WindowConfigType::Metal => Box::new(metal::MetalSkiaRenderer::new(
             window.window,

src/renderer/opengl.rs

@@ -228,12 +228,7 @@ impl SkiaRenderer for OpenGLSkiaRenderer {
 
     fn request_redraw(&mut self) -> bool {
         let window = self.window.as_ref().unwrap();
-        if self.vsync.uses_winit_throttling() {
-            self.vsync.request_redraw(window);
-            true
-        } else {
-            false
-        }
+        self.vsync.request_redraw(window)
     }
 
     fn update_vsync(&mut self) {

src/renderer/vsync/mod.rs

@@ -87,7 +87,7 @@ impl VSync {
         }
     }
 
-    pub fn request_redraw(&mut self, window: &Window) {
+    pub fn request_redraw(&mut self, window: &Window) -> bool {
         match self {
             VSync::WinitThrottling(..) => window.request_redraw(),
             #[cfg(target_os = "windows")]
@@ -97,6 +97,7 @@ impl VSync {
             #[cfg(target_os = "macos")]
             VSync::MacosDisplayLink(vsync) => vsync.request_redraw(),
             _ => {}
-        }
+        };
+        self.uses_winit_throttling()
     }
 }

src/window/error_window.rs

@@ -71,7 +71,12 @@ pub struct ErrorWindow {
 }
 
 impl ErrorWindow {
-    pub fn new(message: String, event_loop: &ActiveEventLoop, settings: Arc<Settings>) -> Self {
+    pub fn new(
+        message: String,
+        event_loop: &ActiveEventLoop,
+        settings: Arc<Settings>,
+        proxy: EventLoopProxy<UserEvent>,
+    ) -> Self {
         let message = message.trim_end().to_string();
 
         let font_manager = FontMgr::new();
@@ -81,7 +86,7 @@ impl ErrorWindow {
         let srgb = SRGB_DEFAULT == "1";
         let vsync = true;
         let window = create_window(event_loop, &settings);
-        let skia_renderer = create_skia_renderer(window, srgb, vsync, settings);
+        let skia_renderer = create_skia_renderer(window, srgb, vsync, settings, proxy);
         skia_renderer.window().set_visible(true);
         let scale_factor = skia_renderer.window().scale_factor();
         let size = skia_renderer.window().inner_size();

src/window/neovim_window.rs

@@ -121,7 +121,7 @@ impl NeovimWindow {
             },
         };
 
-        runtime.launch(proxy, grid_size, settings.clone());
+        runtime.launch(proxy.clone(), grid_size, settings.clone());
 
         let saved_inner_size = Default::default();
         let renderer = Renderer::new(1.0, initial_config, settings.clone());
@@ -485,7 +485,7 @@ impl NeovimWindow {
     fn try_create_window_impl(
         &mut self,
         event_loop: &ActiveEventLoop,
-        _proxy: &EventLoopProxy<UserEvent>,
+        proxy: &EventLoopProxy<UserEvent>,
     ) {
         if self.ui_state != UIState::WaitingForWindowCreate {
             return;
@@ -587,8 +587,13 @@ impl NeovimWindow {
         let cmd_line_settings = self.settings.get::<CmdLineSettings>();
         let srgb = cmd_line_settings.srgb;
         let vsync_enabled = cmd_line_settings.vsync;
-        let skia_renderer =
-            create_skia_renderer(window_config, srgb, vsync_enabled, self.settings.clone());
+        let skia_renderer = create_skia_renderer(
+            window_config,
+            srgb,
+            vsync_enabled,
+            self.settings.clone(),
+            proxy.clone(),
+        );
         let window = skia_renderer.window();
 
         self.saved_inner_size = window.inner_size();