lambent 0.1.0

A ray / path tracer built on wgpu.
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

use crate::Descriptor;
use cgmath::{Matrix4, SquareMatrix, Vector4};
use wgpu::util::BufferInitDescriptor;
use wgpu::BufferUsages;

#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
pub struct Camera {
    pub projection_inverse: [[f32; 4]; 4],
    pub view_inverse: [[f32; 4]; 4],
}

impl Camera {
    /// creates a camera from normal (not inverted) projection and view matrices
    pub fn from_proj_view(proj: [[f32; 4]; 4], view: [[f32; 4]; 4]) -> Result<Camera, CameraError> {
        let projection_inverse: [[f32; 4]; 4] =
            invert_matrix(proj).ok_or(CameraError::ProjectionUninvertable(proj))?;
        let view_inverse: [[f32; 4]; 4] =
            invert_matrix(view).ok_or(CameraError::ViewUninvertable(view))?;
        Ok(Camera {
            projection_inverse,
            view_inverse,
        })
    }
    /// updates a camera from normal (not inverted) projection and view matrices, either can be optional
    /// e.g. only changing fov
    pub fn update_from_proj_view(
        &mut self,
        proj: Option<[[f32; 4]; 4]>,
        view: Option<[[f32; 4]; 4]>,
    ) -> Result<(), CameraError> {
        if let Some(proj) = proj {
            self.projection_inverse =
                invert_matrix(proj).ok_or(CameraError::ProjectionUninvertable(proj))?;
        }
        if let Some(view) = view {
            self.view_inverse = invert_matrix(view).ok_or(CameraError::ViewUninvertable(view))?;
        }
        Ok(())
    }
}

impl Descriptor for Camera {
    fn buffer_descriptor(&self) -> BufferInitDescriptor<'_> {
        BufferInitDescriptor {
            label: Some("Camera"),
            contents: bytemuck::bytes_of(self),
            usage: BufferUsages::UNIFORM,
        }
    }
}

#[derive(Debug)]
pub enum CameraError {
    ProjectionUninvertable([[f32; 4]; 4]),
    ViewUninvertable([[f32; 4]; 4]),
}

fn invert_matrix(mat: [[f32; 4]; 4]) -> Option<[[f32; 4]; 4]> {
    Some(
        Matrix4::from_cols(
            Vector4::from(mat[0]),
            Vector4::from(mat[1]),
            Vector4::from(mat[2]),
            Vector4::from(mat[3]),
        )
        .invert()?
        .into(),
    )
}