Struct tray_rust::geometry::receiver::Receiver

pub struct Receiver {
    pub material: Arc<dyn Material + Send + Sync>,
    pub tag: String,
    // some fields omitted
}

An instance of geometry in the scene that only receives light

Fields

material: Arc<dyn Material + Send + Sync>

The material being used by this instance.

tag: String

Tag to identify the instance

Methods

impl Receiver

pub fn new(
    geom: Arc<dyn BoundableGeom + Send + Sync>,
    material: Arc<dyn Material + Send + Sync>,
    transform: AnimatedTransform,
    tag: String
) -> Receiver

Create a new instance of some geometry in the scene

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 get_transform(&self) -> &AnimatedTransform

Get the transform to place the receiver into world space

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

Set the transform to place the receiver into world space

Trait Implementations

impl Boundable for Receiver

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.