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

use crate::{Float, Vec2, Vec3};
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
pub struct Random {
    pub state: u32,
}

impl Random {
    pub fn new(seed: u32) -> Self {
        let state = if seed != 0 {
            seed
        } else {
            42
        };
        Self { state }
    }

    pub fn next(&mut self) {
        self.state ^= self.state << 13;
        self.state ^= self.state >> 17;
        self.state ^= self.state << 5;
    }

    pub fn in_01<T: Float>(&mut self) -> T {
        self.next();
        T::from(self.state as f32) / T::from(4294967296.0)
    }

    pub fn in_range<T: Float>(&mut self, min: T, max: T) -> T {
        min + (max - min) * self.in_01()
    }

    pub fn probability<T: Float>(&mut self, probability: T) -> bool {
        self.in_01::<T>() < probability
    }

    pub fn in_sphere<T: Float>(&mut self) -> Vec3<T> {
        loop {
            let v = Vec3 {
                x: self.in_range(-T::ONE, T::ONE), 
                y: self.in_range(-T::ONE, T::ONE),
                z: self.in_range(-T::ONE, T::ONE),
            };
            if v.len2() < T::ONE {
                return v;
            }
        }
    }

    pub fn in_hemisphere<T: Float>(&mut self, normal: Vec3<T>) -> Vec3<T> {
        let in_sphere = self.in_sphere();
        if in_sphere.dot(normal) > T::ZERO {
            in_sphere
        } else {
            -in_sphere
        }
    }

    pub fn in_disk<T: Float>(&mut self) -> Vec2<T> {
        loop {
            let v = Vec2 {
                x: self.in_range(-T::ONE, T::ONE), 
                y: self.in_range(-T::ONE, T::ONE), 
            };
            if v.len2() < T::ONE {
                return v;
            }
        }
    }
}