Make module dependencies explicit across the workspace

compositor/src/render/backdrop.rs

@@ -1,4 +1,7 @@
-use super::*;
+use super::{
+    AnimatedWindowRenderElement, Buffer, CommitCounter, Element, Id, Ordering, Physical, Rectangle,
+    RenderScale, Transform,
+};
 
 #[derive(Clone, Debug, Default)]
 pub(super) struct Backdrop {
@@ -132,6 +135,12 @@ pub(super) fn update(elements: &[AnimatedWindowRenderElement], scale: f64) {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(test)]
+    use smithay::backend::renderer::utils::DamageSet;
+    #[cfg(test)]
+    use smithay::backend::renderer::utils::OpaqueRegions;
+    use std::sync::Arc;
+
     use super::*;
 
     struct TestElement {

compositor/src/render/capture.rs

@@ -1,4 +1,10 @@
-use super::*;
+use super::{
+    Arc, Bind, Color32F, CommitCounter, Duration, ExportMem, Ferese, Fourcc, Frame, GlesError,
+    GlesRenderer, GlesTexture, Id, Logical, Offscreen, Physical, Point, Rectangle,
+    RenderElementKind, Renderer, ResizeSnapshot, Size, Texture, Transform,
+    WaylandSurfaceRenderElement, cursor_elements, draw_render_elements,
+    render_elements_from_surface_tree,
+};
 
 #[derive(Default)]
 struct CaptureTarget(std::sync::Mutex<Option<GlesTexture>>);

compositor/src/render/closing.rs

@@ -1,4 +1,8 @@
-use super::*;
+use super::{
+    AnimatedWindowRenderElement, CornerShape, Duration, Ferese, GlesRenderer, MaterialSurface,
+    Output, Renderer, ResizeSnapshot, RoundedRect, corner_program, material_element_with_role,
+    rounded_visual_rect, window_border_element, window_shadow_element, window_tint_element,
+};
 use ferese_animation::{CrossingPolicy, SpringConfig};
 use ferese_core::OutputId;
 use ferese_layout::WindowId;

compositor/src/render/corner_tests.rs

@@ -207,7 +207,7 @@ fn window_corner_shader_timing_sample() {
     let mut renderer = renderer();
     let driver = renderer
         .with_context(|gl| {
-            unsafe { std::ffi::CStr::from_ptr(gl.GetString(0x1F01).cast()) }
+            unsafe { std::ffi::CStr::from_ptr(gl.GetString(0x1f01).cast()) }
                 .to_string_lossy()
                 .into_owned()
         })

compositor/src/render/decorations.rs

@@ -1,4 +1,14 @@
-use super::*;
+use super::{
+    AnimatedWindowRenderElement, BorderParameters, CachedBorder, CachedShadow, ConstrainAlign,
+    ConstrainScaleBehavior, CornerShape, GlesRenderer, Logical, Output, Physical,
+    PhysicalShaderElement, Point, PopupManager, ROUNDED_BORDER_SHADER, ROUNDED_SOLID_SHADER,
+    ROUNDED_TEXTURE_SHADER, Rectangle, RenderElementKind, RenderResources, Renderer,
+    RoundedClipPrograms, RoundedRect, RoundedSurfaceRenderElement, ShadowParameters,
+    SharedPixelShaderElement, Size, Transform, Uniform, UniformName, UniformType,
+    WINDOW_SHADOW_SHADER, WaylandSurfaceRenderElement, WindowContentRenderElement, clamp_radius,
+    constrain_render_elements, corner_shader_for, material_program_for_corners,
+    render_elements_from_surface_tree,
+};
 
 pub(super) fn rounded_clip_program(
     resources: &mut RenderResources,
@@ -529,9 +539,6 @@ pub(super) fn resize_content_behavior(intentional_scale: bool) -> ConstrainScale
     }
 }
 
-#[cfg(test)]
-pub(super) use crate::presentation::scaled_visual_rect;
-
 pub(super) fn color_with_alpha(mut color: [f32; 4], alpha: f32) -> [f32; 4] {
     color[3] *= alpha;
     color

compositor/src/render/materials.rs

@@ -1,4 +1,15 @@
-use super::*;
+use super::{
+    AnimatedWindowRenderElement, Arc, AtomicBool, BLUR_SHADER, BlurCapture, BlurProgram,
+    BlurRenderElement, CachedMaterial, CommitCounter, CornerShape, CropRenderElement, DamageSet,
+    Element, Ferese, Fourcc, GlesRenderer, GlesTexture, Logical, MATERIAL_SHADER, MaterialElement,
+    MaterialParameters, MaterialProgram, Offscreen, Output, PanelMatrices, Physical,
+    PhysicalShaderElement, Point, Rectangle, Relocate, RelocateRenderElement, RenderElementKind,
+    RenderResources, Renderer, RescaleRenderElement, RoundedRect, RoundedSurfaceRenderElement,
+    SharedPixelShaderElement, Size, Texture, Transform, Uniform, UniformName, UniformType,
+    WaylandSurfaceRenderElement, WindowContentRenderElement, clamp_radius, corner_shader,
+    corner_shader_for, framebuffer_clip_rect, render_elements_from_surface_tree,
+    rounded_clip_program, shadow_bounds,
+};
 
 #[allow(clippy::too_many_arguments)]
 pub(super) fn append_material_surface(

compositor/src/render/mod.rs

@@ -22,9 +22,18 @@ use std::time::Duration;
 pub(crate) use capture::{
     capture_resize_snapshot, capture_window_buffer, capture_window_frame, convert_window_pixels,
 };
-use decorations::*;
-use materials::*;
-use overview::*;
+use decorations::{
+    border_uniforms, color_with_alpha, corner_program, framebuffer_clip_rect,
+    resize_content_behavior, rounded_clip_program, rounded_visual_rect, rounded_window_elements,
+    shadow_bounds, tint_uniforms, window_border_element, window_shadow_element,
+    window_tint_element,
+};
+use materials::{
+    MaterialSurface, append_material_surface, blur_damage, blur_program, blur_uniforms,
+    expanded_blur_region, framebuffer_capture_rect, material_element, material_element_with_role,
+    material_program, material_program_for_corners,
+};
+use overview::{overview_chrome_element, overview_strip_elements};
 pub(crate) use resources::RenderResources;
 use scene::cursor_elements;
 pub(crate) use scene::{
@@ -654,14 +663,18 @@ where
 
 #[cfg(test)]
 mod tests {
+    use super::decorations::border_gradient_line;
+    use crate::presentation::scaled_visual_rect;
+    use crate::render::materials::blur_uniform_names;
+    use crate::render::materials::material_blur_radius;
     use smithay::backend::renderer::damage::OutputDamageTracker;
     use smithay::backend::renderer::element::{Element, Id};
     use smithay::backend::renderer::utils::CommitCounter;
     use smithay::utils::{Buffer, Logical, Physical, Rectangle, Scale, Transform};
 
     use super::{
-        border_gradient_line, color_with_alpha, framebuffer_clip_rect, resize_content_behavior,
-        rounded_visual_rect, scaled_visual_rect, shadow_bounds,
+        color_with_alpha, framebuffer_clip_rect, resize_content_behavior, rounded_visual_rect,
+        shadow_bounds,
     };
 
     #[test]
@@ -782,7 +795,7 @@ mod tests {
         let program = renderer
             .compile_custom_texture_shader(
                 super::corner_shader(super::BLUR_SHADER),
-                &super::blur_uniform_names(),
+                &blur_uniform_names(),
             )
             .unwrap();
         let size = (32, 32).into();
@@ -1184,21 +1197,18 @@ mod tests {
     fn translucent_materials_blur_at_full_opacity() {
         use crate::config::MaterialStyle;
         assert_eq!(
-            super::material_blur_radius(MaterialStyle::Translucent, 0.0, 18.0),
+            material_blur_radius(MaterialStyle::Translucent, 0.0, 18.0),
             0.0
         );
         assert_eq!(
-            super::material_blur_radius(MaterialStyle::Translucent, 1.0, 18.0),
+            material_blur_radius(MaterialStyle::Translucent, 1.0, 18.0),
             18.0
         );
         assert_eq!(
-            super::material_blur_radius(MaterialStyle::Translucent, 0.79, 18.0),
+            material_blur_radius(MaterialStyle::Translucent, 0.79, 18.0),
             18.0
         );
-        assert_eq!(
-            super::material_blur_radius(MaterialStyle::Solid, 0.79, 18.0),
-            0.0
-        );
+        assert_eq!(material_blur_radius(MaterialStyle::Solid, 0.79, 18.0), 0.0);
     }
 
     #[test]

compositor/src/render/overview.rs

@@ -1,4 +1,12 @@
-use super::*;
+use super::{
+    AnimatedWindowRenderElement, BorderParameters, CachedBorder, ConstrainScaleBehavior,
+    CropRenderElement, Ferese, GlesRenderer, HashMap, Logical, MemoryRenderBufferRenderElement,
+    Output, OverviewChromePart, OverviewScrim, Physical, PhysicalShaderElement, Point, Rectangle,
+    Relocate, RelocateRenderElement, RenderElementKind, Renderer, RescaleRenderElement,
+    RoundedRect, SharedPixelShaderElement, border_uniforms, corner_program, framebuffer_clip_rect,
+    material_program, physical_rect, rounded_clip_program, rounded_visual_rect,
+    rounded_window_elements, tint_uniforms, window_corner_shape,
+};
 
 #[allow(clippy::too_many_arguments)]
 pub(super) fn overview_chrome_element(

compositor/src/render/resources.rs

@@ -1,8 +1,25 @@
 use ferese_core::OutputId;
+#[cfg(test)]
+use smithay::backend::allocator::Fourcc;
+#[cfg(test)]
+use smithay::backend::renderer::Offscreen;
+#[cfg(test)]
+use smithay::backend::renderer::element::Id;
+#[cfg(test)]
+use smithay::backend::renderer::gles::GlesRenderer;
+#[cfg(test)]
+use smithay::backend::renderer::gles::GlesTexture;
+#[cfg(test)]
+use smithay::backend::renderer::utils::CommitCounter;
+
 use ferese_layout::WindowId;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 
-use super::*;
+use super::{
+    BlurProgram, ClosedWindow, CornerShape, ErasedContextId, HashMap, MaterialBuffers,
+    MaterialProgram, OverviewChromePart, OverviewScrim, ResizeSnapshot, RoundedClipPrograms,
+    WindowBorderBuffers, WindowShadowBuffers,
+};
 
 /// Resource ownership follows the lifetime of a window, output, surface or GL
 /// context. Desktop policy and animation values do not live in these caches.
@@ -208,6 +225,11 @@ impl RenderResources {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::render::blur_program;
+    use crate::render::material_program;
+    use crate::render::rounded_clip_program;
+    use smithay::backend::renderer::Renderer;
+    use std::time::Duration;
 
     #[test]
     fn window_removal_releases_all_its_caches_without_removing_other_windows() {

compositor/src/render/scene.rs

@@ -1,6 +1,23 @@
 use smithay::desktop::Window;
 
-use super::*;
+#[cfg(test)]
+use smithay::backend::renderer::element::Id;
+#[cfg(test)]
+use smithay::backend::renderer::utils::CommitCounter;
+
+use super::{
+    AnimatedWindowRenderElement, ConstrainAlign, ConstrainBehavior, ConstrainReference,
+    CropRenderElement, CursorImageStatus, CursorImageSurfaceData, Duration, Ferese,
+    FrameEffectMetrics, GlesRenderer, Layer, LayerSurface, Logical, MaterialSurface,
+    MemoryRenderBufferRenderElement, Output, Physical, Point, PopupManager, Rectangle, Relocate,
+    RelocateRenderElement, RenderElementKind, Renderer, RescaleRenderElement, Resource,
+    RoundedRect, Size, SolidColorRenderElement, Transform, WaylandSurfaceRenderElement,
+    append_material_surface, backdrop, constrain_space_element, corner_program,
+    layer_map_for_output, material_element, overview_strip_elements,
+    render_elements_from_surface_tree, resize_content_behavior, rounded_visual_rect,
+    rounded_window_elements, window_border_element, window_corner_shape, window_shadow_element,
+    window_tint_element, with_states,
+};
 
 pub(crate) fn animated_window_elements(
     state: &mut Ferese,
@@ -602,6 +619,7 @@ pub(super) fn cursor_elements(
 #[cfg(test)]
 mod layer_crop_tests {
     use super::*;
+    use smithay::backend::renderer::element::Element;
 
     #[test]
     fn layer_crop_keeps_bottom_edge_content_in_every_output_transform() {

compositor/src/render/tab_indicator.rs

@@ -1,4 +1,9 @@
-use super::*;
+use super::{
+    AnimatedWindowRenderElement, CropRenderElement, Ferese, GlesRenderer, Logical,
+    MemoryRenderBufferRenderElement, Output, OverviewChromePart, Physical, Point, Rectangle,
+    Relocate, RelocateRenderElement, RenderElementKind, RescaleRenderElement, color_with_alpha,
+    overview_chrome_element, physical_rect,
+};
 use ferese_layout::{Rect, TabBar, WindowId};
 
 #[allow(clippy::too_many_arguments)]

compositor/src/render/tabs.rs

@@ -1,4 +1,9 @@
-use super::*;
+use super::{
+    AnimatedWindowRenderElement, CropRenderElement, Ferese, GlesRenderer,
+    MemoryRenderBufferRenderElement, Output, OverviewChromePart, Physical, Point, Rectangle,
+    Relocate, RelocateRenderElement, RenderElementKind, RescaleRenderElement,
+    overview_chrome_element, physical_rect,
+};
 
 pub(super) fn tab_elements(
     state: &mut Ferese,

compositor/src/render/window_blur.rs

@@ -1,4 +1,8 @@
-use super::*;
+use super::{
+    AnimatedWindowRenderElement, Arc, AtomicBool, BlurRenderElement, Ferese, Fourcc, GlesRenderer,
+    GlesTexture, MaterialParameters, Offscreen, Output, Rectangle, Renderer, RoundedRect, Size,
+    Texture, blur_program, expanded_blur_region, framebuffer_capture_rect, framebuffer_clip_rect,
+};
 
 #[derive(Debug)]
 pub(super) struct WindowBlur {

compositor/src/render/window_content.rs

@@ -1,5 +1,27 @@
 //! Live, overview and retained views use the same snapshot mapping and clip.
-use super::*;
+#[cfg(test)]
+use crate::presentation::CornerShape;
+#[cfg(test)]
+use smithay::backend::allocator::Fourcc;
+#[cfg(test)]
+use smithay::backend::renderer::Color32F;
+#[cfg(test)]
+use smithay::backend::renderer::element::Id;
+#[cfg(test)]
+use smithay::backend::renderer::gles::GlesRenderer;
+#[cfg(test)]
+use smithay::backend::renderer::gles::GlesTexture;
+#[cfg(test)]
+use smithay::backend::renderer::utils::CommitCounter;
+#[cfg(test)]
+use smithay::backend::renderer::utils::draw_render_elements;
+#[cfg(test)]
+use smithay::utils::Transform;
+
+use super::{
+    NativeTextureElement, Output, Rectangle, ResizeSnapshot, RoundedClipPrograms, RoundedRect,
+    Size, Texture, Uniform, framebuffer_clip_rect,
+};
 
 pub(super) fn snapshot_element(
     snapshot: &ResizeSnapshot,
@@ -60,6 +82,15 @@ pub(super) fn snapshot_element(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::render::AnimatedWindowRenderElement;
+    use crate::render::RenderResources;
+    use crate::render::corner_program;
+    use smithay::backend::renderer::Bind;
+    use smithay::backend::renderer::ExportMem;
+    use smithay::backend::renderer::Frame;
+    use smithay::backend::renderer::Offscreen;
+    use smithay::backend::renderer::Renderer;
+    use std::time::Duration;
 
     #[test]
     #[ignore = "requires an EGL rendering device"]