noises-and-patterns 0.1.1

A procedural creator library for 2D noises and patterns
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

use crate::prelude::*;

pub struct Bricks {
    ratio               : FP,
    brick               : FP,
    cell                : FP,
    gap                 : FP,
    bevel               : FP,
    round               : FP,

}

impl Pattern for Bricks {

    fn new() -> Self {
        Self {
            ratio       : 2.0,
            brick       : 1.0,
            cell        : 16.0,
            gap         : 0.08,
            bevel       : 0.07,
            round       : 0.25,
        }
    }

    fn set_property(&mut self, name: &str, value: FP) {
        if name == "ratio" {
            self.ratio = value;
        } else
        if name == "brick" {
            self.brick = value;
        } else
        if name == "cell" {
            self.cell = value;
        } else
        if name == "gap" {
            self.gap = value;
        } else
        if name == "bevel" {
            self.bevel = value;
        } else
        if name == "round" {
            self.round = value;
        }
    }

    fn pattern_2d(&self, p: (FP, FP)) -> FP {
        let uv = FP2::new(p.0, p.1);

        let mut u = uv;// + FP2::new(10000.0, 10000.0);

        let bevel = FP2::new(self.bevel, self.bevel);
        let gap = FP2::new(self.gap, self.gap);
        let round = self.round;
        //let missing = 0.0;

        let w = FP2::new(self.ratio,1.0);
        u = u.component_mul(&FP2::new(self.cell, self.cell).component_div(&w));

        if self.brick == 1.0 {
            u.x += 0.5 * u.y.floor() % 2.0;
        }

        //hash = hash21(floor(U))

        let t = glm::fract(&u) - FP2::new(1.0, 1.0) / 2.0;
        let s = w.component_mul(&t);

        let a = w / 2.0 - gap - glm::abs(&s);
        let b = a.component_mul(&FP2::new(2.0, 2.0)).component_div(&bevel);
        let mut m = b.x.min(b.y);
        if a.x < round && a.y < round {
           m = (round - glm::length(&(FP2::new(round, round) - a))) * 2.0 / glm::dot(&bevel,&glm::normalize(&(FP2::new(round, round) - a)));
        }

        //if MISSING > missingHash(floor(U)) {
        //    isMissing = true
        //}

        m.clamp(0.0, 1.0)
    }

}