Save power by freezing renders after inactivity (10s)

RobinMcCorkell · RobinMcCorkell · commit 2d92f36cd1c5 · 2023-03-12T10:36:19.000Z
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "shaderlock"
 description = "Wayland (wlroots) screenlocker with GPU shaders"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Robin McCorkell <robin@mccorkell.me.uk>"]
 license = "MIT"
 edition = "2018"
diff --git a/dist/shaders/blur.frag b/dist/shaders/blur.frag
@@ -10,6 +10,7 @@ layout(set = 0, binding = 2) uniform Uniforms {
 
 layout(push_constant) uniform FrameUniforms {
     float iTime;
+    float iFadeAmount;
 };
 
 const float AMOUNT = 4.0;
@@ -23,4 +24,5 @@ void main() {
     vec2 uv = ouv.xy / ouv.w;
 
     f_color = texture(sampler2D(t_screenshot, s_screenshot), uv, lod_bias);
+    f_color = mix(f_color, vec4(0.0, 0.0, 0.0, 1.0), iFadeAmount);
 }
diff --git a/dist/shaders/crt.frag b/dist/shaders/crt.frag
@@ -10,6 +10,7 @@ layout(set = 0, binding = 2) uniform Uniforms {
 
 layout(push_constant) uniform FrameUniforms {
     float iTime;
+    float iFadeAmount;
 };
 
 const float BULGE_AMOUNT = 0.2;
@@ -91,4 +92,5 @@ void main() {
     c = scan_lines(c, uv_monitor);
 
     f_color = c;
+    f_color = mix(f_color, vec4(0.0, 0.0, 0.0, 1.0), iFadeAmount);
 }
diff --git a/dist/shaders/desaturate_fade.frag b/dist/shaders/desaturate_fade.frag
@@ -10,6 +10,7 @@ layout(set = 0, binding = 2) uniform Uniforms {
 
 layout(push_constant) uniform FrameUniforms {
     float iTime;
+    float iFadeAmount;
 };
 
 const vec3 LUMIN = vec3(0.299, 0.587, 0.114);
@@ -35,4 +36,5 @@ void main() {
 
     vec4 desaturated = desaturate(texture(sampler2D(t_screenshot, s_screenshot), uv), desaturation);
     f_color = mix(desaturated, CLEAR_COLOR, fade);
+    f_color = mix(f_color, vec4(0.0, 0.0, 0.0, 1.0), iFadeAmount);
 }
diff --git a/dist/shaders/dissolve.frag b/dist/shaders/dissolve.frag
@@ -10,10 +10,11 @@ layout(set = 0, binding = 2) uniform Uniforms {
 
 layout(push_constant) uniform FrameUniforms {
     float iTime;
+    float iFadeAmount;
 };
 
 const float DISSOLVE_SPEED = 200;
-const float FALL_ACCEL = 400.0;
+const float FALL_ACCEL = 800.0;
 const float RANDOM_AMOUNT = 0.15;
 const float RANDOM_SIZE = 60.0;
 
@@ -89,4 +90,5 @@ void main() {
     } else {
         f_color = texture(sampler2D(t_screenshot, s_screenshot), uv);
     }
+    f_color = mix(f_color, vec4(0.0, 0.0, 0.0, 1.0), iFadeAmount);
 }
diff --git a/dist/shaders/overlay.frag b/dist/shaders/overlay.frag
@@ -10,6 +10,7 @@ layout(set = 0, binding = 2) uniform Uniforms {
 
 layout(push_constant) uniform FrameUniforms {
     float iTime;
+    float iFadeAmount;
 };
 
 const float PI = 3.141529;
@@ -33,4 +34,5 @@ void main() {
     vec2 uv = ouv.xy / ouv.w;
 
     f_color = overlay(uv, amount);
+    f_color = mix(f_color, vec4(0.0, 0.0, 0.0, 1.0), iFadeAmount);
 }
diff --git a/dist/shaders/paper_burn.frag b/dist/shaders/paper_burn.frag
@@ -10,6 +10,7 @@ layout(set = 0, binding = 2) uniform Uniforms {
 
 layout(push_constant) uniform FrameUniforms {
     float iTime;
+    float iFadeAmount;
 };
 
 const float NOISE_FREQ = 12.0;
@@ -76,4 +77,5 @@ void main() {
     f_color = mix(f_color, SCORCH_COLOR, scorch*SCORCH_MAX);
     f_color = mix(f_color, BURN_COLOR, burn*BURN_MAX);
     f_color = mix(f_color, vec4(0.0, 0.0, 0.0, 0.0), alpha);
+    f_color = mix(f_color, vec4(0.0, 0.0, 0.0, 1.0), iFadeAmount);
 }
diff --git a/dist/shaders/vertical_band_slide.frag b/dist/shaders/vertical_band_slide.frag
@@ -10,6 +10,7 @@ layout(set = 0, binding = 2) uniform Uniforms {
 
 layout(push_constant) uniform FrameUniforms {
     float iTime;
+    float iFadeAmount;
 };
 
 const vec4 CLEAR_COLOR = vec4(0.0, 0.0, 0.0, 1.0);
@@ -42,4 +43,5 @@ void main() {
     } else {
         f_color = texture(sampler2D(t_screenshot, s_screenshot), uv);
     }
+    f_color = mix(f_color, vec4(0.0, 0.0, 0.0, 1.0), iFadeAmount);
 }
diff --git a/src/graphics.rs b/src/graphics.rs
@@ -1,6 +1,8 @@
 mod bg;
 mod icon;
 
+use std::time::Duration;
+
 use anyhow::*;
 #[allow(unused_imports)]
 use log::{debug, error, info, warn};
@@ -49,7 +51,7 @@ impl Manager {
         let adapter = self
             .instance
             .request_adapter(&wgpu::RequestAdapterOptions {
-                power_preference: wgpu::PowerPreference::Default,
+                power_preference: wgpu::PowerPreference::LowPower,
                 compatible_surface: Some(&surface),
             })
             .await
@@ -60,7 +62,7 @@ impl Manager {
                 &wgpu::DeviceDescriptor {
                     features: wgpu::Features::PUSH_CONSTANTS,
                     limits: wgpu::Limits {
-                        max_push_constant_size: 4,
+                        max_push_constant_size: self::bg::PUSH_CONSTANTS_SIZE,
                         ..wgpu::Limits::default()
                     },
                     shader_validation: true,
@@ -132,7 +134,7 @@ impl State {
         self.icon.resize(&self.queue, resolution_transform);
     }
 
-    pub fn render(&mut self, time: f32) {
+    pub fn render(&mut self, ctx: RenderContext) {
         let frame = self
             .swap_chain
             .get_current_frame()
@@ -145,10 +147,15 @@ impl State {
                 label: Some("Render Encoder"),
             });
 
-        self.bg.render(&mut encoder, &frame, time);
+        self.bg.render(&mut encoder, &frame, ctx);
         self.icon.render(&mut encoder, &frame);
 
         // submit will accept anything that implements IntoIter
         self.queue.submit(std::iter::once(encoder.finish()));
     }
 }
+
+pub struct RenderContext {
+    pub elapsed: Duration,
+    pub fade_amount: f32,
+}
diff --git a/src/graphics/bg.rs b/src/graphics/bg.rs
@@ -4,6 +4,8 @@ use log::{debug, error, info, warn};
 
 use wgpu::util::DeviceExt;
 
+use super::RenderContext;
+
 pub const VS_MAIN: &str = "main";
 pub const FS_MAIN: &str = "main";
 
@@ -26,11 +28,23 @@ struct UniformsHandle {
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 struct FrameUniforms {
-    time: f32,
+    elapsed: f32,
+    fade_amount: f32,
 }
 unsafe impl bytemuck::Pod for FrameUniforms {}
 unsafe impl bytemuck::Zeroable for FrameUniforms {}
 
+impl From<RenderContext> for FrameUniforms {
+    fn from(ctx: RenderContext) -> Self {
+        Self {
+            elapsed: ctx.elapsed.as_secs_f32(),
+            fade_amount: ctx.fade_amount,
+        }
+    }
+}
+
+pub const PUSH_CONSTANTS_SIZE: u32 = std::mem::size_of::<FrameUniforms>() as u32;
+
 pub struct State {
     pipeline: wgpu::RenderPipeline,
     bind_group: wgpu::BindGroup,
@@ -81,7 +95,7 @@ impl State {
             bind_group_layouts: &[&bind_group_layout],
             push_constant_ranges: &[wgpu::PushConstantRange {
                 stages: wgpu::ShaderStage::FRAGMENT,
-                range: 0..4,
+                range: 0..PUSH_CONSTANTS_SIZE,
             }],
         });
 
@@ -232,7 +246,7 @@ impl State {
         &mut self,
         encoder: &mut wgpu::CommandEncoder,
         frame: &wgpu::SwapChainTexture,
-        time: f32,
+        ctx: RenderContext,
     ) {
         let mut rp = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
             color_attachments: &[wgpu::RenderPassColorAttachmentDescriptor {
@@ -255,7 +269,7 @@ impl State {
         rp.set_push_constants(
             wgpu::ShaderStage::FRAGMENT,
             0,
-            bytemuck::cast_slice(&[FrameUniforms { time }]),
+            bytemuck::cast_slice(&[FrameUniforms::from(ctx)]),
         );
         rp.draw(0..4, 0..1);
     }
diff --git a/src/main.rs b/src/main.rs
@@ -1,5 +1,6 @@
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
+#![feature(tuple_trait)]
 
 mod graphics;
 mod locker;
@@ -62,10 +63,9 @@ async fn main() -> Result<()> {
     let icon_file = std::path::PathBuf::from(args.icon_file);
 
     use winit::platform::unix::{EventLoopBuilderExtUnix, EventLoopWindowTargetExtUnix};
-    let event_loop =
-        winit::event_loop::EventLoopBuilder::new()
-            .with_wayland()
-            .build();
+    let event_loop = winit::event_loop::EventLoopBuilder::new()
+        .with_wayland()
+        .build();
     let display = unsafe {
         wl::Display::from_external_display(event_loop.wayland_display().unwrap() as *mut _)
     };
diff --git a/src/monitor.rs b/src/monitor.rs
@@ -9,8 +9,12 @@ use winit::event_loop::EventLoop;
 use winit::monitor::*;
 use winit::window::*;
 
+use crate::graphics::RenderContext;
 use crate::screengrab::Screengrabber;
 
+const FREEZE_AFTER_INACTIVITY: std::time::Duration = std::time::Duration::from_secs(10);
+const FADE_BEFORE_FREEZE: std::time::Duration = std::time::Duration::from_secs(5);
+
 pub struct State {
     window: Window,
     graphics: crate::graphics::State,
@@ -21,6 +25,8 @@ pub struct Manager {
     graphics: crate::graphics::Manager,
     state: HashMap<WindowId, State>,
     init_time: std::time::Instant,
+    last_keypress_time: std::time::Instant,
+    frozen: bool,
 }
 
 impl Manager {
@@ -30,6 +36,8 @@ impl Manager {
             graphics,
             state: HashMap::new(),
             init_time: std::time::Instant::now(),
+            last_keypress_time: std::time::Instant::now(),
+            frozen: false,
         }
     }
 
@@ -96,6 +104,10 @@ impl Manager {
                     // new_inner_size is &&mut so we have to dereference it twice
                     graphics.resize(**new_inner_size);
                 }
+                WindowEvent::KeyboardInput { .. } => {
+                    self.last_keypress_time = std::time::Instant::now();
+                    self.frozen = false;
+                }
                 _ => {}
             },
             Event::RedrawRequested(window_id) if self.state.contains_key(&window_id) => {
@@ -105,12 +117,23 @@ impl Manager {
                     .state
                     .get_mut(&window_id)
                     .expect("Missing window ID in state");
-                let time = self.init_time.elapsed().as_secs_f32();
-                graphics.render(time);
+                let ctx = RenderContext {
+                    elapsed: self.init_time.elapsed(),
+                    fade_amount: (self.last_keypress_time.elapsed() + FADE_BEFORE_FREEZE)
+                        .saturating_sub(FREEZE_AFTER_INACTIVITY)
+                        .as_secs_f32()
+                        / FADE_BEFORE_FREEZE.as_secs_f32(),
+                };
+                graphics.render(ctx);
+                if self.last_keypress_time.elapsed() > FREEZE_AFTER_INACTIVITY {
+                    self.frozen = true;
+                }
             }
             Event::MainEventsCleared => {
-                for State { window, .. } in self.state.values() {
-                    window.request_redraw();
+                if !self.frozen {
+                    for State { window, .. } in self.state.values() {
+                        window.request_redraw();
+                    }
                 }
             }
             _ => {}
diff --git a/src/utils.rs b/src/utils.rs
@@ -10,7 +10,7 @@ impl<F> CallOnce<F> {
 
 impl<F, Args> FnOnce<Args> for CallOnce<F>
 where
-    F: FnOnce<Args>,
+    F: FnOnce<Args>, Args: std::marker::Tuple,
 {
     type Output = Option<F::Output>;
     extern "rust-call" fn call_once(self, args: Args) -> Self::Output {
@@ -20,7 +20,7 @@ where
 
 impl<F, Args> FnMut<Args> for CallOnce<F>
 where
-    F: FnOnce<Args>,
+    F: FnOnce<Args>, Args: std::marker::Tuple,
 {
     extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output {
         self.inner.take().map(|f| f.call_once(args))

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ layout(set = 0, binding = 2) uniform Uniforms {`
`10`	`10`
`11`	`11`	`layout(push_constant) uniform FrameUniforms {`
`12`	`12`	`float iTime;`
	`13`	`+ float iFadeAmount;`
`13`	`14`	`};`
`14`	`15`
`15`	`16`	`const vec4 CLEAR_COLOR = vec4(0.0, 0.0, 0.0, 1.0);`
`@@ -42,4 +43,5 @@ void main() {`
`42`	`43`	`} else {`
`43`	`44`	`f_color = texture(sampler2D(t_screenshot, s_screenshot), uv);`
`44`	`45`	`}`
	`46`	`+ f_color = mix(f_color, vec4(0.0, 0.0, 0.0, 1.0), iFadeAmount);`
`45`	`47`	`}`