noises_and_patterns/pattern/
bricks.rs

1use crate::prelude::*;
2
3pub struct Bricks {
4    ratio               : FP,
5    brick               : FP,
6    cell                : FP,
7    gap                 : FP,
8    bevel               : FP,
9    round               : FP,
10}
11
12impl Pattern for Bricks {
13
14    fn new() -> Self {
15
16
17
18        Self {
19            ratio       : 2.0,
20            brick       : 1.0,
21            cell        : 16.0,
22            gap         : 0.08,
23            bevel       : 0.07,
24            round       : 0.25,
25        }
26    }
27
28    fn set_property(&mut self, name: &str, value: FP) {
29        if name == "ratio" {
30            self.ratio = value;
31        } else
32        if name == "brick" {
33            self.brick = value;
34        } else
35        if name == "cell" {
36            self.cell = value;
37        } else
38        if name == "gap" {
39            self.gap = value;
40        } else
41        if name == "bevel" {
42            self.bevel = value;
43        } else
44        if name == "round" {
45            self.round = value;
46        }
47    }
48
49    fn pattern_2d(&self, p: (FP, FP)) -> (FP, FP) {
50        let uv = FP2::new(p.0, p.1);
51
52        let mut u = uv + FP2::new(10000.0, 10000.0);
53
54        let bevel = FP2::new(self.bevel, self.bevel);
55        let gap = FP2::new(self.gap, self.gap);
56        let round = self.round;
57
58        let w = FP2::new(self.ratio,1.0);
59        u = u.component_mul(&FP2::new(self.cell, self.cell).component_div(&w));
60
61        if self.brick == 1.0 {
62            u.x += 0.5 * u.y.floor() % 2.0;
63        }
64
65        let t = glm::fract(&u) - FP2::new(1.0, 1.0) / 2.0;
66        let s = w.component_mul(&t);
67
68        let a = w / 2.0 - gap - glm::abs(&s);
69        let b = a.component_mul(&FP2::new(2.0, 2.0)).component_div(&bevel);
70        let mut m = b.x.min(b.y);
71        if a.x < round && a.y < round {
72           m = (round - glm::length(&(FP2::new(round, round) - a))) * 2.0 / glm::dot(&bevel,&glm::normalize(&(FP2::new(round, round) - a)));
73        }
74
75        (m.clamp(0.0, 1.0), self.hash21(glm::floor(&u)))
76    }
77
78}