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
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

use nalgebra::{Scalar, Vector3, Matrix3};


/// Something that could be packed to `i32` buffers
pub trait PackInt {
    /// Size of integer part of an object.
    fn size() -> usize;
    
    /// Write an object into `i32` buffer.
    ///
    /// Buffer *must* be of size greater or equal to object's one.
    fn pack_int_to(&self, buffer: &mut [i32]);
}

/// Something that could be packed to `f32` buffers
pub trait PackFloat {
    /// Size of float part of an object.
    fn size() -> usize;

    /// Write an object into `f32` buffer.
    ///
    /// Buffer *must* be of size greater or equal to object's one.
    fn pack_float_to(&self, buffer: &mut [f32]);
}

/// Something that could be packed to a pair of `i32` and `f32` buffers
pub trait Pack {
    /// Size of integer part of an object.
    fn size_int() -> usize;

    /// Size of float part of an object.
    fn size_float() -> usize;

    /// Write an object into int and float buffers.
    ///
    /// Buffers *must* be of size greater or equal to object's one.
    fn pack_to(&self, buffer_int: &mut [i32], buffer_float: &mut [f32]);
}

pub trait PackerInt {
    fn pack<T: PackInt>(self, t: &T) -> Self;
}
impl<'a> PackerInt for &'a mut [i32] {
    fn pack<T: PackInt>(self, t: &T) -> Self {
        t.pack_int_to(self);
        &mut self[T::size()..]
    }
}

pub trait PackerFloat {
    fn pack<T: PackFloat>(self, t: &T) -> Self;
}
impl<'a> PackerFloat for &'a mut [f32] {
    fn pack<T: PackFloat>(self, t: &T) -> Self {
        t.pack_float_to(self);
        &mut self[T::size()..]
    }
}

pub struct Packer<'a> {
    buffer_int: &'a mut [i32],
    buffer_float: &'a mut [f32],
}
impl<'a> Packer<'a> {
    pub fn new(buffer_int: &'a mut [i32], buffer_float: &'a mut [f32]) -> Self {
        Self { buffer_int, buffer_float }
    }
    pub fn pack<T: Pack>(self, t: &T) -> Self {
        t.pack_to(self.buffer_int, self.buffer_float);
        Self {
            buffer_int: &mut self.buffer_int[T::size_int()..],
            buffer_float: &mut self.buffer_float[T::size_float()..],
        }
    }
}


impl PackInt for i32 {
    fn size() -> usize { 1 }
    fn pack_int_to(&self, buffer: &mut [i32]) {
        buffer[0] = *self;
    }
}
impl Pack for i32 {
    fn size_int() -> usize { 1 }
    fn size_float() -> usize { 0 }
    fn pack_to(&self, buffer_int: &mut [i32], _buffer_float: &mut [f32]) {
        buffer_int[0] = *self;
    }
}
impl PackInt for u32 {
    fn size() -> usize { 1 }
    fn pack_int_to(&self, buffer: &mut [i32]) {
        buffer[0] = *self as i32;
    }
}
impl Pack for u32 {
    fn size_int() -> usize { 1 }
    fn size_float() -> usize { 0 }
    fn pack_to(&self, buffer_int: &mut [i32], _buffer_float: &mut [f32]) {
        buffer_int[0] = *self as i32;
    }
}

impl PackFloat for f32 {
    fn size() -> usize { 1 }
    fn pack_float_to(&self, buffer: &mut [f32]) {
        buffer[0] = *self;
    }
}
impl Pack for f32 {
    fn size_int() -> usize { 0 }
    fn size_float() -> usize { 1 }
    fn pack_to(&self, _buffer_int: &mut [i32], buffer_float: &mut [f32]) {
        buffer_float[0] = *self;
    }
}
impl PackFloat for f64 {
    fn size() -> usize { 1 }
    fn pack_float_to(&self, buffer: &mut [f32]) {
        buffer[0] = *self as f32;
    }
}
impl Pack for f64 {
    fn size_int() -> usize { 0 }
    fn size_float() -> usize { 1 }
    fn pack_to(&self, _buffer_int: &mut [i32], buffer_float: &mut [f32]) {
        buffer_float[0] = *self as f32;
    }
}

impl<T: PackFloat + Scalar> PackFloat for Vector3<T> {
    fn size() -> usize { 3*T::size() }
    fn pack_float_to(&self, mut buffer: &mut [f32]) {
        for x in self.as_slice() {
            buffer = buffer.pack(x);
        }
    }
}
impl<T: Pack + Scalar> Pack for Vector3<T> {
    fn size_int() -> usize { 3*T::size_int() }
    fn size_float() -> usize { 3*T::size_float() }
    fn pack_to(&self, buffer_int: &mut [i32], buffer_float: &mut [f32]) {
        let mut packer = Packer::new(buffer_int, buffer_float);
        for x in self.as_slice() {
            packer = packer.pack(x);
        }
    }
}


impl<T: PackFloat + Scalar> PackFloat for Matrix3<T> {
    fn size() -> usize { 9*T::size() }
    fn pack_float_to(&self, mut buffer: &mut [f32]) {
        for x in self.as_slice() {
            buffer = buffer.pack(x);
        }
    }
}
impl<T: Pack + Scalar> Pack for Matrix3<T> {
    fn size_int() -> usize { 9*T::size_int() }
    fn size_float() -> usize { 9*T::size_float() }
    fn pack_to(&self, buffer_int: &mut [i32], buffer_float: &mut [f32]) {
        let mut packer = Packer::new(buffer_int, buffer_float);
        for x in self.as_slice() {
            packer = packer.pack(x);
        }
    }
}