Struct Light

pub struct Light {
    pub light_type: LightType,
    pub intensity: f64,
}

A light object used to define a scene’s lighting. Used by DisplayMode::Illuminated

Fields

light_type: LightType

The type of light and the way it affects faces based on their normals

intensity: f64

The intensity of the light

Implementations

impl Light

pub const fn new_ambient(intensity: f64) -> Self

Create a new ambient light

Examples found in repository

examples/donut.rs (line 23)

fn main() {
    let mut view = View::new(100, 45, ColChar::EMPTY);
    let mut viewport = Viewport::new(
        Transform3D::look_at_lh(Vec3D::new(0.0, -3.0, 6.0), Vec3D::ZERO, Vec3D::Y),
        FOV,
        view.center(),
    );

    viewport.display_mode = DisplayMode::Illuminated {
        lights: vec![
            Light::new_ambient(0.3),
            Light::new_directional(0.7, Vec3D::new(1.0, 1.0, 1.0)),
        ],
    };

    viewport.objects.push(Mesh3D::torus(1.8, 1.0, 32, 16));

    fps_gameloop!(
        {
            let donut_tr = &mut viewport.objects[0].transform;
            *donut_tr = donut_tr.mul_mat4(&Transform3D::from_rotation_y(-0.03));
            *donut_tr = donut_tr.mul_mat4(&Transform3D::from_rotation_x(0.03));
        },
        {
            view.clear();
            view.draw(&viewport);
            let _ = view.display_render();
        },
        FPS
    );
}

examples/spinning-cube.rs (line 26)

fn main() {
    let mut view = View::new(100, 50, ColChar::EMPTY);

    let mut viewport = Viewport::new(
        Transform3D::look_at_lh(Vec3D::new(0.0, -1.5, 4.3), Vec3D::ZERO, Vec3D::Y),
        FOV,
        view.center(),
    );
    viewport.objects.push(Mesh3D::default_cube());

    viewport.display_mode = DisplayMode::Illuminated {
        lights: vec![
            Light::new_ambient(0.3),
            Light::new_directional(0.6, Vec3D::new(0.5, 1.0, 1.0)),
        ],
    };

    fps_gameloop!(
        {
            viewport.objects[0].transform = viewport.objects[0]
                .transform
                .mul_mat4(&Transform3D::from_rotation_y(-0.05));
        },
        {
            view.clear();
            view.draw(&viewport);
            let _ = view.display_render();
        },
        FPS,
        |elapsed: Duration, frame_skip| {
            println!(
                "Elapsed: {:.2?}µs | Frame skip: {}",
                elapsed.as_micros(),
                frame_skip
            );
        }
    );
}

pub const fn new_directional(intensity: f64, direction: Vec3D) -> Self

Create a new directional light

Examples found in repository

examples/donut.rs (line 24)

fn main() {
    let mut view = View::new(100, 45, ColChar::EMPTY);
    let mut viewport = Viewport::new(
        Transform3D::look_at_lh(Vec3D::new(0.0, -3.0, 6.0), Vec3D::ZERO, Vec3D::Y),
        FOV,
        view.center(),
    );

    viewport.display_mode = DisplayMode::Illuminated {
        lights: vec![
            Light::new_ambient(0.3),
            Light::new_directional(0.7, Vec3D::new(1.0, 1.0, 1.0)),
        ],
    };

    viewport.objects.push(Mesh3D::torus(1.8, 1.0, 32, 16));

    fps_gameloop!(
        {
            let donut_tr = &mut viewport.objects[0].transform;
            *donut_tr = donut_tr.mul_mat4(&Transform3D::from_rotation_y(-0.03));
            *donut_tr = donut_tr.mul_mat4(&Transform3D::from_rotation_x(0.03));
        },
        {
            view.clear();
            view.draw(&viewport);
            let _ = view.display_render();
        },
        FPS
    );
}

examples/spinning-cube.rs (line 27)

fn main() {
    let mut view = View::new(100, 50, ColChar::EMPTY);

    let mut viewport = Viewport::new(
        Transform3D::look_at_lh(Vec3D::new(0.0, -1.5, 4.3), Vec3D::ZERO, Vec3D::Y),
        FOV,
        view.center(),
    );
    viewport.objects.push(Mesh3D::default_cube());

    viewport.display_mode = DisplayMode::Illuminated {
        lights: vec![
            Light::new_ambient(0.3),
            Light::new_directional(0.6, Vec3D::new(0.5, 1.0, 1.0)),
        ],
    };

    fps_gameloop!(
        {
            viewport.objects[0].transform = viewport.objects[0]
                .transform
                .mul_mat4(&Transform3D::from_rotation_y(-0.05));
        },
        {
            view.clear();
            view.draw(&viewport);
            let _ = view.display_render();
        },
        FPS,
        |elapsed: Duration, frame_skip| {
            println!(
                "Elapsed: {:.2?}µs | Frame skip: {}",
                elapsed.as_micros(),
                frame_skip
            );
        }
    );
}

pub const fn new_point(intensity: f64, position: Vec3D) -> Self

Create a new point light

pub fn calculate_intensity(&self, point: Vec3D, normal: Vec3D) -> f64

Calculate the intensity of the light as it affects a surface with the given normal

Trait Implementations

impl Clone for Light

fn clone(&self) -> Light

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Light

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Light

fn eq(&self, other: &Light) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Light

impl StructuralPartialEq for Light