Move shader get out of ResizeRenderElement::new

src/layout/tile.rs

@@ -20,7 +20,6 @@ use crate::render_helpers::offscreen::OffscreenRenderElement;
 use crate::render_helpers::primary_gpu_texture::PrimaryGpuTextureRenderElement;
 use crate::render_helpers::renderer::NiriRenderer;
 use crate::render_helpers::resize::ResizeRenderElement;
-use crate::render_helpers::shaders::Shaders;
 use crate::render_helpers::snapshot::RenderSnapshot;
 use crate::render_helpers::{render_to_encompassing_texture, RenderTarget, ToRenderElement};
 
@@ -552,7 +551,7 @@ impl<W: LayoutElement> Tile<W> {
         let mut resize_fallback = None;
 
         if let Some(resize) = &self.resize_animation {
-            if Shaders::get(gles_renderer).resize().is_some() {
+            if let Some(shader) = ResizeRenderElement::shader(gles_renderer) {
                 if let Some(texture_from) = resize.snapshot.texture(gles_renderer, scale, target) {
                     let window_elements =
                         self.window
@@ -569,7 +568,7 @@ impl<W: LayoutElement> Tile<W> {
 
                     if let Some((texture_current, _sync_point, texture_current_geo)) = current {
                         let elem = ResizeRenderElement::new(
-                            gles_renderer,
+                            shader,
                             area,
                             scale,
                             texture_from.clone(),
@@ -579,8 +578,7 @@ impl<W: LayoutElement> Tile<W> {
                             resize.anim.value() as f32,
                             resize.anim.clamped_value().clamp(0., 1.) as f32,
                             alpha,
-                        )
+                        );
-                        .expect("we checked the resize shader above");
                         self.window
                             .set_offscreen_element_id(Some(elem.id().clone()));
                         resize_shader = Some(elem.into());

src/render_helpers/resize.rs

@@ -6,8 +6,10 @@ use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, GlesT
 use smithay::backend::renderer::utils::{CommitCounter, DamageSet};
 use smithay::utils::{Buffer, Logical, Physical, Rectangle, Scale, Size, Transform};
 
-use super::primary_gpu_pixel_shader_with_textures::PrimaryGpuPixelShaderWithTexturesRenderElement;
+use super::primary_gpu_pixel_shader_with_textures::{
-use super::renderer::AsGlesFrame;
+    PixelWithTexturesProgram, PrimaryGpuPixelShaderWithTexturesRenderElement,
+};
+use super::renderer::{AsGlesFrame, NiriRenderer};
 use super::shaders::{mat3_uniform, Shaders};
 use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};
 
@@ -17,7 +19,7 @@ pub struct ResizeRenderElement(PrimaryGpuPixelShaderWithTexturesRenderElement);
 impl ResizeRenderElement {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
-        renderer: &mut GlesRenderer,
+        shader: PixelWithTexturesProgram,
         area: Rectangle<i32, Logical>,
         scale: Scale<f64>,
         texture_prev: (GlesTexture, Rectangle<i32, Physical>),
@@ -27,7 +29,7 @@ impl ResizeRenderElement {
         progress: f32,
         clamped_progress: f32,
         result_alpha: f32,
-    ) -> Option<Self> {
+    ) -> Self {
         let curr_geo = area;
 
         let (texture_prev, tex_prev_geo) = texture_prev;
@@ -84,30 +86,32 @@ impl ResizeRenderElement {
         let curr_geo_size = curr_geo_size * scale;
 
         // Create the shader.
-        Shaders::get(renderer).resize().map(|shader| {
+        Self(PrimaryGpuPixelShaderWithTexturesRenderElement::new(
-            Self(PrimaryGpuPixelShaderWithTexturesRenderElement::new(
+            shader,
-                shader,
+            HashMap::from([
-                HashMap::from([
+                (String::from("niri_tex_prev"), texture_prev),
-                    (String::from("niri_tex_prev"), texture_prev),
+                (String::from("niri_tex_next"), texture_next),
-                    (String::from("niri_tex_next"), texture_next),
+            ]),
-                ]),
+            area,
-                area,
+            size,
-                size,
+            None,
-                None,
+            result_alpha,
-                result_alpha,
+            vec![
-                vec![
+                mat3_uniform("niri_input_to_curr_geo", input_to_curr_geo),
-                    mat3_uniform("niri_input_to_curr_geo", input_to_curr_geo),
+                mat3_uniform("niri_curr_geo_to_prev_geo", curr_geo_to_prev_geo),
-                    mat3_uniform("niri_curr_geo_to_prev_geo", curr_geo_to_prev_geo),
+                mat3_uniform("niri_curr_geo_to_next_geo", curr_geo_to_next_geo),
-                    mat3_uniform("niri_curr_geo_to_next_geo", curr_geo_to_next_geo),
+                Uniform::new("niri_curr_geo_size", curr_geo_size.to_array()),
-                    Uniform::new("niri_curr_geo_size", curr_geo_size.to_array()),
+                mat3_uniform("niri_geo_to_tex_prev", geo_to_tex_prev),
-                    mat3_uniform("niri_geo_to_tex_prev", geo_to_tex_prev),
+                mat3_uniform("niri_geo_to_tex_next", geo_to_tex_next),
-                    mat3_uniform("niri_geo_to_tex_next", geo_to_tex_next),
+                Uniform::new("niri_progress", progress),
-                    Uniform::new("niri_progress", progress),
+                Uniform::new("niri_clamped_progress", clamped_progress),
-                    Uniform::new("niri_clamped_progress", clamped_progress),
+            ],
-                ],
+            Kind::Unspecified,
-                Kind::Unspecified,
+        ))
-            ))
+    }
-        })
+
+    pub fn shader(renderer: &mut impl NiriRenderer) -> Option<PixelWithTexturesProgram> {
+        Shaders::get(renderer).resize()
     }
 }