Struct tray_rust::geometry::emitter::Emitter

pub struct Emitter {
    pub emission: AnimatedColor,
    pub tag: String,
    // some fields omitted
}

An instance of geometry in the scene that receives and emits light.

Fields

emission: AnimatedColor

The light intensity emitted

tag: String

Tag to identify the instance

Methods

impl Emitter

pub fn area(
    geom: Arc<dyn SampleableGeom + Send + Sync>,
    material: Arc<dyn Material + Send + Sync>,
    emission: AnimatedColor,
    transform: AnimatedTransform,
    tag: String
) -> Emitter

Create a new area light using the geometry passed to emit light TODO: We need sample methods for geometry to do this We also need MIS in the path tracer's direct light sampling so we get good quality

pub fn point(
    transform: AnimatedTransform,
    emission: AnimatedColor,
    tag: String
) -> Emitter

Create a point light at the origin that is transformed by transform to its location in the world

pub fn intersect(
    &self,
    ray: &mut Ray
) -> Option<(DifferentialGeometry, &dyn Material)>

Test the ray for intersection against this insance of geometry. returns Some(Intersection) if an intersection was found and None if not. If an intersection is found ray.max_t will be set accordingly

pub fn radiance(&self, w: &Vector, _: &Point, n: &Normal, time: f32) -> Colorf

Return the radiance emitted by the light in the direction w from point p on the light's surface with normal n

pub fn get_transform(&self) -> &AnimatedTransform

Get the transform to place the emitter into world space

pub fn set_transform(&mut self, transform: AnimatedTransform)

Set the transform to place the emitter into world space

Trait Implementations

impl Boundable for Emitter

fn bounds(&self, start: f32, end: f32) -> BBox

Get an AABB reporting the object's bounds over the time period The default implementation assumes the object isn't animated and simply returns its bounds. This is kind of a hack to use the BVH for animated geomtry (instances) and non-animated geometry (triangles).

fn update_deformation(&mut self, start: f32, end: f32)

Have the object recompute its bounds for the time range. In the case of deforming geometry this can rebuild acceleration structures for example.

impl Light for Emitter

fn sample_incident(
    &self,
    p: &Point,
    samples: &(f32, f32),
    time: f32
) -> (Colorf, Vector, f32, OcclusionTester)

Sample the illumination from the light arriving at the point p Returns the color, incident light direction, pdf and occlusion tester object samples will be used to randomly sample the light.

fn delta_light(&self) -> bool

Determine if the light is described by a delta distribution

fn pdf(&self, p: &Point, w_i: &Vector, time: f32) -> f32

Compute the PDF for sampling the point with incident direction w_i