ffgl-core 0.2.6

FFGL plugin framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use std::path::Iter;

use super::{info::ParamInfo, info::ParamValue, info::SimpleParamInfo};

///Handle the info for a collection of parameters. Allows for nested parameters.
pub trait ParamInfoHandler {
    fn num_params(&self) -> usize;
    fn param_info(&self, index: usize) -> &dyn ParamInfo;
}
///Handle collection of parameter values. Allows for nested parameters.
///
/// Maybe theres some way to just use a Index and IndexMut implementation for this instead?
pub trait ParamValueHandler {
    fn get_param(&self, index: usize) -> f32;
    fn set_param(&mut self, index: usize, value: f32);
}

impl<T> ParamValueHandler for [T]
where
    T: ParamValueHandler + ParamInfoHandler,
{
    fn get_param(&self, index: usize) -> f32 {
        let mut index = index;
        for p in self.iter() {
            if index < p.num_params() {
                return p.get_param(index);
            }
            index -= p.num_params();
        }
        panic!("Index out of bounds");
    }

    fn set_param(&mut self, index: usize, value: f32) {
        let mut index = index;
        for p in self.iter_mut() {
            if index < p.num_params() {
                p.set_param(index, value);
                return;
            }
            index -= p.num_params();
        }
        panic!("Index out of bounds");
    }
}

impl<T> ParamInfoHandler for [T]
where
    T: ParamInfoHandler,
{
    fn num_params(&self) -> usize {
        self.iter().map(|p| p.num_params()).sum()
    }

    fn param_info(&self, index: usize) -> &dyn ParamInfo {
        let mut index = index;
        for p in self.iter() {
            if index < p.num_params() {
                return p.param_info(index);
            }
            index -= p.num_params();
        }
        panic!("Index out of bounds");
    }
}

impl<T: ParamInfo> ParamInfoHandler for T {
    fn num_params(&self) -> usize {
        1
    }

    fn param_info(&self, index: usize) -> &dyn ParamInfo {
        self
    }
}

impl<T: ParamValue> ParamValueHandler for T {
    fn get_param(&self, index: usize) -> f32 {
        self.get()
    }

    fn set_param(&mut self, index: usize, value: f32) {
        self.set(value)
    }
}