Renamed usages of panel_state to state.

zsw/src/menu/panels.rs

@@ -70,13 +70,13 @@ fn draw_fade_panel_editor(
 	ui: &mut egui::Ui,
 	wgpu: &Wgpu,
 	window_geometry: Rect<i32, u32>,
-	panel_state: &mut PanelFadeState,
+	state: &mut PanelFadeState,
 	display: &mut Display,
 ) {
 	{
-		let mut is_paused = panel_state.is_paused();
+		let mut is_paused = state.is_paused();
 		ui.checkbox(&mut is_paused, "Paused");
-		panel_state.set_paused(is_paused);
+		state.set_paused(is_paused);
 	}
 
 	ui.collapsing("Geometries", |ui| {
@@ -99,51 +99,51 @@ fn draw_fade_panel_editor(
 		// Note: We only allow up until the duration - 1 so that you don't get stuck
 		//       skipping images when you hold it at the max value
 		// TODO: This max needs to be `duration - min_frame_duration` to not skip ahead.
-		let max = panel_state.duration().mul_f32(0.99);
-		let mut progress = panel_state.progress();
+		let max = state.duration().mul_f32(0.99);
+		let mut progress = state.progress();
 		super::draw_duration(ui, &mut progress, Duration::ZERO..=max);
-		panel_state.set_progress(progress);
+		state.set_progress(progress);
 	});
 
 	ui.horizontal(|ui| {
 		ui.label("Fade Duration");
 		let min = Duration::ZERO;
-		let max = panel_state.duration() / 2;
+		let max = state.duration() / 2;
 
-		let mut fade_duration = panel_state.fade_duration();
+		let mut fade_duration = state.fade_duration();
 		super::draw_duration(ui, &mut fade_duration, min..=max);
-		panel_state.set_fade_duration(fade_duration);
+		state.set_fade_duration(fade_duration);
 	});
 
 	ui.horizontal(|ui| {
 		ui.label("Duration");
 
-		let mut duration = panel_state.duration();
+		let mut duration = state.duration();
 		super::draw_duration(ui, &mut duration, Duration::ZERO..=Duration::from_secs_f32(180.0));
-		panel_state.set_duration(duration);
+		state.set_duration(duration);
 	});
 
 	ui.horizontal(|ui| {
 		ui.label("Skip");
 		if ui.button("🔄").clicked() {
-			panel_state.skip(wgpu).block_on();
+			state.skip(wgpu).block_on();
 		}
 	});
 
 	ui.collapsing("Images", |ui| {
 		ui.collapsing("Previous", |ui| {
-			self::draw_fade_panel_image(ui, &mut panel_state.images_mut().prev);
+			self::draw_fade_panel_image(ui, &mut state.images_mut().prev);
 		});
 		ui.collapsing("Current", |ui| {
-			self::draw_fade_panel_image(ui, &mut panel_state.images_mut().cur);
+			self::draw_fade_panel_image(ui, &mut state.images_mut().cur);
 		});
 		ui.collapsing("Next", |ui| {
-			self::draw_fade_panel_image(ui, &mut panel_state.images_mut().next);
+			self::draw_fade_panel_image(ui, &mut state.images_mut().next);
 		});
 	});
 
 	ui.collapsing("Playlist", |ui| {
-		let playlist_player = panel_state.playlist_player().lock().block_on();
+		let playlist_player = state.playlist_player().lock().block_on();
 
 		let row_height = ui.text_style_height(&egui::TextStyle::Body);
 

zsw/src/panel/panels.rs

@@ -154,7 +154,7 @@ impl Panels {
 					.with_context(|| format!("Unable to load display {:?}", profile_panel.display))?;
 
 
-				let panel_state = match &profile_panel.shader {
+				let state = match &profile_panel.shader {
 					ProfilePanelShader::None(shader) => PanelState::None(PanelNoneState::new(shader.background_color)),
 					ProfilePanelShader::Fade(shader) => {
 						let state = PanelFadeState::new(shader.duration, shader.fade_duration, match shader.inner {
@@ -192,7 +192,7 @@ impl Panels {
 					},
 				};
 
-				let panel = Panel::new(display, panel_state);
+				let panel = Panel::new(display, state);
 				self.inner.lock().await.panels.push(Arc::new(Mutex::new(panel)));
 
 				Ok::<_, AppError>(())

zsw/src/panel/renderer.rs

@@ -372,7 +372,7 @@ impl PanelsRenderer {
 		window_id: WindowId,
 		geometry_idx: usize,
 		surface_size: PhysicalSize<u32>,
-		panel_state: &PanelState,
+		state: &PanelState,
 		window_geometry: Rect<i32, u32>,
 		display_geometry: &DisplayGeometry,
 		render_pass: &mut wgpu::RenderPass<'_>,
@@ -381,19 +381,19 @@ impl PanelsRenderer {
 		let pos_matrix = display_geometry.pos_matrix(window_geometry, surface_size);
 		let pos_matrix = uniform::Matrix4x4(pos_matrix.into());
 
-		match panel_state {
-			PanelState::None(panel_state) => Self::render_panel_none_geometry(
+		match state {
+			PanelState::None(state) => Self::render_panel_none_geometry(
 				wgpu,
 				render_pass,
 				window_id,
 				geometry_idx,
 				&shared.none,
 				pos_matrix,
-				panel_state,
+				state,
 			)
 			.await
 			.into(),
-			PanelState::Fade(panel_state) => Self::render_panel_fade_geometry(
+			PanelState::Fade(state) => Self::render_panel_fade_geometry(
 				wgpu,
 				render_pass,
 				window_id,
@@ -401,18 +401,18 @@ impl PanelsRenderer {
 				&shared.fade,
 				display_geometry,
 				pos_matrix,
-				panel_state,
+				state,
 			)
 			.await
 			.into(),
-			PanelState::Slide(panel_state) => Self::render_panel_slide_geometry(
+			PanelState::Slide(state) => Self::render_panel_slide_geometry(
 				wgpu,
 				render_pass,
 				window_id,
 				geometry_idx,
 				&shared.slide,
 				pos_matrix,
-				panel_state,
+				state,
 			)
 			.await
 			.into(),
@@ -427,16 +427,14 @@ impl PanelsRenderer {
 		geometry_idx: usize,
 		shared: &PanelNoneShared,
 		pos_matrix: uniform::Matrix4x4,
-		panel_state: &PanelNoneState,
+		state: &PanelNoneState,
 	) -> metrics::RenderPanelGeometryNoneFrameTime {
-		let geometry_uniforms = panel_state
-			.geometry_uniforms(wgpu, shared, window_id, geometry_idx)
-			.await;
+		let geometry_uniforms = state.geometry_uniforms(wgpu, shared, window_id, geometry_idx).await;
 
 		#[time(write_uniforms)]
 		let () = Self::write_uniforms(wgpu, &geometry_uniforms.buffer, uniform::None {
 			pos_matrix,
-			background_color: uniform::Vec4(panel_state.background_color),
+			background_color: uniform::Vec4(state.background_color),
 		});
 
 		// Bind the geometry uniforms
@@ -456,16 +454,16 @@ impl PanelsRenderer {
 		shared: &PanelFadeShared,
 		display_geometry: &DisplayGeometry,
 		pos_matrix: uniform::Matrix4x4,
-		panel_state: &PanelFadeState,
+		state: &PanelFadeState,
 	) -> metrics::RenderPanelGeometryFadeFrameTime {
-		let p = panel_state.progress_norm();
-		let f = panel_state.fade_duration_norm();
+		let p = state.progress_norm();
+		let f = state.fade_duration_norm();
 
 		// Full duration an image is on screen (including the fades)
 		let d = 1.0 + 2.0 * f;
 
 		let mut image_metrics = HashMap::new();
-		for (panel_image_slot, panel_image) in panel_state.images().iter() {
+		for (panel_image_slot, panel_image) in state.images().iter() {
 			let geometry_uniforms = panel_image
 				.geometry_uniforms(wgpu, &shared.images, window_id, geometry_idx)
 				.await;
@@ -500,7 +498,7 @@ impl PanelsRenderer {
 			let image_ratio = display_geometry.image_ratio(image_size);
 
 			#[time(write_uniforms)]
-			let () = match panel_state.shader() {
+			let () = match state.shader() {
 				PanelFadeShader::Basic => Self::write_uniforms(wgpu, &geometry_uniforms.buffer, uniform::FadeBasic {
 					pos_matrix,
 					image_ratio: uniform::Vec2(image_ratio.into()),
@@ -540,7 +538,7 @@ impl PanelsRenderer {
 			render_pass.set_bind_group(0, &geometry_uniforms.bind_group, &[]);
 
 			// Bind the image uniforms
-			let sampler = panel_state.images().image_sampler(wgpu).await;
+			let sampler = state.images().image_sampler(wgpu).await;
 			render_pass.set_bind_group(1, panel_image.bind_group(wgpu, sampler, &shared.images).await, &[]);
 
 			#[time(draw)]
@@ -563,11 +561,9 @@ impl PanelsRenderer {
 		geometry_idx: usize,
 		shared: &PanelSlideShared,
 		pos_matrix: uniform::Matrix4x4,
-		panel_state: &PanelSlideState,
+		state: &PanelSlideState,
 	) -> metrics::RenderPanelGeometrySlideFrameTime {
-		let geometry_uniforms = panel_state
-			.geometry_uniforms(wgpu, shared, window_id, geometry_idx)
-			.await;
+		let geometry_uniforms = state.geometry_uniforms(wgpu, shared, window_id, geometry_idx).await;
 
 		#[time(write_uniforms)]
 		let () = Self::write_uniforms(wgpu, &geometry_uniforms.buffer, uniform::Slide { pos_matrix });