aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/backend/tty.rs3
-rw-r--r--src/backend/winit.rs10
-rw-r--r--src/layout/focus_ring.rs101
-rw-r--r--src/layout/tile.rs22
-rw-r--r--src/layout/workspace.rs2
-rw-r--r--src/render_helpers/gradient.rs143
-rw-r--r--src/render_helpers/mod.rs3
-rw-r--r--src/render_helpers/primary_gpu_pixel_shader.rs97
-rw-r--r--src/render_helpers/shaders/gradient_border.frag46
-rw-r--r--src/render_helpers/shaders/mod.rs47
10 files changed, 441 insertions, 33 deletions
diff --git a/src/backend/tty.rs b/src/backend/tty.rs
index a0a50dd1..1f0cdb16 100644
--- a/src/backend/tty.rs
+++ b/src/backend/tty.rs
@@ -53,6 +53,7 @@ use super::RenderResult;
use crate::frame_clock::FrameClock;
use crate::niri::{Niri, RedrawState, State};
use crate::render_helpers::renderer::AsGlesRenderer;
+use crate::render_helpers::shaders;
use crate::utils::get_monotonic_time;
const SUPPORTED_COLOR_FORMATS: &[Fourcc] = &[Fourcc::Argb8888, Fourcc::Abgr8888];
@@ -443,6 +444,8 @@ impl Tty {
renderer.bind_wl_display(&niri.display_handle)?;
+ shaders::init(renderer.as_gles_renderer());
+
// Create the dmabuf global.
let primary_formats = renderer.dmabuf_formats().collect::<HashSet<_>>();
let default_feedback =
diff --git a/src/backend/winit.rs b/src/backend/winit.rs
index 7f35e153..e9413698 100644
--- a/src/backend/winit.rs
+++ b/src/backend/winit.rs
@@ -19,6 +19,7 @@ use smithay::reexports::winit::window::WindowBuilder;
use super::RenderResult;
use crate::niri::{Niri, RedrawState, State};
+use crate::render_helpers::shaders;
use crate::utils::get_monotonic_time;
pub struct Winit {
@@ -123,14 +124,13 @@ impl Winit {
}
pub fn init(&mut self, niri: &mut Niri) {
- if let Err(err) = self
- .backend
- .renderer()
- .bind_wl_display(&niri.display_handle)
- {
+ let renderer = self.backend.renderer();
+ if let Err(err) = renderer.bind_wl_display(&niri.display_handle) {
warn!("error binding renderer wl_display: {err}");
}
+ shaders::init(renderer);
+
niri.add_output(self.output.clone(), None);
}
diff --git a/src/layout/focus_ring.rs b/src/layout/focus_ring.rs
index 0addd204..24013510 100644
--- a/src/layout/focus_ring.rs
+++ b/src/layout/focus_ring.rs
@@ -1,26 +1,41 @@
use std::iter::zip;
use arrayvec::ArrayVec;
-use niri_config;
+use niri_config::{self, GradientRelativeTo};
use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
use smithay::backend::renderer::element::Kind;
-use smithay::utils::{Logical, Point, Scale, Size};
+use smithay::utils::{Logical, Point, Rectangle, Scale, Size};
+
+use crate::niri_render_elements;
+use crate::render_helpers::gradient::GradientRenderElement;
+use crate::render_helpers::renderer::NiriRenderer;
#[derive(Debug)]
pub struct FocusRing {
buffers: [SolidColorBuffer; 4],
locations: [Point<i32, Logical>; 4],
+ sizes: [Size<i32, Logical>; 4],
+ full_size: Size<i32, Logical>,
+ is_active: bool,
is_border: bool,
config: niri_config::FocusRing,
}
-pub type FocusRingRenderElement = SolidColorRenderElement;
+niri_render_elements! {
+ FocusRingRenderElement => {
+ SolidColor = SolidColorRenderElement,
+ Gradient = GradientRenderElement,
+ }
+}
impl FocusRing {
pub fn new(config: niri_config::FocusRing) -> Self {
Self {
buffers: Default::default(),
locations: Default::default(),
+ sizes: Default::default(),
+ full_size: Default::default(),
+ is_active: false,
is_border: false,
config,
}
@@ -32,20 +47,25 @@ impl FocusRing {
pub fn update(&mut self, win_size: Size<i32, Logical>, is_border: bool) {
let width = i32::from(self.config.width);
+ self.full_size = win_size + Size::from((width * 2, width * 2));
if is_border {
- self.buffers[0].resize((win_size.w + width * 2, width));
- self.buffers[1].resize((win_size.w + width * 2, width));
- self.buffers[2].resize((width, win_size.h));
- self.buffers[3].resize((width, win_size.h));
+ self.sizes[0] = Size::from((win_size.w + width * 2, width));
+ self.sizes[1] = Size::from((win_size.w + width * 2, width));
+ self.sizes[2] = Size::from((width, win_size.h));
+ self.sizes[3] = Size::from((width, win_size.h));
+
+ for (buf, size) in zip(&mut self.buffers, self.sizes) {
+ buf.resize(size);
+ }
self.locations[0] = Point::from((-width, -width));
self.locations[1] = Point::from((-width, win_size.h));
self.locations[2] = Point::from((-width, 0));
self.locations[3] = Point::from((win_size.w, 0));
} else {
- let size = win_size + Size::from((width * 2, width * 2));
- self.buffers[0].resize(size);
+ self.sizes[0] = self.full_size;
+ self.buffers[0].resize(self.sizes[0]);
self.locations[0] = Point::from((-width, -width));
}
@@ -62,12 +82,16 @@ impl FocusRing {
for buf in &mut self.buffers {
buf.set_color(color);
}
+
+ self.is_active = is_active;
}
- pub fn render(
+ pub fn render<R: NiriRenderer>(
&self,
+ renderer: &mut R,
location: Point<i32, Logical>,
scale: Scale<f64>,
+ view_size: Size<i32, Logical>,
) -> impl Iterator<Item = FocusRingRenderElement> {
let mut rv = ArrayVec::<_, 4>::new();
@@ -75,23 +99,56 @@ impl FocusRing {
return rv.into_iter();
}
- let mut push = |buffer, location: Point<i32, Logical>| {
- let elem = SolidColorRenderElement::from_buffer(
- buffer,
- location.to_physical_precise_round(scale),
- scale,
- 1.,
- Kind::Unspecified,
- );
- rv.push(elem.into());
+ let gradient = if self.is_active {
+ self.config.active_gradient
+ } else {
+ self.config.inactive_gradient
+ };
+
+ let full_rect = Rectangle::from_loc_and_size(location + self.locations[0], self.full_size);
+ let view_rect = Rectangle::from_loc_and_size((0, 0), view_size);
+
+ let mut push = |buffer, location: Point<i32, Logical>, size: Size<i32, Logical>| {
+ let elem = gradient.and_then(|gradient| {
+ let gradient_area = match gradient.relative_to {
+ GradientRelativeTo::Window => full_rect,
+ GradientRelativeTo::WorkspaceView => view_rect,
+ };
+ GradientRenderElement::new(
+ renderer,
+ scale,
+ Rectangle::from_loc_and_size(location, size),
+ gradient_area,
+ gradient.from.into(),
+ gradient.to.into(),
+ ((gradient.angle as f32) - 90.).to_radians(),
+ )
+ .map(Into::into)
+ });
+
+ let elem = elem.unwrap_or_else(|| {
+ SolidColorRenderElement::from_buffer(
+ buffer,
+ location.to_physical_precise_round(scale),
+ scale,
+ 1.,
+ Kind::Unspecified,
+ )
+ .into()
+ });
+ rv.push(elem);
};
if self.is_border {
- for (buf, loc) in zip(&self.buffers, self.locations) {
- push(buf, location + loc);
+ for (buf, (loc, size)) in zip(&self.buffers, zip(self.locations, self.sizes)) {
+ push(buf, location + loc, size);
}
} else {
- push(&self.buffers[0], location + self.locations[0]);
+ push(
+ &self.buffers[0],
+ location + self.locations[0],
+ self.sizes[0],
+ );
}
rv.into_iter()
diff --git a/src/layout/tile.rs b/src/layout/tile.rs
index 28bcfb47..ca2779fe 100644
--- a/src/layout/tile.rs
+++ b/src/layout/tile.rs
@@ -7,7 +7,7 @@ use smithay::backend::renderer::element::utils::RescaleRenderElement;
use smithay::backend::renderer::element::{Element, Kind};
use smithay::utils::{Logical, Point, Rectangle, Scale, Size};
-use super::focus_ring::FocusRing;
+use super::focus_ring::{FocusRing, FocusRingRenderElement};
use super::{LayoutElement, LayoutElementRenderElement, Options};
use crate::animation::Animation;
use crate::niri_render_elements;
@@ -51,6 +51,7 @@ pub struct Tile<W: LayoutElement> {
niri_render_elements! {
TileRenderElement<R> => {
LayoutElement = LayoutElementRenderElement<R>,
+ FocusRing = FocusRingRenderElement,
SolidColor = SolidColorRenderElement,
Offscreen = RescaleRenderElement<OffscreenRenderElement>,
}
@@ -297,6 +298,7 @@ impl<W: LayoutElement> Tile<W> {
renderer: &mut R,
location: Point<i32, Logical>,
scale: Scale<f64>,
+ view_size: Size<i32, Logical>,
focus_ring: bool,
) -> impl Iterator<Item = TileRenderElement<R>> {
let rv = self
@@ -307,12 +309,21 @@ impl<W: LayoutElement> Tile<W> {
let elem = self.effective_border_width().map(|width| {
self.border
- .render(location + Point::from((width, width)), scale)
+ .render(
+ renderer,
+ location + Point::from((width, width)),
+ scale,
+ view_size,
+ )
.map(Into::into)
});
let rv = rv.chain(elem.into_iter().flatten());
- let elem = focus_ring.then(|| self.focus_ring.render(location, scale).map(Into::into));
+ let elem = focus_ring.then(|| {
+ self.focus_ring
+ .render(renderer, location, scale, view_size)
+ .map(Into::into)
+ });
let rv = rv.chain(elem.into_iter().flatten());
let elem = self.is_fullscreen.then(|| {
@@ -333,11 +344,12 @@ impl<W: LayoutElement> Tile<W> {
renderer: &mut R,
location: Point<i32, Logical>,
scale: Scale<f64>,
+ view_size: Size<i32, Logical>,
focus_ring: bool,
) -> impl Iterator<Item = TileRenderElement<R>> {
if let Some(anim) = &self.open_animation {
let renderer = renderer.as_gles_renderer();
- let elements = self.render_inner(renderer, location, scale, focus_ring);
+ let elements = self.render_inner(renderer, location, scale, view_size, focus_ring);
let elements = elements.collect::<Vec<TileRenderElement<_>>>();
let elem = OffscreenRenderElement::new(
@@ -365,7 +377,7 @@ impl<W: LayoutElement> Tile<W> {
} else {
self.window().set_offscreen_element_id(None);
- let elements = self.render_inner(renderer, location, scale, focus_ring);
+ let elements = self.render_inner(renderer, location, scale, view_size, focus_ring);
None.into_iter().chain(Some(elements).into_iter().flatten())
}
}
diff --git a/src/layout/workspace.rs b/src/layout/workspace.rs
index 5e872340..b9016098 100644
--- a/src/layout/workspace.rs
+++ b/src/layout/workspace.rs
@@ -1188,7 +1188,7 @@ impl<W: LayoutElement> Workspace<W> {
first = false;
rv.extend(
- tile.render(renderer, tile_pos, output_scale, focus_ring)
+ tile.render(renderer, tile_pos, output_scale, self.view_size, focus_ring)
.map(Into::into),
);
}
diff --git a/src/render_helpers/gradient.rs b/src/render_helpers/gradient.rs
new file mode 100644
index 00000000..1dbed05a
--- /dev/null
+++ b/src/render_helpers/gradient.rs
@@ -0,0 +1,143 @@
+use std::f32::consts::{self, FRAC_PI_2, PI};
+
+use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
+use smithay::backend::renderer::gles::element::PixelShaderElement;
+use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer, Uniform};
+use smithay::backend::renderer::utils::CommitCounter;
+use smithay::utils::{Buffer, Logical, Physical, Rectangle, Scale, Transform};
+
+use super::primary_gpu_pixel_shader::PrimaryGpuPixelShaderRenderElement;
+use super::renderer::NiriRenderer;
+use super::shaders::Shaders;
+use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};
+
+/// Renders a sub- or super-rect of an angled linear gradient like CSS linear-gradient(angle, a, b).
+#[derive(Debug)]
+pub struct GradientRenderElement(PrimaryGpuPixelShaderRenderElement);
+
+impl GradientRenderElement {
+ pub fn new(
+ renderer: &mut impl NiriRenderer,
+ scale: Scale<f64>,
+ area: Rectangle<i32, Logical>,
+ gradient_area: Rectangle<i32, Logical>,
+ color_from: [f32; 4],
+ color_to: [f32; 4],
+ mut angle: f32,
+ ) -> Option<Self> {
+ let shader = Shaders::get(renderer).gradient_border.clone()?;
+ let g_offset = (area.loc - gradient_area.loc).to_f64().to_physical(scale);
+
+ let g_size = gradient_area.size.to_f64().to_physical(scale);
+ let (w, h) = (g_size.w as f32, g_size.h as f32);
+ let g_area_angle = f32::atan2(h, w);
+ let g_area_diag = f32::hypot(h, w);
+
+ // Normalize the angle to [0°; 360°).
+ while angle < 0. {
+ angle += consts::TAU;
+ }
+ while angle >= consts::TAU {
+ angle -= consts::TAU;
+ }
+
+ let angle_diag_to_grad =
+ if (0. ..=FRAC_PI_2).contains(&angle) || (PI..=PI + FRAC_PI_2).contains(&angle) {
+ angle - g_area_angle
+ } else {
+ (PI - angle) - g_area_angle
+ };
+ let g_total = angle_diag_to_grad.cos().abs() * g_area_diag;
+
+ let elem = PixelShaderElement::new(
+ shader,
+ area,
+ None,
+ 1.,
+ vec![
+ Uniform::new("color_from", color_from),
+ Uniform::new("color_to", color_to),
+ Uniform::new("angle", angle),
+ Uniform::new("gradient_offset", (g_offset.x as f32, g_offset.y as f32)),
+ Uniform::new("gradient_width", w),
+ Uniform::new("gradient_total", g_total),
+ ],
+ Kind::Unspecified,
+ );
+ Some(Self(PrimaryGpuPixelShaderRenderElement(elem)))
+ }
+}
+
+impl Element for GradientRenderElement {
+ fn id(&self) -> &Id {
+ self.0.id()
+ }
+
+ fn current_commit(&self) -> CommitCounter {
+ self.0.current_commit()
+ }
+
+ fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
+ self.0.geometry(scale)
+ }
+
+ fn transform(&self) -> Transform {
+ self.0.transform()
+ }
+
+ fn src(&self) -> Rectangle<f64, Buffer> {
+ self.0.src()
+ }
+
+ fn damage_since(
+ &self,
+ scale: Scale<f64>,
+ commit: Option<CommitCounter>,
+ ) -> Vec<Rectangle<i32, Physical>> {
+ self.0.damage_since(scale, commit)
+ }
+
+ fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
+ self.0.opaque_regions(scale)
+ }
+
+ fn alpha(&self) -> f32 {
+ self.0.alpha()
+ }
+
+ fn kind(&self) -> Kind {
+ self.0.kind()
+ }
+}
+
+impl RenderElement<GlesRenderer> for GradientRenderElement {
+ fn draw(
+ &self,
+ frame: &mut GlesFrame<'_>,
+ src: Rectangle<f64, Buffer>,
+ dst: Rectangle<i32, Physical>,
+ damage: &[Rectangle<i32, Physical>],
+ ) -> Result<(), GlesError> {
+ RenderElement::<GlesRenderer>::draw(&self.0, frame, src, dst, damage)
+ }
+
+ fn underlying_storage(&self, renderer: &mut GlesRenderer) -> Option<UnderlyingStorage> {
+ self.0.underlying_storage(renderer)
+ }
+}
+
+impl<'render> RenderElement<TtyRenderer<'render>> for GradientRenderElement {
+ fn draw(
+ &self,
+ frame: &mut TtyFrame<'_, '_>,
+ src: Rectangle<f64, Buffer>,
+ dst: Rectangle<i32, Physical>,
+ damage: &[Rectangle<i32, Physical>],
+ ) -> Result<(), TtyRendererError<'render>> {
+ RenderElement::<TtyRenderer<'_>>::draw(&self.0, frame, src, dst, damage)
+ }
+
+ fn underlying_storage(&self, renderer: &mut TtyRenderer<'render>) -> Option<UnderlyingStorage> {
+ self.0.underlying_storage(renderer)
+ }
+}
diff --git a/src/render_helpers/mod.rs b/src/render_helpers/mod.rs
index c05877f9..7d7ea9c1 100644
--- a/src/render_helpers/mod.rs
+++ b/src/render_helpers/mod.rs
@@ -6,10 +6,13 @@ use smithay::backend::renderer::sync::SyncPoint;
use smithay::backend::renderer::{Bind, ExportMem, Frame, Offscreen, Renderer};
use smithay::utils::{Physical, Rectangle, Scale, Size, Transform};
+pub mod gradient;
pub mod offscreen;
+pub mod primary_gpu_pixel_shader;
pub mod primary_gpu_texture;
pub mod render_elements;
pub mod renderer;
+pub mod shaders;
pub fn render_to_texture(
renderer: &mut GlesRenderer,
diff --git a/src/render_helpers/primary_gpu_pixel_shader.rs b/src/render_helpers/primary_gpu_pixel_shader.rs
new file mode 100644
index 00000000..b3b75023
--- /dev/null
+++ b/src/render_helpers/primary_gpu_pixel_shader.rs
@@ -0,0 +1,97 @@
+use smithay::backend::renderer::element::{Element, Id, Kind, RenderElement, UnderlyingStorage};
+use smithay::backend::renderer::gles::element::PixelShaderElement;
+use smithay::backend::renderer::gles::{GlesError, GlesFrame, GlesRenderer};
+use smithay::backend::renderer::utils::CommitCounter;
+use smithay::utils::{Buffer, Physical, Rectangle, Scale, Transform};
+
+use super::renderer::AsGlesFrame;
+use crate::backend::tty::{TtyFrame, TtyRenderer, TtyRendererError};
+
+/// Wrapper for a poxel shader from the primary GPU for rendering with the primary GPU.
+#[derive(Debug)]
+pub struct PrimaryGpuPixelShaderRenderElement(pub PixelShaderElement);
+
+impl Element for PrimaryGpuPixelShaderRenderElement {
+ fn id(&self) -> &Id {
+ self.0.id()
+ }
+
+ fn current_commit(&self) -> CommitCounter {
+ self.0.current_commit()
+ }
+
+ fn geometry(&self, scale: Scale<f64>) -> Rectangle<i32, Physical> {
+ self.0.geometry(scale)
+ }
+
+ fn transform(&self) -> Transform {
+ self.0.transform()
+ }
+
+ fn src(&self) -> Rectangle<f64, Buffer> {
+ self.0.src()
+ }
+
+ fn damage_since(
+ &self,
+ scale: Scale<f64>,
+ commit: Option<CommitCounter>,
+ ) -> Vec<Rectangle<i32, Physical>> {
+ self.0.damage_since(scale, commit)
+ }
+
+ fn opaque_regions(&self, scale: Scale<f64>) -> Vec<Rectangle<i32, Physical>> {
+ self.0.opaque_regions(scale)
+ }
+
+ fn alpha(&self) -> f32 {
+ self.0.alpha()
+ }
+
+ fn kind(&self) -> Kind {
+ self.0.kind()
+ }
+}
+
+impl RenderElement<GlesRenderer> for PrimaryGpuPixelShaderRenderElement {
+ fn draw(
+ &self,
+ frame: &mut GlesFrame<'_>,
+ src: Rectangle<f64, Buffer>,
+ dst: Rectangle<i32, Physical>,
+ damage: &[Rectangle<i32, Physical>],
+ ) -> Result<(), GlesError> {
+ let gles_frame = frame.as_gles_frame();
+ RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage)?;
+ Ok(())
+ }
+
+ fn underlying_storage(&self, _renderer: &mut GlesRenderer) -> Option<UnderlyingStorage> {
+ // If scanout for things other than Wayland buffers is implemented, this will need to take
+ // the target GPU into account.
+ None
+ }
+}
+
+impl<'render> RenderElement<TtyRenderer<'render>> for PrimaryGpuPixelShaderRenderElement {
+ fn draw(
+ &self,
+ frame: &mut TtyFrame<'_, '_>,
+ src: Rectangle<f64, Buffer>,
+ dst: Rectangle<i32, Physical>,
+ damage: &[Rectangle<i32, Physical>],
+ ) -> Result<(), TtyRendererError<'render>> {
+ let gles_frame = frame.as_gles_frame();
+ RenderElement::<GlesRenderer>::draw(&self.0, gles_frame, src, dst, damage)?;
+ Ok(())
+ }
+
+ fn underlying_storage(
+ &self,
+ _renderer: &mut TtyRenderer<'render>,
+ ) -> Option<UnderlyingStorage> {
+ // If scanout for things other than Wayland buffers is implemented, this will need to take
+ // the target GPU into account.
+ None
+ }
+}
diff --git a/src/render_helpers/shaders/gradient_border.frag b/src/render_helpers/shaders/gradient_border.frag
new file mode 100644
index 00000000..354968cf
--- /dev/null
+++ b/src/render_helpers/shaders/gradient_border.frag
@@ -0,0 +1,46 @@
+precision mediump float;
+uniform float alpha;
+#if defined(DEBUG_FLAGS)
+uniform float tint;
+#endif
+uniform vec2 size;
+varying vec2 v_coords;
+
+uniform vec4 color_from;
+uniform vec4 color_to;
+uniform float angle;
+uniform vec2 gradient_offset;
+uniform float gradient_width;
+uniform float gradient_total;
+
+#define FRAC_PI_2 1.57079632679
+#define PI 3.14159265359
+#define FRAC_3_PI_2 4.71238898038
+#define TAU 6.28318530718
+
+void main() {
+ vec2 coords = v_coords * size + gradient_offset;
+
+ if ((FRAC_PI_2 <= angle && angle < PI) || (FRAC_3_PI_2 <= angle && angle < TAU))
+ coords.x -= gradient_width;
+
+ float frag_angle = FRAC_PI_2;
+ if (coords.x != 0.0)
+ frag_angle = atan(coords.y, coords.x);
+
+ float angle_frag_to_grad = frag_angle - angle;
+
+ float frac = cos(angle_frag_to_grad) * length(coords) / gradient_total;
+ if (PI <= angle)
+ frac += 1.0;
+ frac = clamp(frac, 0.0, 1.0);
+
+ vec4 out_color = mix(color_from, color_to, frac);
+
+#if defined(DEBUG_FLAGS)
+ if (tint == 1.0)
+ out_color = vec4(0.0, 0.3, 0.0, 0.2) + out_color * 0.8;
+#endif
+
+ gl_FragColor = out_color;
+}
diff --git a/src/render_helpers/shaders/mod.rs b/src/render_helpers/shaders/mod.rs
new file mode 100644
index 00000000..72e9fa1c
--- /dev/null
+++ b/src/render_helpers/shaders/mod.rs
@@ -0,0 +1,47 @@
+use smithay::backend::renderer::gles::{GlesPixelProgram, GlesRenderer, UniformName, UniformType};
+
+use super::renderer::NiriRenderer;
+
+pub struct Shaders {
+ pub gradient_border: Option<GlesPixelProgram>,
+}
+
+impl Shaders {
+ fn compile(renderer: &mut GlesRenderer) -> Self {
+ let _span = tracy_client::span!("Shaders::compile");
+
+ let gradient_border = renderer
+ .compile_custom_pixel_shader(
+ include_str!("gradient_border.frag"),
+ &[
+ UniformName::new("color_from", UniformType::_4f),
+ UniformName::new("color_to", UniformType::_4f),
+ UniformName::new("angle", UniformType::_1f),
+ UniformName::new("gradient_offset", UniformType::_2f),
+ UniformName::new("gradient_width", UniformType::_1f),
+ UniformName::new("gradient_total", UniformType::_1f),
+ ],
+ )
+ .map_err(|err| {
+ warn!("error compiling gradient border shader: {err:?}");
+ })
+ .ok();
+
+ Self { gradient_border }
+ }
+
+ pub fn get(renderer: &mut impl NiriRenderer) -> &Self {
+ let renderer = renderer.as_gles_renderer();
+ let data = renderer.egl_context().user_data();
+ data.get()
+ .expect("shaders::init() must be called when creating the renderer")
+ }
+}
+
+pub fn init(renderer: &mut GlesRenderer) {
+ let shaders = Shaders::compile(renderer);
+ let data = renderer.egl_context().user_data();
+ if !data.insert_if_missing(|| shaders) {
+ error!("shaders were already compiled");
+ }
+}
generated by cgit (git 2.34.1) at 2026-02-05 01:16:51 +0000