TMP alpha mode

Author: madsmtm

src/backend_interface.rs

@@ -1,6 +1,6 @@
 //! Interface implemented by backends
 
-use crate::{InitError, Rect, SoftBufferError};
+use crate::{AlphaMode, InitError, Rect, SoftBufferError};
 
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use std::num::NonZeroU32;
@@ -22,12 +22,23 @@ pub(crate) trait SurfaceInterface<D: HasDisplayHandle + ?Sized, W: HasWindowHand
     where
         W: Sized,
         Self: Sized;
+
     /// Get the inner window handle.
     fn window(&self) -> &W;
-    /// Resize the internal buffer to the given width and height.
-    fn resize(&mut self, width: NonZeroU32, height: NonZeroU32) -> Result<(), SoftBufferError>;
+
+    fn alpha_mode(&self) -> AlphaMode;
+
+    /// Reconfigure the internal buffer(s).
+    fn configure(
+        &mut self,
+        width: NonZeroU32,
+        height: NonZeroU32,
+        alpha_mode: AlphaMode,
+    ) -> Result<(), SoftBufferError>;
+
     /// Get a mutable reference to the buffer.
     fn buffer_mut(&mut self) -> Result<Self::Buffer<'_>, SoftBufferError>;
+
     /// Fetch the buffer from the window.
     fn fetch(&mut self) -> Result<Vec<u32>, SoftBufferError> {
         Err(SoftBufferError::Unimplemented)

src/backends/cg.rs

@@ -252,7 +252,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceInterface<D, W> for CGImpl<
         &self.window_handle
     }
 
