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
21pub 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
28pub trait RangedParamField: ParamField {
30 type Bound: Copy;
31 fn default_ranged_param_value(min: Self::Bound, max: Self::Bound) -> ProjectParamValue;
32 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
44pub 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(¶m.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 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}