clay-core 0.1.3

Core functionality for Clay - fast, modular and extendable ray tracer
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

use std::collections::HashSet;
use crate::{prelude::*, map::{Map, MapClass}};

/// Subsequently chains two mappins together.
pub struct Chain<F: Map, S: Map> {
    pub first: F,
    pub second: S,
}

impl<F: Map, S: Map> Chain<F, S> {
    pub fn new(first: F, second: S) -> Self {
        Self { first, second }
    }
}

impl<F: Map, S: Map> Map for Chain<F, S> {}

impl<F: Map, S: Map> Instance<MapClass> for Chain<F, S> {
    fn source(cache: &mut HashSet<u64>) -> String {
        if !cache.insert(Self::type_hash()) {
            return String::new()
        }
        [
            F::source(cache),
            S::source(cache),
            "#include <clay_core/map/chain.h>".to_string(),
            format!(
                "MAP_CHAIN({}, {}, {}, {}, {})",
                Self::inst_name(),
                F::inst_name(),
                S::inst_name(),
                F::size_int(),
                F::size_float(),
            ),
        ].join("\n")
    }
    fn inst_name() -> String {
        format!(
            "__{}_{}_{:x}",
            F::inst_name(),
            S::inst_name(),
            Self::type_hash(),
        )
    }
}

impl<F: Map, S: Map> Pack for Chain<F, S> {
    fn size_int() -> usize {
        F::size_int() + S::size_int()
    }
    fn size_float() -> usize {
        F::size_float() + S::size_float()
    }
    fn pack_to(&self, buffer_int: &mut [i32], buffer_float: &mut [f32]) {
        Packer::new(buffer_int, buffer_float)
        .pack(&self.first)
        .pack(&self.second);
    }
}