bs-trace 0.3.0

Free RayTracing software
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
84
85
86
87
88
89

use itertools::Itertools;
use rand::{Rng, RngCore};

pub trait SamplingStrategy: Send + Sync {
    fn get_sample_positions(
        &self,
        rng: &mut Box<dyn RngCore>,
        x: usize,
        y: usize,
    ) -> Vec<(f64, f64)>;
}

pub struct SingleSampling<const W: usize, const H: usize>;
pub struct SubdivisionSampling<const W: usize, const H: usize, const NUM_SUBDIVS: usize>;
pub struct RandomSampling<const W: usize, const H: usize, const NUM_SAMPLES: usize> {}

impl<const W: usize, const H: usize> SingleSampling<W, H> {
    pub const fn new() -> Self {
        SingleSampling {}
    }
}

impl<const W: usize, const H: usize> SamplingStrategy for SingleSampling<W, H> {
    fn get_sample_positions(
        &self,
        rng: &mut Box<dyn RngCore>,
        x: usize,
        y: usize,
    ) -> Vec<(f64, f64)> {
        vec![(x as f64 / W as f64, y as f64 / H as f64)]
    }
}

impl<const W: usize, const H: usize, const NUM_SUBDIVS: usize>
    SubdivisionSampling<W, H, NUM_SUBDIVS>
{
    pub const fn new() -> Self {
        SubdivisionSampling {}
    }
}

impl<const W: usize, const H: usize, const NUM_SUBDIVS: usize> SamplingStrategy
    for SubdivisionSampling<W, H, NUM_SUBDIVS>
{
    fn get_sample_positions(
        &self,
        rng: &mut Box<dyn RngCore>,
        x: usize,
        y: usize,
    ) -> Vec<(f64, f64)> {
        (0..NUM_SUBDIVS)
            .cartesian_product(0..NUM_SUBDIVS)
            .map(|(x_adj, y_adj)| {
                (
                    (x_adj as f64 + 0.5) / NUM_SUBDIVS as f64,
                    (y_adj as f64 + 0.5) / NUM_SUBDIVS as f64,
                )
            })
            .map(|(x_adj, y_adj)| ((x_adj + x as f64) / W as f64, (y_adj + y as f64) / H as f64))
            .collect()
    }
}

impl<const W: usize, const H: usize, const NUM_SAMPLES: usize> RandomSampling<W, H, NUM_SAMPLES> {
    pub const fn new() -> Self {
        RandomSampling {}
    }
}

impl<const W: usize, const H: usize, const NUM_SAMPLES: usize> SamplingStrategy
    for RandomSampling<W, H, NUM_SAMPLES>
{
    fn get_sample_positions(
        &self,
        rng: &mut Box<dyn RngCore>,
        x: usize,
        y: usize,
    ) -> Vec<(f64, f64)> {
        (0..NUM_SAMPLES)
            .map(|_| {
                let x_adj: f64 = rng.gen_range(0.0..1.0);
                let y_adj: f64 = rng.gen_range(0.0..1.0);
                let x = x as f64 + x_adj;
                let y = y as f64 + y_adj;
                (x / W as f64, y / H as f64)
            })
            .collect()
    }
}