alchemyst 0.52.0

Alchemyst PCG tool based on Intuicio scripting platform
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

use image::*;
use intuicio_core::{IntuicioStruct, registry::Registry};
use intuicio_derive::*;
use intuicio_frontend_simpleton::{Array, Real, Reference};

#[derive(IntuicioStruct, Default, Clone)]
#[intuicio(name = "Color", module_name = "color", override_send = true)]
pub struct Color {
    pub r: Reference,
    pub g: Reference,
    pub b: Reference,
    pub a: Reference,
}

#[intuicio_methods(module_name = "color")]
impl Color {
    pub fn from_pixel(pixel: &Rgba<f32>, registry: &Registry) -> Self {
        Self {
            r: Reference::new_real(pixel.0[0] as f64, registry),
            g: Reference::new_real(pixel.0[1] as f64, registry),
            b: Reference::new_real(pixel.0[2] as f64, registry),
            a: Reference::new_real(pixel.0[3] as f64, registry),
        }
    }

    pub fn to_pixel(&self) -> Rgba<f32> {
        Rgba([
            *self.r.read::<Real>().unwrap() as f32,
            *self.g.read::<Real>().unwrap() as f32,
            *self.b.read::<Real>().unwrap() as f32,
            *self.a.read::<Real>().unwrap() as f32,
        ])
    }

    #[intuicio_method(use_registry)]
    pub fn from_array(registry: &Registry, value: Reference) -> Reference {
        let value = value.read::<Array>().unwrap();
        Reference::new(
            Color {
                r: value[0].clone(),
                g: value[1].clone(),
                b: value[2].clone(),
                a: value[3].clone(),
            },
            registry,
        )
    }

    #[intuicio_method(use_registry)]
    pub fn to_array(registry: &Registry, value: Reference) -> Reference {
        let value = value.read::<Color>().unwrap();
        Reference::new_array(
            vec![
                value.r.clone(),
                value.g.clone(),
                value.b.clone(),
                value.a.clone(),
            ],
            registry,
        )
    }
}

pub fn install(registry: &mut Registry) {
    registry.add_type(Color::define_struct(registry));
    registry.add_function(Color::from_array__define_function(registry));
    registry.add_function(Color::to_array__define_function(registry));
}