shell: Handle fullscreen surfaces

src/backend/render/mod.rs

@@ -14,12 +14,18 @@ use smithay::{
         renderer::{
             gles2::{Gles2Renderbuffer, Gles2Renderer, Gles2Texture},
             multigpu::{egl::EglGlesBackend, Error as MultiError, MultiFrame, MultiRenderer},
-            ImportAll, Renderer, TextureFilter,
+            ImportAll, Renderer, Frame, TextureFilter,
         },
     },
-    desktop::space::{RenderElement, RenderError, SpaceOutputTuple, SurfaceTree},
-    utils::{Logical, Point, Rectangle},
-    wayland::output::Output,
+    desktop::{
+        space::{RenderElement, RenderError, SpaceOutputTuple, SurfaceTree},
+        draw_window, draw_layer_surface, Window, layer_map_for_output, utils::damage_from_surface_tree,
+    },
+    utils::{Logical, Point, Rectangle, Transform},
+    wayland::{
+        shell::wlr_layer::Layer as WlrLayer,
+        output::Output,
+    },
 };
 
 mod cursor;
@@ -29,6 +35,8 @@ pub type GlMultiRenderer<'a> =
     MultiRenderer<'a, 'a, EglGlesBackend, EglGlesBackend, Gles2Renderbuffer>;
 pub type GlMultiFrame = MultiFrame<EglGlesBackend, EglGlesBackend>;
 
+static CLEAR_COLOR: [f32; 4] = [0.153, 0.161, 0.165, 1.0];
+
 smithay::custom_elements! {
     pub CustomElem<=Gles2Renderer>;
     SurfaceTree=SurfaceTree,
@@ -97,7 +105,7 @@ impl AsGles2Renderer for GlMultiRenderer<'_> {
 }
 
 pub fn render_output<R>(
-    _gpu: Option<&DrmNode>,
+    gpu: Option<&DrmNode>,
     renderer: &mut R,
     age: u8,
     state: &mut Common,
@@ -117,7 +125,50 @@ where
         fps.start();
     }
 
-    #[allow(unused_mut)]
+    let workspace = state.shell.active_space(output);
+    let maybe_fullscreen_window = workspace.get_fullscreen(output).cloned();
+    let res = if let Some(window) = maybe_fullscreen_window {
+    #[cfg(not(feature = "debug"))]
+        {
+            render_fullscreen(gpu, renderer, window, state, output, hardware_cursor)
+        }
+        #[cfg(feature = "debug")]
+        {
+            render_fullscreen(gpu, renderer, window, state, output, hardware_cursor, fps)
+        }
+    } else {
+        #[cfg(not(feature = "debug"))]
+        {
+            render_desktop(gpu, renderer, age, state, output, hardware_cursor)
+        }
+        #[cfg(feature = "debug")]
+        {
+            render_desktop(gpu, renderer, age, state, output, hardware_cursor, fps)
+        }
+    };
+
+    #[cfg(feature = "debug")]
+    {
+        fps.end();
+    }
+
+    res
+}
+
+fn render_desktop<R>(
+    _gpu: Option<&DrmNode>,
+    renderer: &mut R,
+    age: u8,
+    state: &mut Common,
+    output: &Output,
+    hardware_cursor: bool,
+    #[cfg(feature = "debug")] fps: &mut Fps,
+) -> Result<Option<Vec<Rectangle<i32, Logical>>>, RenderError<R>>
+where
+    R: Renderer + ImportAll + AsGles2Renderer,
+    <R as Renderer>::TextureId: Clone + 'static,
+    CustomElem: RenderElement<R>,
+{
     let mut custom_elements = Vec::<CustomElem>::new();
 
     #[cfg(feature = "debug")]
@@ -162,18 +213,116 @@ where
         }
     }
 
-    let res = state.shell.active_space_mut(output).space.render_output(
+    state.shell.active_space_mut(output).space.render_output(
         renderer,
         &output,
         age as usize,
-        [0.153, 0.161, 0.165, 1.0],
+        CLEAR_COLOR,
         &*custom_elements,
-    );
+    )
+}
+
+fn render_fullscreen<R>(
+    _gpu: Option<&DrmNode>,
+    renderer: &mut R,
+    window: Window,
+    state: &mut Common,
+    output: &Output,
+    hardware_cursor: bool,
+    #[cfg(feature = "debug")] fps: &mut Fps,
+) -> Result<Option<Vec<Rectangle<i32, Logical>>>, RenderError<R>>
+where
+    R: Renderer + ImportAll + AsGles2Renderer,
+    <R as Renderer>::TextureId: Clone + 'static,
+    CustomElem: RenderElement<R>,
+{
+    let transform = Transform::from(output.current_transform());
+    let mode = output.current_mode().unwrap();
+    let scale = output.current_scale().fractional_scale();
+    let output_geo = state.shell.output_geometry(output);
+
+    let mut custom_elements = Vec::<CustomElem>::new();
 
     #[cfg(feature = "debug")]
     {
-        fps.end();
+        let fps_overlay = fps_ui(_gpu, state, fps, Rectangle::from_loc_and_size((0, 0), output_geo.size), scale);
+        custom_elements.push(fps_overlay.into());
+    }
+    
+    for seat in &state.seats {
+        let pointer = match seat.get_pointer() {
+            Some(ptr) => ptr,
+            None => continue,
+        };
+        let location = state
+            .shell
+            .space_relative_output_geometry(pointer.current_location().to_i32_round(), output);
+
+        if let Some(cursor) = cursor::draw_cursor(
+            renderer.as_gles2(),
+            seat,
+            location,
+            &state.start_time,
+            !hardware_cursor,
+        ) {
+            custom_elements.push(cursor)
+        }
     }
 
-    res
+    renderer
+        .render(mode.size, transform, |renderer, frame| {
+            let mut damage = window.accumulated_damage(None);
+            frame.clear(
+                CLEAR_COLOR,
+                &[Rectangle::from_loc_and_size((0, 0), mode.size).to_f64()],
+            )?;
+            draw_window(
+                renderer,
+                frame,
+                &window,
+                scale,
+                (0, 0),
+                &[Rectangle::from_loc_and_size(
+                    (0, 0),
+                    mode.size.to_f64().to_logical(scale).to_i32_round(),
+                )],
+                &slog_scope::logger(),
+            )?;
+            let layer_map = layer_map_for_output(output);
+            for layer_surface in layer_map.layers_on(WlrLayer::Overlay) {
+                let geo = layer_map.layer_geometry(&layer_surface).unwrap();
+                draw_layer_surface(
+                    renderer,
+                    frame,
+                    layer_surface,
+                    scale,
+                    geo.loc,
+                    &[Rectangle::from_loc_and_size((0, 0), geo.size)],
+                    &slog_scope::logger(),
+                )?;
+                if let Some(surface) = layer_surface.get_surface() {
+                    damage.extend(damage_from_surface_tree(surface, geo.loc, None));
+                }
+            }
+            for elem in custom_elements {
+                let geo = elem.geometry();
+                let location = geo.loc - output_geo.loc;
+                let elem_damage = elem.accumulated_damage(None);
+                elem.draw(
+                    renderer,
+                    frame,
+                    scale,
+                    location,
+                    &[Rectangle::from_loc_and_size((0, 0), geo.size)],
+                    &slog_scope::logger(),
+                )?;
+                damage.extend(elem_damage.into_iter().map(|mut rect| {
+                    rect.loc += geo.loc;
+                    rect
+                }))
+            }
+            Ok(Some(damage))
+        })
+        .and_then(std::convert::identity)
+        .map_err(RenderError::<R>::Rendering)
 }