organicomplex 0.7.0

Interactive complex-valued cellular automaton on 2D and 3D grids in search of that stuff - emergence, open-endedness, organicity etc.
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

use crate::{
    base::RGB,
    sys::System
};

pub struct Precalc {
    pub reim_to_huelum_rgb: Vec<Vec<RGB>>,
    pub reim_to_hue_rgb: Vec<Vec<RGB>>,
    pub reim_to_lum_rgb: Vec<Vec<RGB>>
}

impl Precalc {
    pub fn init(_sys: &System) -> Result<Self, String> {
        let mut reim_to_huelum_rgb: Vec<Vec<RGB>> = Vec::new();
        let mut reim_to_hue_rgb: Vec<Vec<RGB>> = Vec::new();
        let mut reim_to_lum_rgb: Vec<Vec<RGB>> = Vec::new();

        (-0x200isize..0x200).for_each(|re| {
		    let re = (re as f64) / (0x200 as f64);
            let mut row_huelum: Vec<RGB> = Vec::new();
            let mut row_hue: Vec<RGB> = Vec::new();
            let mut row_lum: Vec<RGB> = Vec::new();
		    (-0x200isize..0x200).for_each(|im| {
                let im = (im as f64) / (0x200) as f64;
                let lum = (re * re + im * im).sqrt().min(1.0) * 255.0;
                row_lum.push(RGB{r: lum as u8, g: lum as u8, b: lum as u8});
                let hue = 6.0 * (im.atan2(re) + 2.0 * std::f64::consts::PI).rem_euclid(2.0 * std::f64::consts::PI) / (2.0 * std::f64::consts::PI);
                let (red, green, blue) = if hue <= 1.0 {
                    (1.0, hue, 0.0)
                } else if hue <= 2.0 {
                    (2.0 - hue, 1.0, 0.0)
                } else if hue <= 3.0 {
                    (0.0, 1.0, hue - 2.0)
                } else if hue <= 4.0 {
                    (0.0, 4.0 - hue, 1.0)
                } else if hue <= 5.0 {
                    (hue - 4.0, 0.0, 1.0)
                } else {
                    (1.0, 0.0, 6.0 - hue)
                };
                row_hue.push(RGB{r: (red * 255.0) as u8, g: (green * 255.0) as u8, b: (blue * 255.0) as u8});
                row_huelum.push(RGB{r: (red * lum) as u8, g: (green * lum) as u8, b: (blue * lum) as u8});
            });
            reim_to_huelum_rgb.push(row_huelum);
            reim_to_hue_rgb.push(row_hue);
            reim_to_lum_rgb.push(row_lum);
        });

        Ok(Self{reim_to_huelum_rgb, reim_to_hue_rgb, reim_to_lum_rgb})
    }

}