From 3c63be6261f3420008366b41b3df6d57b3ec3867 Mon Sep 17 00:00:00 2001 From: Ivan Molodetskikh Date: Sat, 1 Jun 2024 12:27:30 +0300 Subject: Implement our own TextureBuffer/RenderElement Supports fractional texture scale + has some getters. --- src/layout/closing_window.rs | 69 +++++++++++++++++++++----------------------- src/layout/mod.rs | 2 +- src/layout/opening_window.rs | 19 +++++------- 3 files changed, 42 insertions(+), 48 deletions(-) (limited to 'src/layout') 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, /// Blocked-out contents of the window. - blocked_out_texture: GlesTexture, - - /// Scale that the textures was rendered with. - texture_scale: Scale, - - /// ID of the textures' renderer. - texture_renderer_id: usize, + blocked_out_buffer: TextureBuffer, /// Where the window should be blocked out from. block_out_from: Option, @@ -46,10 +40,10 @@ pub struct ClosingWindow { pos: Point, /// How much the texture should be offset. - texture_offset: Point, + buffer_offset: Point, /// How much the blocked-out texture should be offset. - blocked_out_texture_offset: Point, + blocked_out_buffer_offset: Point, /// 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, -- cgit