Skip to main content

plottery_runtime/project_params/
param_field.rs

1use std::collections::HashMap;
2
3pub use anyhow::Error as ParamFieldError;
4use plottery_lib::{
5    Angle, BundledFont, ColorRgb, Easing, NoiseSettings, Paper, Range, SystemFont, V2i, V2,
6};
7
8use super::angle_unit::AngleUnit;
9
10use super::curve_2d::Curve2D;
11use super::curve_2d_norm::Curve2DNorm;
12use super::image_path::ImagePath;
13use super::project_param::ProjectParam;
14use super::project_param_file::ProjectParamFile;
15use super::project_param_optional::ProjectParamOptional;
16use super::project_param_value::ProjectParamValue;
17use super::project_param_vec::ProjectParamVec;
18use super::seed::{ProjectParamSeed, Seed};
19use super::svg_path::SvgPath;
20
21/// A type that can be used as a field of a `#[derive(PlotteryParams)]` struct.
22pub trait ParamField: Sized {
23    fn default_param_value() -> ProjectParamValue;
24    fn to_param_value(&self) -> ProjectParamValue;
25    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError>;
26}
27
28/// A [`ParamField`] that accepts `#[range(min, max)]`.
29pub trait RangedParamField: ParamField {
30    type Bound: Copy;
31    fn default_ranged_param_value(min: Self::Bound, max: Self::Bound) -> ProjectParamValue;
32    /// Clamps `self` into `min..=max`.
33    fn to_ranged_param_value(&self, min: Self::Bound, max: Self::Bound) -> ProjectParamValue;
34}
35
36pub fn param_type_mismatch(expected: &str, found: &ProjectParamValue) -> ParamFieldError {
37    anyhow::anyhow!(
38        "Expected param of type '{}' but found '{}'",
39        expected,
40        found.type_name()
41    )
42}
43
44/// Looks up `name` in `params` and converts it. Used by the generated `try_new_from_map`.
45pub fn param_field_from_map<T: ParamField>(
46    params: &HashMap<String, ProjectParam>,
47    name: &str,
48) -> Result<T, ParamFieldError> {
49    let param = params
50        .get(name)
51        .ok_or_else(|| anyhow::anyhow!("Field '{}' is missing in params.", name))?;
52    T::from_param_value(&param.value).map_err(|e| e.context(format!("field '{}'", name)))
53}
54
55impl ParamField for f32 {
56    fn default_param_value() -> ProjectParamValue {
57        ProjectParamValue::Float(0.0)
58    }
59    fn to_param_value(&self) -> ProjectParamValue {
60        ProjectParamValue::Float(*self)
61    }
62    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
63        value.get_f32()
64    }
65}
66
67impl RangedParamField for f32 {
68    type Bound = f32;
69    fn default_ranged_param_value(min: f32, max: f32) -> ProjectParamValue {
70        0.0f32.to_ranged_param_value(min, max)
71    }
72    fn to_ranged_param_value(&self, min: f32, max: f32) -> ProjectParamValue {
73        ProjectParamValue::FloatRanged {
74            val: self.clamp(min, max),
75            min,
76            max,
77        }
78    }
79}
80
81impl ParamField for i32 {
82    fn default_param_value() -> ProjectParamValue {
83        ProjectParamValue::Int(0)
84    }
85    fn to_param_value(&self) -> ProjectParamValue {
86        ProjectParamValue::Int(*self)
87    }
88    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
89        value.get_i32()
90    }
91}
92
93impl RangedParamField for i32 {
94    type Bound = i32;
95    fn default_ranged_param_value(min: i32, max: i32) -> ProjectParamValue {
96        0i32.to_ranged_param_value(min, max)
97    }
98    fn to_ranged_param_value(&self, min: i32, max: i32) -> ProjectParamValue {
99        ProjectParamValue::IntRanged {
100            val: (*self).clamp(min, max),
101            min,
102            max,
103        }
104    }
105}
106
107impl ParamField for bool {
108    fn default_param_value() -> ProjectParamValue {
109        ProjectParamValue::Bool(false)
110    }
111    fn to_param_value(&self) -> ProjectParamValue {
112        ProjectParamValue::Bool(*self)
113    }
114    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
115        value.get_bool()
116    }
117}
118
119impl ParamField for String {
120    fn default_param_value() -> ProjectParamValue {
121        ProjectParamValue::String(String::new())
122    }
123    fn to_param_value(&self) -> ProjectParamValue {
124        ProjectParamValue::String(self.clone())
125    }
126    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
127        match value {
128            ProjectParamValue::String(val) => Ok(val.clone()),
129            other => Err(param_type_mismatch("string", other)),
130        }
131    }
132}
133
134impl ParamField for Paper {
135    fn default_param_value() -> ProjectParamValue {
136        ProjectParamValue::Paper(Self::default())
137    }
138    fn to_param_value(&self) -> ProjectParamValue {
139        ProjectParamValue::Paper(*self)
140    }
141    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
142        match value {
143            ProjectParamValue::Paper(paper) => Ok(*paper),
144            other => Err(param_type_mismatch("paper", other)),
145        }
146    }
147}
148
149impl ParamField for Range<f32> {
150    fn default_param_value() -> ProjectParamValue {
151        Self::default().to_param_value()
152    }
153    fn to_param_value(&self) -> ProjectParamValue {
154        ProjectParamValue::RangeF32 {
155            min: self.min,
156            max: self.max,
157            bounds: None,
158        }
159    }
160    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
161        match value {
162            ProjectParamValue::RangeF32 { min, max, .. } => Ok(Range::new(*min, *max)),
163            other => Err(param_type_mismatch("range<f32>", other)),
164        }
165    }
166}
167
168impl RangedParamField for Range<f32> {
169    type Bound = f32;
170    fn default_ranged_param_value(lo: f32, hi: f32) -> ProjectParamValue {
171        Range::new(lo, hi).to_ranged_param_value(lo, hi)
172    }
173    fn to_ranged_param_value(&self, lo: f32, hi: f32) -> ProjectParamValue {
174        ProjectParamValue::RangeF32 {
175            min: self.min.clamp(lo, hi),
176            max: self.max.clamp(lo, hi),
177            bounds: Some((lo, hi)),
178        }
179    }
180}
181
182impl ParamField for Range<i32> {
183    fn default_param_value() -> ProjectParamValue {
184        Self::default().to_param_value()
185    }
186    fn to_param_value(&self) -> ProjectParamValue {
187        ProjectParamValue::RangeI32 {
188            min: self.min,
189            max: self.max,
190            bounds: None,
191        }
192    }
193    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
194        match value {
195            ProjectParamValue::RangeI32 { min, max, .. } => Ok(Range::new(*min, *max)),
196            other => Err(param_type_mismatch("range<i32>", other)),
197        }
198    }
199}
200
201impl RangedParamField for Range<i32> {
202    type Bound = i32;
203    fn default_ranged_param_value(lo: i32, hi: i32) -> ProjectParamValue {
204        Range::new(lo, hi).to_ranged_param_value(lo, hi)
205    }
206    fn to_ranged_param_value(&self, lo: i32, hi: i32) -> ProjectParamValue {
207        ProjectParamValue::RangeI32 {
208            min: self.min.clamp(lo, hi),
209            max: self.max.clamp(lo, hi),
210            bounds: Some((lo, hi)),
211        }
212    }
213}
214
215impl ParamField for Angle {
216    fn default_param_value() -> ProjectParamValue {
217        Angle::zero().to_param_value()
218    }
219    fn to_param_value(&self) -> ProjectParamValue {
220        ProjectParamValue::Angle {
221            rad: self.to_rad(),
222            unit: AngleUnit::default(),
223        }
224    }
225    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
226        match value {
227            ProjectParamValue::Angle { rad, .. } => Ok(Angle::from_rad(*rad)),
228            other => Err(param_type_mismatch("angle", other)),
229        }
230    }
231}
232
233impl ParamField for V2 {
234    fn default_param_value() -> ProjectParamValue {
235        ProjectParamValue::V2(V2::zero())
236    }
237    fn to_param_value(&self) -> ProjectParamValue {
238        ProjectParamValue::V2(*self)
239    }
240    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
241        match value {
242            ProjectParamValue::V2(v) => Ok(*v),
243            other => Err(param_type_mismatch("v2", other)),
244        }
245    }
246}
247
248impl ParamField for Seed {
249    fn default_param_value() -> ProjectParamValue {
250        Self::default().to_param_value()
251    }
252    fn to_param_value(&self) -> ProjectParamValue {
253        ProjectParamValue::Seed(ProjectParamSeed::new(self.value))
254    }
255    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
256        match value {
257            ProjectParamValue::Seed(seed) => Ok(Seed::new(seed.current)),
258            other => Err(param_type_mismatch("seed", other)),
259        }
260    }
261}
262
263impl ParamField for ImagePath {
264    fn default_param_value() -> ProjectParamValue {
265        ProjectParamValue::Image(ProjectParamFile::default())
266    }
267    fn to_param_value(&self) -> ProjectParamValue {
268        ProjectParamValue::Image(ProjectParamFile::new(self.path.clone()))
269    }
270    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
271        match value {
272            ProjectParamValue::Image(image) => Ok(ImagePath {
273                path: image.path.clone(),
274            }),
275            other => Err(param_type_mismatch("image", other)),
276        }
277    }
278}
279
280impl ParamField for SvgPath {
281    fn default_param_value() -> ProjectParamValue {
282        ProjectParamValue::Svg(ProjectParamFile::default())
283    }
284    fn to_param_value(&self) -> ProjectParamValue {
285        ProjectParamValue::Svg(ProjectParamFile::new(self.path.clone()))
286    }
287    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
288        match value {
289            ProjectParamValue::Svg(svg) => Ok(SvgPath {
290                path: svg.path.clone(),
291            }),
292            other => Err(param_type_mismatch("svg", other)),
293        }
294    }
295}
296
297impl ParamField for NoiseSettings {
298    fn default_param_value() -> ProjectParamValue {
299        ProjectParamValue::Noise(Self::default())
300    }
301    fn to_param_value(&self) -> ProjectParamValue {
302        ProjectParamValue::Noise(*self)
303    }
304    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
305        match value {
306            ProjectParamValue::Noise(noise) => Ok(*noise),
307            other => Err(param_type_mismatch("noise", other)),
308        }
309    }
310}
311
312impl ParamField for Easing {
313    fn default_param_value() -> ProjectParamValue {
314        ProjectParamValue::Easing(Self::default())
315    }
316    fn to_param_value(&self) -> ProjectParamValue {
317        ProjectParamValue::Easing(*self)
318    }
319    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
320        match value {
321            ProjectParamValue::Easing(easing) => Ok(*easing),
322            other => Err(param_type_mismatch("easing", other)),
323        }
324    }
325}
326
327impl ParamField for ColorRgb {
328    fn default_param_value() -> ProjectParamValue {
329        ProjectParamValue::Color(ColorRgb::black())
330    }
331    fn to_param_value(&self) -> ProjectParamValue {
332        ProjectParamValue::Color(*self)
333    }
334    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
335        match value {
336            ProjectParamValue::Color(color) => Ok(*color),
337            other => Err(param_type_mismatch("color", other)),
338        }
339    }
340}
341
342impl ParamField for V2i {
343    fn default_param_value() -> ProjectParamValue {
344        ProjectParamValue::V2i(V2i::default())
345    }
346    fn to_param_value(&self) -> ProjectParamValue {
347        ProjectParamValue::V2i(*self)
348    }
349    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
350        match value {
351            ProjectParamValue::V2i(v) => Ok(*v),
352            other => Err(param_type_mismatch("v2i", other)),
353        }
354    }
355}
356
357impl ParamField for BundledFont {
358    fn default_param_value() -> ProjectParamValue {
359        BundledFont::EmsReadability.to_param_value()
360    }
361    fn to_param_value(&self) -> ProjectParamValue {
362        ProjectParamValue::Font(self.name().to_string())
363    }
364    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
365        match value {
366            ProjectParamValue::Font(name) => BundledFont::from_name(name)
367                .ok_or_else(|| anyhow::anyhow!("unknown bundled font '{}'", name)),
368            other => Err(param_type_mismatch("font", other)),
369        }
370    }
371}
372
373impl ParamField for SystemFont {
374    fn default_param_value() -> ProjectParamValue {
375        ProjectParamValue::SystemFont(Self::default())
376    }
377    fn to_param_value(&self) -> ProjectParamValue {
378        ProjectParamValue::SystemFont(self.clone())
379    }
380    // Not checked against the installed fonts: params have to load on a machine without the font.
381    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
382        match value {
383            ProjectParamValue::SystemFont(font) => Ok(font.clone()),
384            other => Err(param_type_mismatch("system_font", other)),
385        }
386    }
387}
388
389impl ParamField for Curve2DNorm {
390    fn default_param_value() -> ProjectParamValue {
391        ProjectParamValue::Curve2DNorm(Self::default())
392    }
393    fn to_param_value(&self) -> ProjectParamValue {
394        ProjectParamValue::Curve2DNorm(self.clone())
395    }
396    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
397        match value {
398            ProjectParamValue::Curve2DNorm(curve) => Ok(curve.clone()),
399            other => Err(param_type_mismatch("curve2d_norm", other)),
400        }
401    }
402}
403
404impl ParamField for Curve2D {
405    fn default_param_value() -> ProjectParamValue {
406        ProjectParamValue::Curve2D(Self::default())
407    }
408    fn to_param_value(&self) -> ProjectParamValue {
409        ProjectParamValue::Curve2D(self.clone())
410    }
411    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
412        match value {
413            ProjectParamValue::Curve2D(curve) => Ok(curve.clone()),
414            other => Err(param_type_mismatch("curve2d", other)),
415        }
416    }
417}
418
419impl<T: ParamField> ParamField for Option<T> {
420    fn default_param_value() -> ProjectParamValue {
421        ProjectParamValue::Optional(ProjectParamOptional::new(false, T::default_param_value()))
422    }
423    fn to_param_value(&self) -> ProjectParamValue {
424        let (enabled, inner) = match self {
425            Some(value) => (true, value.to_param_value()),
426            None => (false, T::default_param_value()),
427        };
428        ProjectParamValue::Optional(ProjectParamOptional::new(enabled, inner))
429    }
430    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
431        match value {
432            ProjectParamValue::Optional(optional) if optional.enabled => {
433                T::from_param_value(&optional.value).map(Some)
434            }
435            ProjectParamValue::Optional(_) => Ok(None),
436            other => Err(param_type_mismatch("option", other)),
437        }
438    }
439}
440
441impl<T: RangedParamField> RangedParamField for Option<T> {
442    type Bound = T::Bound;
443    fn default_ranged_param_value(min: T::Bound, max: T::Bound) -> ProjectParamValue {
444        ProjectParamValue::Optional(ProjectParamOptional::new(
445            false,
446            T::default_ranged_param_value(min, max),
447        ))
448    }
449    fn to_ranged_param_value(&self, min: T::Bound, max: T::Bound) -> ProjectParamValue {
450        let (enabled, inner) = match self {
451            Some(value) => (true, value.to_ranged_param_value(min, max)),
452            None => (false, T::default_ranged_param_value(min, max)),
453        };
454        ProjectParamValue::Optional(ProjectParamOptional::new(enabled, inner))
455    }
456}
457
458impl<T: ParamField> ParamField for Vec<T> {
459    fn default_param_value() -> ProjectParamValue {
460        ProjectParamValue::Vec(ProjectParamVec::new(T::default_param_value(), vec![]))
461    }
462    fn to_param_value(&self) -> ProjectParamValue {
463        ProjectParamValue::Vec(ProjectParamVec::new(
464            T::default_param_value(),
465            self.iter().map(T::to_param_value).collect(),
466        ))
467    }
468    fn from_param_value(value: &ProjectParamValue) -> Result<Self, ParamFieldError> {
469        match value {
470            ProjectParamValue::Vec(vec_value) => {
471                vec_value.items.iter().map(T::from_param_value).collect()
472            }
473            other => Err(param_type_mismatch("vec", other)),
474        }
475    }
476}