-    fn resize(&mut self, width: NonZeroU32, height: NonZeroU32) -> Result<(), SoftBufferError> {
+    fn configure(&mut self, width: NonZeroU32, height: NonZeroU32) -> Result<(), SoftBufferError> {
         self.width = width.get() as usize;
         self.height = height.get() as usize;
         Ok(())

src/backends/wayland/buffer.rs

@@ -82,7 +82,13 @@ pub(super) struct WaylandBuffer {
 }
 
 impl WaylandBuffer {
-    pub fn new(shm: &wl_shm::WlShm, width: i32, height: i32, qh: &QueueHandle<State>) -> Self {
+    pub fn new(
+        shm: &wl_shm::WlShm,
+        width: i32,
+        height: i32,
+        format: wl_shm::Format,
+        qh: &QueueHandle<State>,
+    ) -> Self {
         // Calculate size to use for shm pool
         let pool_size = get_pool_size(width, height);
 
@@ -94,15 +100,7 @@ impl WaylandBuffer {
         // Create wayland shm pool and buffer
         let pool = shm.create_pool(tempfile.as_fd(), pool_size, qh, ());
         let released = Arc::new(AtomicBool::new(true));
-        let buffer = pool.create_buffer(
-            0,
-            width,
-            height,
-            width * 4,
-            wl_shm::Format::Xrgb8888,
-            qh,
-            released.clone(),
-        );
+        let buffer = pool.create_buffer(0, width, height, width * 4, format, qh, released.clone());
 
         Self {
             qh: qh.clone(),
@@ -118,7 +116,7 @@ impl WaylandBuffer {
         }
     }
 
-    pub fn resize(&mut self, width: i32, height: i32) {
+    pub fn configure(&mut self, width: i32, height: i32, format: wl_shm::Format) {
         // If size is the same, there's nothing to do
         if self.width != width || self.height != height {
             // Destroy old buffer
@@ -139,7 +137,7 @@ impl WaylandBuffer {
                 width,
                 height,
                 width * 4,
-                wl_shm::Format::Xrgb8888,
+                format,
                 &self.qh,
                 self.released.clone(),
             );

src/backends/wayland/mod.rs

@@ -1,7 +1,7 @@
 use crate::{
     backend_interface::*,
     error::{InitError, SwResultExt},
-    Rect, SoftBufferError,
+    AlphaMode, Rect, SoftBufferError,
 };
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawDisplayHandle, RawWindowHandle};
 use std::{
@@ -81,6 +81,7 @@ pub struct WaylandImpl<D: ?Sized, W: ?Sized> {
     surface: Option<wl_surface::WlSurface>,
     buffers: Option<(WaylandBuffer, WaylandBuffer)>,
     size: Option<(NonZeroI32, NonZeroI32)>,
+    format: wl_shm::Format,
 
     /// The pointer to the window object.
     ///
@@ -128,7 +129,12 @@ impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> SurfaceInterface<D, W>
         &self.window_handle
     }
 
-    fn resize(&mut self, width: NonZeroU32, height: NonZeroU32) -> Result<(), SoftBufferError> {
+    fn configure(
+        &mut self,
+        width: NonZeroU32,
+        height: NonZeroU32,
+        alpha_mode: AlphaMode,
+    ) -> Result<AlphaMode, SoftBufferError> {
         self.size = Some(
             (|| {
                 let width = NonZeroI32::try_from(width).ok()?;
@@ -137,7 +143,13 @@ impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> SurfaceInterface<D, W>
             })()
             .ok_or(SoftBufferError::SizeOutOfRange { width, height })?,
         );
-        Ok(())
+        let (format, chosen_alpha_mode) = match alpha_mode {
+            AlphaMode::Opaque => (wl_shm::Format::Xrgb8888, AlphaMode::Opaque),
+            AlphaMode::PreMultiplied => (wl_shm::Format::Argb8888, AlphaMode::PreMultiplied),
+            AlphaMode::PostMultiplied => (wl_shm::Format::Argb8888, AlphaMode::PostMultiplied),
+        };
+        self.format = format;
+        Ok(chosen_alpha_mode)
     }
 
     fn buffer_mut(&mut self) -> Result<BufferImpl<'_>, SoftBufferError> {
@@ -164,20 +176,22 @@ impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> SurfaceInterface<D, W>
             }
 
             // Resize, if buffer isn't large enough
-            back.resize(width.get(), height.get());
+            back.configure(width.get(), height.get(), self.format);
         } else {
             // Allocate front and back buffer
             self.buffers = Some((
                 WaylandBuffer::new(
                     &self.display.shm,
                     width.get(),
                     height.get(),
+                    self.format,
                     &self.display.qh,
                 ),
                 WaylandBuffer::new(
                     &self.display.shm,
                     width.get(),
                     height.get(),
+                    self.format,
                     &self.display.qh,
                 ),
             ));

src/lib.rs

@@ -74,6 +74,9 @@ pub struct Rect {
 /// A surface for drawing to a window with software buffers.
 #[derive(Debug)]
 pub struct Surface<D, W> {
+    alpha_mode: AlphaMode,
+    /// A buffer that is used when `!supported_alpha_mode.contains(alpha_mode)`.
+    fallback_buffer: Option<Vec<u8>>,
     /// This is boxed so that `Surface` is the same size on every platform.
     surface_impl: Box<SurfaceDispatch<D, W>>,
     _marker: PhantomData<Cell<()>>,
@@ -104,14 +107,28 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> Surface<D, W> {
         self.surface_impl.window()
     }
 
+    /// The current alpha mode of the surface.
+    pub fn alpha_mode(&self) -> AlphaMode {
+        self.surface_impl.alpha_mode()
+    }
+
     /// Set the size of the buffer that will be returned by [`Surface::buffer_mut`].
     ///
     /// If the size of the buffer does not match the size of the window, the buffer is drawn
     /// in the upper-left corner of the window. It is recommended in most production use cases
     /// to have the buffer fill the entire window. Use your windowing library to find the size
     /// of the window.
     pub fn resize(&mut self, width: NonZeroU32, height: NonZeroU32) -> Result<(), SoftBufferError> {
-        self.surface_impl.resize(width, height)
+        self.configure(width, height, self.alpha_mode())
+    }
+
+    pub fn configure(
+        &mut self,
+        width: NonZeroU32,
+        height: NonZeroU32,
+        alpha_mode: AlphaMode,
+    ) -> Result<(), SoftBufferError> {
+        self.surface_impl.configure(width, height, alpha_mode)
     }
 
     /// Copies the window contents into a buffer.
@@ -424,6 +441,72 @@ impl Buffer<'_> {
     }
 }
 
+/// Specifies how the alpha channel of the surface should be handled by the compositor.
+///
+/// Whether this has an effect is dependent on whether [the pixel format](crate::Format) has an
+/// alpha component.
+///
+/// See [the WhatWG spec][whatwg-premultiplied] for a good description of the difference between
+/// premultiplied and postmultiplied alpha.
+///
+/// [whatwg-premultiplied]: https://html.spec.whatwg.org/multipage/canvas.html#premultiplied-alpha-and-the-2d-rendering-context
+#[doc(alias = "Transparency")]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
+pub enum AlphaMode {
+    /// The alpha channel is ignored.
+    ///
+    /// # Platform-specific
+    ///
+    /// This requires a copy on Web.
+    #[default]
+    Opaque,
+    /// The non-alpha channels are expected to already have been multiplied by the alpha channel.
+    ///
+    /// # Platform-specific
+    ///
+    /// This requires a copy on Web.
+    PreMultiplied,
+    /// The non-alpha channels are not expected to already be multiplied by the alpha channel;
+    /// instead, the compositor will multiply the non-alpha channels by the alpha channel during
+    /// compositing.
+    ///
+    /// Also known as "straight alpha".
+    ///
+    /// # Platform-specific
+    ///
+    /// This is unsupported on Wayland (TODO: And others?), so there Softbuffer creates a separate
+    /// buffer that is used later on for the conversion.
+    ///
+    /// Web: Works great.
+    #[doc(alias = "Straight")]
+    PostMultiplied,
+}
+
+/// Convenience helpers.
+impl AlphaMode {
+    /// Check if this is [`AlphaMode::Opaque`].
+    pub fn is_opaque(self) -> bool {
+        matches!(self, Self::Opaque)
+    }
+
+    /// Check if this is [`AlphaMode::PreMultiplied`].
+    pub fn is_pre_multiplied(self) -> bool {
+        matches!(self, Self::PreMultiplied)
+    }
+
+    /// Check if this is [`AlphaMode::PostMultiplied`].
+    pub fn is_post_multiplied(self) -> bool {
+        matches!(self, Self::PostMultiplied)
+    }
+
+    /// Whether the alpha mode allows the surface to be transparent.
+    ///
+    /// This is true for pre-multiplied and post-multiplied alpha modes.
+    pub fn has_transparency(self) -> bool {
+        !self.is_opaque()
+    }
+}
+
 /// There is no display handle.
 #[derive(Debug)]
 #[allow(dead_code)]