lumo 0.3.2

CPU based rendering engine
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

use crate::{
    rand_utils, Axis, efloat::{self, EFloat},
    Point, Normal, Direction, Float,
    Vec3, Vec2, Transform, Mat3
};
use crate::tracer::{
    hit::Hit, material::Material,
    onb::Onb, ray::Ray
};
use std::sync::Arc;

pub use aabb::AaBoundingBox;
pub use cone::Cone;
pub use cube::Cube;
pub use cylinder::Cylinder;
pub use disk::Disk;
pub use instance::{Instance, Instanceable};
pub use kdtree::{KdTree, Mesh};
pub use medium::Medium;
pub use plane::Plane;
pub use rectangle::Rectangle;
pub use sphere::Sphere;
pub use triangle::Triangle;
pub use triangle_mesh::{TriangleMesh, Face};

/// Axis aligned bounding boxes
mod aabb;
/// Defines cones
mod cone;
/// Defines a unit cube. Transform to desired shape with instances.
mod cube;
/// Defines y axis aligned cylinders
mod cylinder;
/// Defines disks
mod disk;
/// Instance of an object i.e. an object to wich Euclidean (+ scaling)
/// transformations have been applied to.
mod instance;
/// kD-trees, used for complex meshes
mod kdtree;
/// Volumetric mediums
mod medium;
/// Defines infinite planes
mod plane;
/// Defines rectangles. Built from two triangles.
mod rectangle;
/// Defines spheres.
mod sphere;
/// Defines triangles.
mod triangle;
/// Triangle meshes, stores vertices, normals and texture coordinates to save space
mod triangle_mesh;

/// Common functionality shared between all objects.
pub trait Object: Sync {
    /// Does the ray hit the object? NOTE: ray direction can be unnormalized
    /// for instanced objects. Is this an issue?
    fn hit(&self, r: &Ray, t_min: Float, t_max: Float) -> Option<Hit>;
}

/// Objects that can be contained within an AABB
pub trait Bounded: Object {
    /// Axis aligned box that contains the object
    fn bounding_box(&self) -> AaBoundingBox;
}

/// Object towards which rays can be sampled
pub trait Sampleable: Object {
    /// Returns surface area of the object
    fn area(&self) -> Float;

    /// Samples a ray leaving at random point on the surface of the object.
    /// Direction cos weighed on the hemisphere. Returns also normal at ray origin
    fn sample_leaving(&self, rand_sq0: Vec2, rand_sq1: Vec2) -> (Ray, Hit) {
        let ho = self.sample_on(rand_sq0);
        let ns = ho.ns;
        let xo = ho.p;
        let uvw = Onb::new(ns);
        let wi_local = rand_utils::square_to_cos_hemisphere(rand_sq1);
        let wi = uvw.to_world(wi_local);
        // pdf start = 1 / area
        // pdf dir = cos hemisphere
        // prob want to make sample_leaving_pdf function
        (Ray::new(xo, wi), ho)
    }

    /// Returns PDF for sampled ray (i) origin and (ii) direction
    fn sample_leaving_pdf(&self, r: &Ray, ng: Normal) -> (Float, Float) {
        let pdf_origin = 1.0 / self.area();
        let wi = r.dir;
        let cos_theta = ng.dot(wi);
        let pdf_dir = cos_theta / crate::PI;

        (pdf_origin, pdf_dir)
    }

    /// Returns randomly sampled point on the surface of the object
    /// and the normal at the point.
    fn sample_on(&self, rand_sq: Vec2) -> Hit;

    /// Sample random direction from `xo` towards area of object
    /// that is visible form `xo`
    ///
    /// # Arguments
    /// * `xo` - Point on the "from" object
    /// * `rand_sq` - Uniformly random point on unit square
    fn sample_towards(&self, xo: Point, rand_sq: Vec2) -> Direction {
        let xi = self.sample_on(rand_sq).p;
        xi - xo
    }

    /// PDF for sampling points on the surface uniformly at random. Returns PDF
    /// with respect to area and hit to self, if found.
    ///
    /// # Arguments
    /// * `ri` - Sampled ray from `xo` to `xi`
    fn sample_towards_pdf(&self, ri: &Ray) -> (Float, Option<Hit>) {
        match self.hit(ri, 0.0, crate::INF) {
            None => (0.0, None),
            Some(hi) => {
                // might not work for solids, cause might be multiple hits
                let p = 1.0 / self.area();

                (p, Some(hi))
            }
        }
    }
}