aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/layout/closing_window.rs69
-rw-r--r--src/layout/mod.rs2
-rw-r--r--src/layout/opening_window.rs19
-rw-r--r--src/niri.rs8
-rw-r--r--src/render_helpers/mod.rs13
-rw-r--r--src/render_helpers/offscreen.rs17
-rw-r--r--src/render_helpers/primary_gpu_texture.rs2
-rw-r--r--src/render_helpers/surface.rs6
-rw-r--r--src/render_helpers/texture.rs207
-rw-r--r--src/ui/screen_transition.rs6
-rw-r--r--src/ui/screenshot_ui.rs20
11 files changed, 291 insertions, 78 deletions
diff --git a/src/layout/closing_window.rs b/src/layout/closing_window.rs
index bdeb73a5..8945d2aa 100644
--- a/src/layout/closing_window.rs
+++ b/src/layout/closing_window.rs
@@ -5,13 +5,12 @@ use anyhow::Context as _;
use glam::{Mat3, Vec2};
use niri_config::BlockOutFrom;
use smithay::backend::allocator::Fourcc;
-use smithay::backend::renderer::element::texture::TextureRenderElement;
use smithay::backend::renderer::element::utils::{
Relocate, RelocateRenderElement, RescaleRenderElement,
};
-use smithay::backend::renderer::element::{Id, Kind, RenderElement};
+use smithay::backend::renderer::element::{Kind, RenderElement};
use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture, Uniform};
-use smithay::backend::renderer::{Renderer as _, Texture};
+use smithay::backend::renderer::Texture;
use smithay::utils::{Logical, Point, Rectangle, Scale, Size, Transform};
use crate::animation::Animation;
@@ -20,21 +19,16 @@ use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
use crate::render_helpers::shader_element::ShaderRenderElement;
use crate::render_helpers::shaders::{mat3_uniform, ProgramType, Shaders};
use crate::render_helpers::snapshot::RenderSnapshot;
+use crate::render_helpers::texture::{TextureBuffer, TextureRenderElement};
use crate::render_helpers::{render_to_encompassing_texture, RenderTarget};
#[derive(Debug)]
pub struct ClosingWindow {
/// Contents of the window.
- texture: GlesTexture,
+ buffer: TextureBuffer<GlesTexture>,
/// Blocked-out contents of the window.
- blocked_out_texture: GlesTexture,
-
- /// Scale that the textures was rendered with.
- texture_scale: Scale<f64>,
-
- /// ID of the textures' renderer.
- texture_renderer_id: usize,
+ blocked_out_buffer: TextureBuffer<GlesTexture>,
/// Where the window should be blocked out from.
block_out_from: Option<BlockOutFrom>,
@@ -46,10 +40,10 @@ pub struct ClosingWindow {
pos: Point<i32, Logical>,
/// How much the texture should be offset.
- texture_offset: Point<f64, Logical>,
+ buffer_offset: Point<f64, Logical>,
/// How much the blocked-out texture should be offset.
- blocked_out_texture_offset: Point<f64, Logical>,
+ blocked_out_buffer_offset: Point<f64, Logical>,
/// The closing animation.
anim: Animation,
@@ -86,27 +80,33 @@ impl ClosingWindow {
)
.context("error rendering to texture")?;
+ let buffer = TextureBuffer::from_texture(
+ renderer,
+ texture,
+ scale,
+ Transform::Normal,
+ Vec::new(),
+ );
+
let offset = geo.loc.to_f64().to_logical(scale);
- Ok((texture, offset))
+ Ok((buffer, offset))
};
- let (texture, texture_offset) =
+ let (buffer, buffer_offset) =
render_to_texture(snapshot.contents).context("error rendering contents")?;
- let (blocked_out_texture, blocked_out_texture_offset) =
+ let (blocked_out_buffer, blocked_out_buffer_offset) =
render_to_texture(snapshot.blocked_out_contents)
.context("error rendering blocked-out contents")?;
Ok(Self {
- texture,
- blocked_out_texture,
- texture_scale: scale,
- texture_renderer_id: renderer.id(),
+ buffer,
+ blocked_out_buffer,
block_out_from: snapshot.block_out_from,
geo_size,
pos,
- texture_offset,
- blocked_out_texture_offset,
+ buffer_offset,
+ blocked_out_buffer_offset,
anim,
random_seed: fastrand::f32(),
})
@@ -130,10 +130,10 @@ impl ClosingWindow {
let progress = self.anim.value();
let clamped_progress = self.anim.clamped_value().clamp(0., 1.);
- let (texture, offset) = if target.should_block_out(self.block_out_from) {
- (&self.blocked_out_texture, self.blocked_out_texture_offset)
+ let (buffer, offset) = if target.should_block_out(self.block_out_from) {
+ (&self.blocked_out_buffer, self.blocked_out_buffer_offset)
} else {
- (&self.texture, self.texture_offset)
+ (&self.buffer, self.buffer_offset)
};
if Shaders::get(renderer).program(ProgramType::Close).is_some() {
@@ -146,9 +146,11 @@ impl ClosingWindow {
let input_to_geo = Mat3::from_scale(area_size / geo_size)
* Mat3::from_translation((area_loc - geo_loc) / area_size);
- let tex_scale = Vec2::new(self.texture_scale.x as f32, self.texture_scale.y as f32);
+ let tex_scale = self.buffer.texture_scale();
+ let tex_scale = Vec2::new(tex_scale.x as f32, tex_scale.y as f32);
let tex_loc = Vec2::new(offset.x as f32, offset.y as f32);
- let tex_size = Vec2::new(texture.width() as f32, texture.height() as f32) / tex_scale;
+ let tex_size = self.buffer.texture().size();
+ let tex_size = Vec2::new(tex_size.w as f32, tex_size.h as f32) / tex_scale;
let geo_to_tex =
Mat3::from_translation(-tex_loc / tex_size) * Mat3::from_scale(geo_size / tex_size);
@@ -166,22 +168,17 @@ impl ClosingWindow {
Uniform::new("niri_clamped_progress", clamped_progress as f32),
Uniform::new("niri_random_seed", self.random_seed),
],
- HashMap::from([(String::from("niri_tex"), texture.clone())]),
+ HashMap::from([(String::from("niri_tex"), buffer.texture().clone())]),
Kind::Unspecified,
)
.with_location(Point::from((0, 0)))
.into();
}
- let elem = TextureRenderElement::from_static_texture(
- Id::new(),
- self.texture_renderer_id,
+ let elem = TextureRenderElement::from_texture_buffer(
+ buffer.clone(),
Point::from((0., 0.)),
- texture.clone(),
- self.texture_scale.x as i32,
- Transform::Normal,
- Some(1. - clamped_progress as f32),
- None,
+ 1. - clamped_progress as f32,
None,
None,
Kind::Unspecified,
diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index e8e00609..3c660238 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -38,7 +38,6 @@ use niri_config::{CenterFocusedColumn, Config, Struts, Workspace as WorkspaceCon
use niri_ipc::SizeChange;
use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
-use smithay::backend::renderer::element::texture::TextureBuffer;
use smithay::backend::renderer::element::Id;
use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture};
use smithay::output::{self, Output};
@@ -51,6 +50,7 @@ use self::workspace::{compute_working_area, Column, ColumnWidth, OutputId, Works
use crate::niri_render_elements;
use crate::render_helpers::renderer::NiriRenderer;
use crate::render_helpers::snapshot::RenderSnapshot;
+use crate::render_helpers::texture::TextureBuffer;
use crate::render_helpers::{BakedBuffer, RenderTarget, SplitElements};
use crate::utils::{output_size, ResizeEdge};
use crate::window::ResolvedWindowRules;
diff --git a/src/layout/opening_window.rs b/src/layout/opening_window.rs
index 1a8b3b99..38eb89ab 100644
--- a/src/layout/opening_window.rs
+++ b/src/layout/opening_window.rs
@@ -4,13 +4,12 @@ use std::time::Duration;
use anyhow::Context as _;
use glam::{Mat3, Vec2};
use smithay::backend::allocator::Fourcc;
-use smithay::backend::renderer::element::texture::TextureRenderElement;
use smithay::backend::renderer::element::utils::{
Relocate, RelocateRenderElement, RescaleRenderElement,
};
-use smithay::backend::renderer::element::{Id, Kind, RenderElement};
+use smithay::backend::renderer::element::{Kind, RenderElement};
use smithay::backend::renderer::gles::{GlesRenderer, Uniform};
-use smithay::backend::renderer::{Renderer as _, Texture};
+use smithay::backend::renderer::Texture;
use smithay::utils::{Logical, Point, Rectangle, Scale, Size, Transform};
use crate::animation::Animation;
@@ -19,6 +18,7 @@ use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
use crate::render_helpers::render_to_encompassing_texture;
use crate::render_helpers::shader_element::ShaderRenderElement;
use crate::render_helpers::shaders::{mat3_uniform, ProgramType, Shaders};
+use crate::render_helpers::texture::{TextureBuffer, TextureRenderElement};
#[derive(Debug)]
pub struct OpenAnimation {
@@ -122,15 +122,12 @@ impl OpenAnimation {
.into());
}
- let elem = TextureRenderElement::from_static_texture(
- Id::new(),
- renderer.id(),
+ let buffer =
+ TextureBuffer::from_texture(renderer, texture, scale, Transform::Normal, Vec::new());
+ let elem = TextureRenderElement::from_texture_buffer(
+ buffer,
Point::from((0., 0.)),
- texture.clone(),
- scale.x as i32,
- Transform::Normal,
- Some(clamped_progress as f32),
- None,
+ clamped_progress as f32,
None,
None,
Kind::Unspecified,
diff --git a/src/niri.rs b/src/niri.rs
index 8e9e11bd..e7bab37d 100644
--- a/src/niri.rs
+++ b/src/niri.rs
@@ -20,7 +20,6 @@ use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRen
use smithay::backend::renderer::element::surface::{
render_elements_from_surface_tree, WaylandSurfaceRenderElement,
};
-use smithay::backend::renderer::element::texture::TextureBuffer;
use smithay::backend::renderer::element::utils::{
select_dmabuf_feedback, Relocate, RelocateRenderElement,
};
@@ -115,6 +114,7 @@ use crate::pw_utils::{Cast, PipeWire};
use crate::render_helpers::debug::draw_opaque_regions;
use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
use crate::render_helpers::renderer::NiriRenderer;
+use crate::render_helpers::texture::TextureBuffer;
use crate::render_helpers::{
render_to_shm, render_to_texture, render_to_vec, shaders, RenderTarget,
};
@@ -1870,7 +1870,7 @@ impl Niri {
let transform = output.current_transform();
let output_mode = output.current_mode().unwrap();
let size = transform.transform_size(output_mode.size);
- let scale = output.current_scale().integer_scale();
+ let scale = output.current_scale().fractional_scale();
// FIXME: scale changes and transform flips shouldn't matter but they currently do since
// I haven't quite figured out how to draw the screenshot textures in
// physical coordinates.
@@ -3898,9 +3898,9 @@ impl Niri {
TextureBuffer::from_texture(
renderer,
texture,
- output.current_scale().integer_scale(),
+ output.current_scale().fractional_scale(),
Transform::Normal,
- None, // We want windows below to get frame callbacks.
+ Vec::new(), // We want windows below to get frame callbacks.
)
});
diff --git a/src/render_helpers/mod.rs b/src/render_helpers/mod.rs
index db2d39d7..dcb51e7c 100644
--- a/src/render_helpers/mod.rs
+++ b/src/render_helpers/mod.rs
@@ -4,7 +4,6 @@ use anyhow::{ensure, Context};
use niri_config::BlockOutFrom;
use smithay::backend::allocator::Fourcc;
use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
-use smithay::backend::renderer::element::texture::{TextureBuffer, TextureRenderElement};
use smithay::backend::renderer::element::utils::{Relocate, RelocateRenderElement};
use smithay::backend::renderer::element::{Kind, RenderElement};
use smithay::backend::renderer::gles::{GlesMapping, GlesRenderer, GlesTexture};
@@ -16,6 +15,7 @@ use smithay::utils::{Logical, Physical, Point, Rectangle, Scale, Size, Transform
use smithay::wayland::shm;
use self::primary_gpu_texture::PrimaryGpuTextureRenderElement;
+use self::texture::{TextureBuffer, TextureRenderElement};
pub mod border;
pub mod clipped_surface;
@@ -31,6 +31,7 @@ pub mod shader_element;
pub mod shaders;
pub mod snapshot;
pub mod surface;
+pub mod texture;
/// What we're rendering for.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -117,16 +118,16 @@ impl ToRenderElement for BakedBuffer<TextureBuffer<GlesTexture>> {
fn to_render_element(
&self,
location: Point<i32, Logical>,
- scale: Scale<f64>,
+ _scale: Scale<f64>,
alpha: f32,
kind: Kind,
) -> Self::RenderElement {
let elem = TextureRenderElement::from_texture_buffer(
- (location + self.location).to_physical_precise_round(scale),
- &self.buffer,
- Some(alpha),
+ self.buffer.clone(),
+ (location + self.location).to_f64(),
+ alpha,
self.src,
- self.dst,
+ self.dst.map(|dst| dst.to_f64()),
kind,
);
PrimaryGpuTextureRenderElement(elem)
diff --git a/src/render_helpers/offscreen.rs b/src/render_helpers/offscreen.rs
index 7c563b9b..a7df69c1 100644
--- a/src/render_helpers/offscreen.rs
+++ b/src/render_helpers/offscreen.rs
@@ -1,6 +1,5 @@
use smithay::backend::allocator::Fourcc;
use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
-use smithay::backend::renderer::element::texture::{TextureBuffer, TextureRenderElement};
use smithay::backend::renderer::element::utils::{Relocate, RelocateRenderElement};
use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer};
@@ -10,6 +9,7 @@ use smithay::utils::{Buffer, Physical, Rectangle, Scale, Transform};
use super::primary_gpu_texture::PrimaryGpuTextureRenderElement;
use super::render_to_texture;
use super::renderer::AsGlesFrame;
+use super::texture::{TextureBuffer, TextureRenderElement};
use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};
/// Renders elements into an off-screen buffer.
@@ -59,12 +59,17 @@ impl OffscreenRenderElement {
elements,
) {
Ok((texture, _sync_point)) => {
- let buffer =
- TextureBuffer::from_texture(renderer, texture, scale, Transform::Normal, None);
+ let buffer = TextureBuffer::from_texture(
+ renderer,
+ texture,
+ scale as f64,
+ Transform::Normal,
+ Vec::new(),
+ );
let element = TextureRenderElement::from_texture_buffer(
- geo.loc.to_f64(),
- &buffer,
- Some(result_alpha),
+ buffer,
+ geo.loc.to_f64().to_logical(scale as f64),
+ result_alpha,
None,
None,
Kind::Unspecified,
diff --git a/src/render_helpers/primary_gpu_texture.rs b/src/render_helpers/primary_gpu_texture.rs
index 54046f59..9f4e38d1 100644
--- a/src/render_helpers/primary_gpu_texture.rs
+++ b/src/render_helpers/primary_gpu_texture.rs
@@ -1,10 +1,10 @@
-use smithay::backend::renderer::element::texture::TextureRenderElement;
use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, GlesTexture};
use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
use smithay::utils::{Buffer, Physical, Rectangle, Scale, Transform};
use super::renderer::AsGlesFrame;
+use super::texture::TextureRenderElement;
use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};
/// Wrapper for a texture from the primary GPU for rendering with the primary GPU.
diff --git a/src/render_helpers/surface.rs b/src/render_helpers/surface.rs
index 21141b30..859be85f 100644
--- a/src/render_helpers/surface.rs
+++ b/src/render_helpers/surface.rs
@@ -1,4 +1,3 @@
-use smithay::backend::renderer::element::texture::TextureBuffer;
use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture};
use smithay::backend::renderer::utils::{import_surface, RendererSurfaceStateUserData};
use smithay::backend::renderer::Renderer as _;
@@ -6,6 +5,7 @@ use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
use smithay::utils::{Logical, Point};
use smithay::wayland::compositor::{with_surface_tree_downward, TraversalAction};
+use super::texture::TextureBuffer;
use super::BakedBuffer;
/// Renders elements from a surface tree as textures into `storage`.
@@ -62,9 +62,9 @@ pub fn render_snapshot_from_surface_tree(
let buffer = TextureBuffer::from_texture(
renderer,
texture.clone(),
- data.buffer_scale(),
+ f64::from(data.buffer_scale()),
data.buffer_transform(),
- None,
+ Vec::new(),
);
let baked = BakedBuffer {
diff --git a/src/render_helpers/texture.rs b/src/render_helpers/texture.rs
new file mode 100644
index 00000000..c1eec367
--- /dev/null
+++ b/src/render_helpers/texture.rs
@@ -0,0 +1,207 @@
+use smithay::backend::allocator::Fourcc;
+use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
+use smithay::backend::renderer::utils::{CommitCounter, OpaqueRegions};
+use smithay::backend::renderer::{Frame as _, ImportMem, Renderer, Texture};
+use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
+
+/// Smithay's texture buffer, but with fractional scale.
+#[derive(Debug, Clone)]
+pub struct TextureBuffer<T> {
+ id: Id,
+ commit_counter: CommitCounter,
+ renderer_id: usize,
+ texture: T,
+ scale: Scale<f64>,
+ transform: Transform,
+ opaque_regions: Vec<Rectangle<i32, Buffer>>,
+}
+
+/// Render element for a [`TextureBuffer`].
+#[derive(Debug)]
+pub struct TextureRenderElement<T> {
+ buffer: TextureBuffer<T>,
+ location: Point<f64, Logical>,
+ alpha: f32,
+ src: Option<Rectangle<f64, Logical>>,
+ size: Option<Size<f64, Logical>>,
+ kind: Kind,
+}
+
+impl<T> TextureBuffer<T> {
+ pub fn from_texture<R: Renderer<TextureId = T>>(
+ renderer: &R,
+ texture: T,
+ scale: impl Into<Scale<f64>>,
+ transform: Transform,
+ opaque_regions: Vec<Rectangle<i32, Buffer>>,
+ ) -> Self {
+ TextureBuffer {
+ id: Id::new(),
+ commit_counter: CommitCounter::default(),
+ renderer_id: renderer.id(),
+ texture,
+ scale: scale.into(),
+ transform,
+ opaque_regions,
+ }
+ }
+
+ #[allow(clippy::too_many_arguments)]
+ pub fn from_memory<R: Renderer<TextureId = T> + ImportMem>(
+ renderer: &mut R,
+ data: &[u8],
+ format: Fourcc,
+ size: impl Into<Size<i32, Buffer>>,
+ flipped: bool,
+ scale: impl Into<Scale<f64>>,
+ transform: Transform,
+ opaque_regions: Vec<Rectangle<i32, Buffer>>,
+ ) -> Result<Self, <R as Renderer>::Error> {
+ let texture = renderer.import_memory(data, format, size.into(), flipped)?;
+ Ok(TextureBuffer::from_texture(
+ renderer,
+ texture,
+ scale,
+ transform,
+ opaque_regions,
+ ))
+ }
+
+ pub fn texture(&self) -> &T {
+ &self.texture
+ }
+
+ pub fn texture_scale(&self) -> Scale<f64> {
+ self.scale
+ }
+}
+
+impl<T: Texture> TextureBuffer<T> {
+ pub fn logical_size(&self) -> Size<f64, Logical> {
+ self.texture
+ .size()
+ .to_f64()
+ .to_logical(self.scale, self.transform)
+ }
+}
+
+impl<T> TextureRenderElement<T> {
+ pub fn from_texture_buffer(
+ buffer: TextureBuffer<T>,
+ location: impl Into<Point<f64, Logical>>,
+ alpha: f32,
+ src: Option<Rectangle<f64, Logical>>,
+ size: Option<Size<f64, Logical>>,
+ kind: Kind,
+ ) -> Self {
+ TextureRenderElement {
+ buffer,
+ location: location.into(),
+ alpha,
+ src,
+ size,
+ kind,
+ }
+ }
+}
+
+impl<T: Texture> TextureRenderElement<T> {
+ pub fn logical_size(&self) -> Size<f64, Logical> {
+ self.size
+ .or_else(|| self.src.map(|src| src.size))
+ .unwrap_or_else(|| self.buffer.logical_size())
+ }
+}
+
+impl<T: Texture> Element for TextureRenderElement<T> {
+ fn id(&self) -> &Id {
+ &self.buffer.id
+ }
+
+ fn current_commit(&self) -> CommitCounter {
+ self.buffer.commit_counter
+ }
+
+ fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
+ let logical_geo = Rectangle::from_loc_and_size(self.location, self.logical_size());
+ logical_geo.to_physical_precise_round(scale)
+ }
+
+ fn transform(&self) -> Transform {
+ self.buffer.transform
+ }
+
+ fn src(&self) -> Rectangle<f64, Buffer> {
+ self.src
+ .map(|src| {
+ src.to_buffer(
+ self.buffer.scale,
+ self.buffer.transform,
+ &self.buffer.logical_size(),
+ )
+ })
+ .unwrap_or_else(|| {
+ Rectangle::from_loc_and_size((0, 0), self.buffer.texture.size()).to_f64()
+ })
+ }
+
+ fn opaque_regions(&self, scale: Scale<f64>) -> OpaqueRegions<i32, Physical> {
+ let texture_size = self.buffer.texture.size().to_f64();
+ let src = self.src();
+
+ self.buffer
+ .opaque_regions
+ .iter()
+ .filter_map(|region| {
+ let mut region = region.to_f64().intersection(src)?;
+
+ region.loc -= src.loc;
+ region.upscale(texture_size / src.size);
+
+ let logical =
+ region.to_logical(self.buffer.scale, self.buffer.transform, &src.size);
+ Some(logical.to_physical_precise_down(scale))
+ })
+ .collect()
+ }
+
+ fn alpha(&self) -> f32 {
+ self.alpha
+ }
+
+ fn kind(&self) -> Kind {
+ self.kind
+ }
+}
+
+impl<R, T> RenderElement<R> for TextureRenderElement<T>
+where
+ R: Renderer<TextureId = T>,
+ T: Texture,
+{
+ fn draw(
+ &self,
+ frame: &mut <R as Renderer>::Frame<'_>,
+ src: Rectangle<f64, Buffer>,
+ dest: Rectangle<i32, Physical>,
+ damage: &[Rectangle<i32, Physical>],
+ ) -> Result<(), <R as Renderer>::Error> {
+ if frame.id() != self.buffer.renderer_id {
+ warn!("trying to render texture from different renderer");
+ return Ok(());
+ }
+
+ frame.render_texture_from_to(
+ &self.buffer.texture,
+ src,
+ dest,
+ damage,
+ self.buffer.transform,
+ self.alpha,
+ )
+ }
+
+ fn underlying_storage(&self, _renderer: &mut R) -> Option<UnderlyingStorage<'_>> {
+ None
+ }
+}
diff --git a/src/ui/screen_transition.rs b/src/ui/screen_transition.rs
index 0bc10c39..ecec1f1e 100644
--- a/src/ui/screen_transition.rs
+++ b/src/ui/screen_transition.rs
@@ -1,10 +1,10 @@
use std::time::Duration;
-use smithay::backend::renderer::element::texture::{TextureBuffer, TextureRenderElement};
use smithay::backend::renderer::element::Kind;
use smithay::backend::renderer::gles::GlesTexture;
use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
+use crate::render_helpers::texture::{TextureBuffer, TextureRenderElement};
use crate::render_helpers::RenderTarget;
pub const DELAY: Duration = Duration::from_millis(250);
@@ -51,9 +51,9 @@ impl ScreenTransition {
};
PrimaryGpuTextureRenderElement(TextureRenderElement::from_texture_buffer(
+ self.from_texture[idx].clone(),
(0., 0.),
- &self.from_texture[idx],
- Some(self.alpha),
+ self.alpha,
None,
None,
Kind::Unspecified,
diff --git a/src/ui/screenshot_ui.rs b/src/ui/screenshot_ui.rs
index 5892fde1..c4b887a3 100644
--- a/src/ui/screenshot_ui.rs
+++ b/src/ui/screenshot_ui.rs
@@ -9,7 +9,6 @@ use niri_config::Action;
use smithay::backend::allocator::Fourcc;
use smithay::backend::input::{ButtonState, MouseButton};
use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
-use smithay::backend::renderer::element::texture::{TextureBuffer, TextureRenderElement};
use smithay::backend::renderer::element::Kind;
use smithay::backend::renderer::gles::{GlesRenderer, GlesTexture};
use smithay::backend::renderer::ExportMem;
@@ -19,6 +18,7 @@ use smithay::utils::{Physical, Point, Rectangle, Size, Transform};
use crate::niri_render_elements;
use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
+use crate::render_helpers::texture::{TextureBuffer, TextureRenderElement};
use crate::render_helpers::RenderTarget;
const BORDER: i32 = 2;
@@ -41,7 +41,7 @@ pub enum ScreenshotUi {
pub struct OutputData {
size: Size<i32, Physical>,
- scale: i32,
+ scale: f64,
transform: Transform,
// Output, screencast, screen capture.
texture: [GlesTexture; 3],
@@ -112,9 +112,15 @@ impl ScreenshotUi {
let transform = output.current_transform();
let output_mode = output.current_mode().unwrap();
let size = transform.transform_size(output_mode.size);
- let scale = output.current_scale().integer_scale();
+ let scale = output.current_scale().fractional_scale();
let texture_buffer = texture.clone().map(|texture| {
- TextureBuffer::from_texture(renderer, texture, scale, Transform::Normal, None)
+ TextureBuffer::from_texture(
+ renderer,
+ texture,
+ scale,
+ Transform::Normal,
+ Vec::new(),
+ )
});
let buffers = [
SolidColorBuffer::new((0, 0), [1., 1., 1., 1.]),
@@ -279,9 +285,9 @@ impl ScreenshotUi {
};
elements.push(
PrimaryGpuTextureRenderElement(TextureRenderElement::from_texture_buffer(
+ output_data.texture_buffer[index].clone(),
(0., 0.),
- &output_data.texture_buffer[index],
- None,
+ 1.,
None,
None,
Kind::Unspecified,
@@ -344,7 +350,7 @@ impl ScreenshotUi {
}
}
- pub fn output_size(&self, output: &Output) -> Option<(Size<i32, Physical>, i32, Transform)> {
+ pub fn output_size(&self, output: &Output) -> Option<(Size<i32, Physical>, f64, Transform)> {
if let Self::Open { output_data, .. } = self {
let data = output_data.get(output)?;
Some((data.size, data.scale, data.transform))
generated by cgit (git 2.34.1) at 2026-02-04 06:57:15 +0000