Skip to main content

freya_core/style/
shader.rs

1use std::rc::Rc;
2
3use freya_engine::prelude::*;
4use torin::prelude::Area;
5
6pub trait ShaderProvider {
7    fn prepare_shader(&self, effect: &RuntimeEffect, bounds: Area) -> Option<Shader>;
8}
9
10impl<F> ShaderProvider for F
11where
12    F: Fn(&RuntimeEffect, Area) -> Option<Shader>,
13{
14    fn prepare_shader(&self, effect: &RuntimeEffect, bounds: Area) -> Option<Shader> {
15        self(effect, bounds)
16    }
17}
18
19/// A custom paint source backed by an SkSL shader.
20///
21/// Build it with [`ShaderFill::new`], passing the SkSL source, a compiled
22/// [`RuntimeEffect`] and a provider closure that supplies the shader's uniforms
23/// for a given bounds. Use it as a [`Fill`](crate::style::fill::Fill) for
24/// backgrounds or text.
25#[derive(Clone)]
26pub struct ShaderFill {
27    sksl: Rc<str>,
28    effect: Rc<RuntimeEffect>,
29    provider: Rc<dyn ShaderProvider>,
30}
31
32impl ShaderFill {
33    pub fn new<F>(sksl: impl Into<Rc<str>>, effect: RuntimeEffect, provider: F) -> Self
34    where
35        F: Fn(&RuntimeEffect, Area) -> Option<Shader> + 'static,
36    {
37        Self::from_provider(sksl, effect, provider)
38    }
39
40    pub fn from_provider<S>(sksl: impl Into<Rc<str>>, effect: RuntimeEffect, provider: S) -> Self
41    where
42        S: ShaderProvider + 'static,
43    {
44        Self {
45            sksl: sksl.into(),
46            effect: Rc::new(effect),
47            provider: Rc::new(provider),
48        }
49    }
50
51    /// Prepare the shader for use by providing the necessary uniforms.
52    /// Returns [None] if the provider could not produce a [Shader], in which case the renderer will fallback to no fill.
53    pub fn prepare_shader(&self, bounds: Area) -> Option<Shader> {
54        self.provider.prepare_shader(&self.effect, bounds)
55    }
56}
57
58impl std::fmt::Display for ShaderFill {
59    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
60        write!(f, "shader({:p})", Rc::as_ptr(&self.provider))
61    }
62}
63
64impl std::fmt::Debug for ShaderFill {
65    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
66        f.debug_struct("FillShader")
67            .field("sksl", &self.sksl)
68            .finish()
69    }
70}
71
72impl PartialEq for ShaderFill {
73    fn eq(&self, other: &Self) -> bool {
74        *self.sksl == *other.sksl
75            && Rc::ptr_eq(&self.effect, &other.effect)
76            && Rc::ptr_eq(&self.provider, &other.provider)
77    }
78}
79
80impl std::hash::Hash for ShaderFill {
81    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
82        (*self.sksl).hash(state);
83        Rc::as_ptr(&self.effect).hash(state);
84        Rc::as_ptr(&self.provider).hash(state);
85    }
86}
87
88#[cfg(feature = "serde")]
89impl serde::Serialize for ShaderFill {
90    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
91    where
92        S: serde::Serializer,
93    {
94        serializer.serialize_str(&self.sksl)
95    }
96}
97
98#[cfg(feature = "serde")]
99impl<'de> serde::Deserialize<'de> for ShaderFill {
100    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
101    where
102        D: serde::Deserializer<'de>,
103    {
104        let sksl = String::deserialize(deserializer)?;
105        let effect =
106            RuntimeEffect::make_for_shader(&sksl, None).map_err(serde::de::Error::custom)?;
107
108        Ok(Self {
109            sksl: sksl.into(),
110            effect: Rc::new(effect),
111            provider: Rc::new(|_: &RuntimeEffect, _: Area| None),
112        })
113    }
114}