Struct Light 

pub struct Light { /* private fields */ }

One light for one frame.

A frame is lit by exactly what it submits; submitting none keeps the default environment.

Implementations

impl Light

pub fn directional(direction: Vec3, color: Color) -> Self

A sun: parallel light along direction.

Examples found in repository

examples/flock-parallelism.rs (line 748)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.apply_settings();

        let center = Vec3::from(self.butterflies.center());
        let elapsed = ctx.elapsed().as_secs_f32();
        ctx.set_camera(Self::camera(center, self.world, elapsed));
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        Self::draw_ground(ctx);
        self.draw_butterflies(ctx);
        self.panel(ctx);
    }

examples/sprite-adventure.rs (line 1725)

    fn frame_overworld(&mut self, ctx: &mut FrameContext<'_, Keep>) {
        let drawn_at = self.previous.lerp(self.position, ctx.alpha());
        ctx.set_camera(Self::camera(drawn_at, OVERWORLD_CAMERA_OFFSET));
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        self.draw_ground(ctx);
        self.draw_hedgerow(ctx);
        self.draw_pond(ctx);
        self.draw_crates(ctx);
        self.draw_well(ctx);
        self.draw_flora(ctx);
        Self::draw_mouth(ctx, ENTRANCE);
        self.draw_walker(ctx, drawn_at);
    }

examples/isometric-board.rs (line 823)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Board>) {
        let camera = Self::camera();
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(Vec3::new(-0.35, -1.0, -0.5), SUN_COLOR).shadow());
        ctx.set_bloom(BLOOM);

        let hover = self.hovered(ctx);
        self.draw_ground(ctx);
        self.draw_board(ctx, hover);
        self.draw_current_mark(ctx);
        self.draw_rocks(ctx);
        self.draw_sprite(ctx, hover);
        self.draw_block(ctx, hover);
        self.draw_prompt(ctx, camera, hover);

        self.overlay(ctx);
    }

examples/stress-preview.rs (line 612)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.apply_settings();
        self.frame_times.record(ctx.dt());

        let elapsed = ctx.elapsed().as_secs_f32();
        self.handle_camera(ctx, elapsed);
        let camera = self.camera(elapsed);
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);

        let sun = Light::directional(SUN_DIRECTION, SUN_COLOR);
        ctx.light(if self.settings.sun_shadow {
            sun.shadow()
        } else {
            sun
        });

        Self::draw_ground(ctx);
        self.draw_field(ctx, elapsed);
        self.controls(ctx, &camera);
    }

examples/material-playground.rs (line 1026)

    fn lights(&self) -> Vec<Light> {
        let lamp = Light::point(LAMP_POSITION, self.lamp.scaled(), LAMP_RANGE);
        let spotlight = Light::spot(Spot {
            position: SPOT_POSITION,
            direction: SPOT_DIRECTION,
            color: self.spotlight.scaled(),
            range: SPOT_RANGE,
            angle: SPOT_ANGLE,
        });

        let mut lights = vec![
            if self.lamp.shadow {
                lamp.shadow()
            } else {
                lamp
            },
            if self.spotlight.shadow {
                spotlight.shadow()
            } else {
                spotlight
            },
        ];

        if let Some((direction, color, strength)) = self.sky.sun() {
            let sun = Light::directional(direction, scaled(color, strength));
            lights.push(if self.sun_shadow { sun.shadow() } else { sun });
        }

        lights
    }

examples/post-effects.rs (line 91)

    fn draw_scene(&self, ctx: &mut FrameContext<'_, Self>) {
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    GROUND_SIZE,
                    1.0,
                    GROUND_SIZE,
                )))
                .material(Material::lit(GROUND_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(GLOW_SIZE),
                Quat::IDENTITY,
                GLOW_POSITION,
            ))
            .material(Material::color(Color::BLACK).emissive(GLOW_COLOR)),
        );
        for position in SPHERE_POSITIONS {
            ctx.draw(
                Sphere {
                    subdivisions: SPHERE_SUBDIVISIONS,
                }
                .at(position)
                .material(Material::lit(SPHERE_COLOR)),
            );
        }
    }

Additional examples can be found in:

• examples/ui-fonts.rs
• examples/sound-lab.rs
• examples/animation.rs

pub fn point(position: Vec3, color: Color, range: f32) -> Self

A lamp at position, fading to nothing range meters out.

A surface takes the square of the fraction of range left at its distance from position: the whole of the light at position, a quarter of it halfway out, and none of it at range or past it.

Examples found in repository

examples/material-playground.rs (line 1003)

    fn lights(&self) -> Vec<Light> {
        let lamp = Light::point(LAMP_POSITION, self.lamp.scaled(), LAMP_RANGE);
        let spotlight = Light::spot(Spot {
            position: SPOT_POSITION,
            direction: SPOT_DIRECTION,
            color: self.spotlight.scaled(),
            range: SPOT_RANGE,
            angle: SPOT_ANGLE,
        });

        let mut lights = vec![
            if self.lamp.shadow {
                lamp.shadow()
            } else {
                lamp
            },
            if self.spotlight.shadow {
                spotlight.shadow()
            } else {
                spotlight
            },
        ];

        if let Some((direction, color, strength)) = self.sky.sun() {
            let sun = Light::directional(direction, scaled(color, strength));
            lights.push(if self.sun_shadow { sun.shadow() } else { sun });
        }

        lights
    }

examples/sprite-adventure.rs (line 1553)

    fn draw_torches(&self, ctx: &mut FrameContext<'_, Keep>) {
        let elapsed = self.simulated.as_secs_f32();
        let loop_cells = Sheet::new(UVec2::new(FLAME_CELLS, 1));

        for (index, &(x, z)) in TORCH_POSITIONS.iter().enumerate() {
            let base = Vec3::new(x, 0.0, z);
            ctx.draw(
                Torch
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::new(TORCH_SPRITE_WIDTH, TORCH_STAND_HEIGHT, 1.0),
                        Quat::IDENTITY,
                        base + Vec3::Y * (TORCH_STAND_HEIGHT * 0.5),
                    ))
                    .upright(),
            );

            let phase = index as f32 * 2.1;
            let flicker = (elapsed * FLAME_FLICKER_SPEED + phase).sin();
            let flame_pos =
                base + Vec3::Y * (TORCH_STAND_HEIGHT + FLAME_LIFT + flicker * FLAME_BOB);

            let light_pos = flame_pos + Vec3::new(0.0, TORCH_LIGHT_LIFT, TORCH_LIGHT_STANDOFF);
            ctx.light(Light::point(light_pos, TORCH_LIGHT_COLOR, TORCH_LIGHT_RANGE).shadow());
            // The pair burn an even share of the loop apart.
            let offset = index as u32 * FLAME_CELLS / TORCH_POSITIONS.len() as u32;
            ctx.draw(
                Flame
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::splat(FLAME_SIZE),
                        Quat::IDENTITY,
                        flame_pos,
                    ))
                    .billboard()
                    .roll(flicker * FLAME_ROLL)
                    .frame(loop_cells.cell((elapsed * FLAME_RATE) as u32 + offset)),
            );
        }
    }

    /// The door at its hinge — swung back against the wall once opened —
    /// drawn through alongside its wall, faded by `ghost`.
    fn draw_door(&self, ctx: &mut FrameContext<'_, Keep>, ghost: f32) {
        let fade = ghost_alpha(ghost);
        let swung = if self.door_opening {
            Quat::from_rotation_y(core::f32::consts::FRAC_PI_2)
        } else {
            Quat::IDENTITY
        };

        ctx.draw(
            Door.at(Transform::from_rotation_translation(swung, DOOR_HINGE))
                .material(Material::shaded(DOOR_COLOR, DOOR_LITNESS))
                .faded(fade),
        );
    }

    /// The posts and lintel framing the doorway, in a color the stone never
    /// is, standing clear of the wall so the opening reads as a door from
    /// across the chamber. Glowing of their own while the door is closed and
    /// within [`INTERACT_RADIUS`], the cue that it opens.
    fn draw_door_frame(&self, ctx: &mut FrameContext<'_, Keep>, ghost: f32) {
        let reachable =
            !self.door_opening && self.position.distance(INTERACT_POINT) < INTERACT_RADIUS;
        let material =
            Material::shaded(DOOR_FRAME_COLOR, DOOR_FRAME_LITNESS).emissive(if reachable {
                DOOR_FRAME_GLOW
            } else {
                Color::BLACK
            });
        let fade = ghost_alpha(ghost);
        let z = DOOR_WALL_NEAR_Z + DOOR_FRAME_STANDOFF;
        let jamb_height = DOOR_HEIGHT + DOOR_FRAME_THICKNESS;

        for side in SIDES {
            ctx.draw(
                Cube.at(Transform::from_scale_rotation_translation(
                    Vec3::new(DOOR_FRAME_THICKNESS, jamb_height, DOOR_FRAME_THICKNESS),
                    Quat::IDENTITY,
                    Vec3::new(
                        side * (DOORWAY_HALF + DOOR_FRAME_THICKNESS * 0.5),
                        jamb_height * 0.5,
                        z,
                    ),
                ))
                .material(material)
                .faded(fade),
            );
        }
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::new(
                    DOOR_WIDTH + DOOR_FRAME_THICKNESS * 2.0,
                    DOOR_FRAME_THICKNESS,
                    DOOR_FRAME_THICKNESS,
                ),
                Quat::IDENTITY,
                Vec3::new(0.0, DOOR_HEIGHT + DOOR_FRAME_THICKNESS * 0.5, z),
            ))
            .material(material)
            .faded(fade),
        );
    }

    /// A world prompt over the door: what opens it while the player is
    /// within [`INTERACT_RADIUS`] and it is closed, and that it swings while
    /// it does; gone once it has swung [`DOOR_SWING_TICKS`]. Laid out and
    /// placed like `examples/animation.rs`'s own prompt.
    fn draw_door_prompt(&self, ctx: &mut FrameContext<'_, Keep>, camera: Camera) {
        let near = self.position.distance(INTERACT_POINT) < INTERACT_RADIUS;
        let swinging = self.door_opening && self.swing_ticks < DOOR_SWING_TICKS;
        let text = if swinging {
            "opening"
        } else if near && !self.door_opening {
            "e opens the door"
        } else {
            return;
        };

        let galley = ctx.text_layout(text, egui::FontId::proportional(DOOR_PROMPT_SIZE));
        let point = INTERACT_POINT + Vec3::Y * (DOOR_HEIGHT + DOOR_PROMPT_LIFT);
        let window_size = ctx.window_size();
        let pixels_per_point = ctx.pixels_per_point();
        let Some(pixel) = camera.pixel_of(point, window_size) else {
            return;
        };

        ctx.ui(|ui| {
            let painter = ui.painter();
            let at = logical(pixel, pixels_per_point);
            let ink = galley.mesh_bounds;
            let pos = egui::pos2(at.x - ink.center().x, at.y - ink.center().y);
            let backdrop = egui::Rect::from_center_size(
                at,
                ink.size() + egui::Vec2::splat(DOOR_PROMPT_PADDING * 2.0),
            );
            painter.rect_filled(
                backdrop,
                DOOR_PROMPT_PADDING,
                egui::Color32::from_black_alpha(DOOR_PROMPT_BACKDROP),
            );
            painter.galley(pos, galley, DOOR_PROMPT_COLOR);
        });
    }

    /// The gem, spinning and bobbing over the chamber's floor, and the light
    /// it casts over it.
    fn draw_gem(&self, ctx: &mut FrameContext<'_, Keep>) {
        let t = self.simulated.as_secs_f32();
        let bob = (t * 2.0).sin() * GEM_BOB_HEIGHT;
        ctx.light(
            Light::point(
                GEM_POSITION + Vec3::Y * (bob + GEM_LIGHT_LIFT),
                GEM_LIGHT_COLOR,
                GEM_LIGHT_RANGE,
            )
            .shadow(),
        );
        ctx.draw(
            Gem.at(Transform::from_scale_rotation_translation(
                Vec3::ONE,
                Quat::from_rotation_y(t * GEM_SPIN_SPEED),
                GEM_POSITION + Vec3::Y * bob,
            ))
            .material(Material::shaded(GEM_COLOR, 0.7).emissive(GEM_COLOR.dimmed(1.6))),
        );
    }

examples/breakout-game.rs (line 1020)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Breakout>) {
        if matches!(self.phase, Phase::Serving | Phase::Playing) && ctx.pressed(Button::Pause) {
            self.paused = !self.paused;
        }

        ctx.set_volume(self.master_volume);
        self.sustain_music(ctx);

        ctx.set_camera(Self::camera());

        let brick_pulse = (self.brick_flash / BRICK_FLASH).clamp(0.0, 1.0);
        ctx.set_bloom((BLOOM_BASE + brick_pulse * BLOOM_PULSE_PEAK).clamp(0.0, 1.0));

        let life_lost_t = (self.life_lost_flash / LIFE_LOST_FLASH).clamp(0.0, 1.0);
        ctx.set_exposure((1.0 - life_lost_t * EXPOSURE_DIP_DEPTH).clamp(0.0, 1.0));

        // The tick moves nothing behind a menu, so a frame there draws the last
        // step whole rather than interpolating from the one before.
        let alpha = match self.phase {
            Phase::Serving | Phase::Playing if !self.paused => ctx.alpha(),
            _ => 1.0,
        };
        let paddle_x = self.paddle_prev_x.lerp(self.paddle_x, alpha);
        let ball_pos = self.ball_prev.lerp(self.ball_pos, alpha);

        ctx.light(Light::point(ball_pos, BALL_GLOW, BALL_LIGHT_RANGE).shadow());

        self.draw_court(ctx);
        self.draw_bricks(ctx);
        self.draw_sparks(ctx);
        self.draw_lives(ctx);

        ctx.draw(
            Paddle
                .at(Transform::from_translation(Vec3::new(
                    paddle_x,
                    PADDLE_HALF_HEIGHT,
                    PADDLE_Z,
                )))
                .material_of(PaddlePart::Face, self.paddle_face_material()),
        );

        self.draw_trail(ctx, alpha);
        ctx.draw(
            Sphere { subdivisions: 2 }
                .at(Transform::from_scale_rotation_translation(
                    Vec3::splat(BALL_RADIUS * 2.0),
                    Quat::IDENTITY,
                    ball_pos,
                ))
                .material(
                    Material::color(BALL_GLOW)
                        .emissive(BALL_EMISSIVE)
                        .additive(),
                ),
        );

        self.overlay(ctx);
    }

examples/animation.rs (lines 940-944)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Scene>) {
        self.steer_camera(ctx);

        let alpha = ctx.alpha();
        let elf_pos = self.elf_prev.lerp(self.elf_pos, alpha);
        let elf_height = self.elf_height_prev + (self.elf_height - self.elf_height_prev) * alpha;
        let (butterfly_pos, butterfly_yaw) = butterfly_pose(ctx.elapsed().as_secs_f32());

        let camera = orbit_camera(elf_pos, self.camera_yaw, self.camera_pitch);
        ctx.set_camera(camera);
        ctx.set_cursor(if self.holding {
            Cursor::Held
        } else {
            Cursor::Arrow
        });
        ctx.set_skybox(Sky::Day);
        ctx.set_exposure(3.0);
        ctx.set_bloom(0.2);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());
        ctx.light(
            Light::point(
                LAMP_POST_POSITION + Vec3::Y * (LAMP_POST_HEIGHT + LAMP_HEAD_GAP * 0.5),
                LAMP_LIGHT_COLOR,
                LAMP_LIGHT_RANGE,
            )
            .shadow(),
        );
        ctx.light(
            Light::spot(Spot {
                position: SPOT_POSITION,
                direction: SPOT_DIRECTION,
                color: SPOT_COLOR,
                range: SPOT_RANGE,
                angle: SPOT_ANGLE,
            })
            .shadow(),
        );
        ctx.light(
            Light::point(butterfly_pos, BUTTERFLY_LIGHT_COLOR, BUTTERFLY_LIGHT_RANGE).shadow(),
        );

        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    GROUND_SIZE,
                    1.0,
                    GROUND_SIZE,
                )))
                .material(Material::lit(GROUND_COLOR)),
        );
        for patch in HURT_PATCHES {
            ctx.draw(
                Plane
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::splat(HURT_RADIUS * 2.0),
                        Quat::IDENTITY,
                        patch,
                    ))
                    .material(Material::lit(HURT_COLOR)),
            );
        }
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::new(SEAT_FOOTPRINT, SEAT_HEIGHT, SEAT_FOOTPRINT),
                Quat::IDENTITY,
                SEAT_POSITION + Vec3::Y * SEAT_HEIGHT * 0.5,
            ))
            .material(Material::lit(SEAT_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::new(LAMP_POST_THICKNESS, LAMP_POST_HEIGHT, LAMP_POST_THICKNESS),
                Quat::IDENTITY,
                LAMP_POST_POSITION + Vec3::Y * LAMP_POST_HEIGHT * 0.5,
            ))
            .material(Material::lit(LAMP_POST_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(LAMP_HEAD_SIZE),
                Quat::IDENTITY,
                LAMP_POST_POSITION
                    + Vec3::Y * (LAMP_POST_HEIGHT + LAMP_HEAD_GAP + LAMP_HEAD_SIZE * 0.5),
            ))
            .material(Material::color(Color::BLACK).emissive(LAMP_LIGHT_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(SPOT_FIXTURE_SIZE),
                Quat::IDENTITY,
                SPOT_POSITION + Vec3::Y * SPOT_FIXTURE_SIZE * 0.5,
            ))
            .material(Material::lit(SPOT_FIXTURE_COLOR)),
        );

        ctx.draw(
            Elf.at(Transform::from_rotation_translation(
                Quat::from_rotation_y(self.elf_yaw),
                elf_pos + Vec3::Y * elf_height,
            ))
            .posed(&self.elf_animator),
        );
        ctx.draw(
            Elf.at(Transform::from_rotation_translation(
                Quat::from_rotation_y(core::f32::consts::PI),
                SCRUBBED_ELF_POSITION,
            ))
            .posed(&self.scrubbed_animator),
        );
        ctx.draw(
            Butterfly
                .at(Transform::from_rotation_translation(
                    Quat::from_rotation_y(butterfly_yaw),
                    butterfly_pos,
                ))
                .posed(&self.butterfly_animator)
                .material(Material::lit(Color::WHITE).emissive(BUTTERFLY_EMISSIVE)),
        );

        self.draw_prompts(ctx, camera);
        self.panel(ctx);
    }

pub fn spot(spot: Spot) -> Self

A point light within spot’s cone.

Examples found in repository

examples/material-playground.rs (lines 1004-1010)

    fn lights(&self) -> Vec<Light> {
        let lamp = Light::point(LAMP_POSITION, self.lamp.scaled(), LAMP_RANGE);
        let spotlight = Light::spot(Spot {
            position: SPOT_POSITION,
            direction: SPOT_DIRECTION,
            color: self.spotlight.scaled(),
            range: SPOT_RANGE,
            angle: SPOT_ANGLE,
        });

        let mut lights = vec![
            if self.lamp.shadow {
                lamp.shadow()
            } else {
                lamp
            },
            if self.spotlight.shadow {
                spotlight.shadow()
            } else {
                spotlight
            },
        ];

        if let Some((direction, color, strength)) = self.sky.sun() {
            let sun = Light::directional(direction, scaled(color, strength));
            lights.push(if self.sun_shadow { sun.shadow() } else { sun });
        }

        lights
    }

examples/animation.rs (lines 948-954)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Scene>) {
        self.steer_camera(ctx);

        let alpha = ctx.alpha();
        let elf_pos = self.elf_prev.lerp(self.elf_pos, alpha);
        let elf_height = self.elf_height_prev + (self.elf_height - self.elf_height_prev) * alpha;
        let (butterfly_pos, butterfly_yaw) = butterfly_pose(ctx.elapsed().as_secs_f32());

        let camera = orbit_camera(elf_pos, self.camera_yaw, self.camera_pitch);
        ctx.set_camera(camera);
        ctx.set_cursor(if self.holding {
            Cursor::Held
        } else {
            Cursor::Arrow
        });
        ctx.set_skybox(Sky::Day);
        ctx.set_exposure(3.0);
        ctx.set_bloom(0.2);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());
        ctx.light(
            Light::point(
                LAMP_POST_POSITION + Vec3::Y * (LAMP_POST_HEIGHT + LAMP_HEAD_GAP * 0.5),
                LAMP_LIGHT_COLOR,
                LAMP_LIGHT_RANGE,
            )
            .shadow(),
        );
        ctx.light(
            Light::spot(Spot {
                position: SPOT_POSITION,
                direction: SPOT_DIRECTION,
                color: SPOT_COLOR,
                range: SPOT_RANGE,
                angle: SPOT_ANGLE,
            })
            .shadow(),
        );
        ctx.light(
            Light::point(butterfly_pos, BUTTERFLY_LIGHT_COLOR, BUTTERFLY_LIGHT_RANGE).shadow(),
        );

        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    GROUND_SIZE,
                    1.0,
                    GROUND_SIZE,
                )))
                .material(Material::lit(GROUND_COLOR)),
        );
        for patch in HURT_PATCHES {
            ctx.draw(
                Plane
                    .at(Transform::from_scale_rotation_translation(
                        Vec3::splat(HURT_RADIUS * 2.0),
                        Quat::IDENTITY,
                        patch,
                    ))
                    .material(Material::lit(HURT_COLOR)),
            );
        }
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::new(SEAT_FOOTPRINT, SEAT_HEIGHT, SEAT_FOOTPRINT),
                Quat::IDENTITY,
                SEAT_POSITION + Vec3::Y * SEAT_HEIGHT * 0.5,
            ))
            .material(Material::lit(SEAT_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::new(LAMP_POST_THICKNESS, LAMP_POST_HEIGHT, LAMP_POST_THICKNESS),
                Quat::IDENTITY,
                LAMP_POST_POSITION + Vec3::Y * LAMP_POST_HEIGHT * 0.5,
            ))
            .material(Material::lit(LAMP_POST_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(LAMP_HEAD_SIZE),
                Quat::IDENTITY,
                LAMP_POST_POSITION
                    + Vec3::Y * (LAMP_POST_HEIGHT + LAMP_HEAD_GAP + LAMP_HEAD_SIZE * 0.5),
            ))
            .material(Material::color(Color::BLACK).emissive(LAMP_LIGHT_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(SPOT_FIXTURE_SIZE),
                Quat::IDENTITY,
                SPOT_POSITION + Vec3::Y * SPOT_FIXTURE_SIZE * 0.5,
            ))
            .material(Material::lit(SPOT_FIXTURE_COLOR)),
        );

        ctx.draw(
            Elf.at(Transform::from_rotation_translation(
                Quat::from_rotation_y(self.elf_yaw),
                elf_pos + Vec3::Y * elf_height,
            ))
            .posed(&self.elf_animator),
        );
        ctx.draw(
            Elf.at(Transform::from_rotation_translation(
                Quat::from_rotation_y(core::f32::consts::PI),
                SCRUBBED_ELF_POSITION,
            ))
            .posed(&self.scrubbed_animator),
        );
        ctx.draw(
            Butterfly
                .at(Transform::from_rotation_translation(
                    Quat::from_rotation_y(butterfly_yaw),
                    butterfly_pos,
                ))
                .posed(&self.butterfly_animator)
                .material(Material::lit(Color::WHITE).emissive(BUTTERFLY_EMISSIVE)),
        );

        self.draw_prompts(ctx, camera);
        self.panel(ctx);
    }

pub fn shadow(self) -> Self

Draws what this light covers into a depth map of its own, and darkens this light where the map holds a blocker in front of the surface.

MAX_SHADOWS lights of a frame may cast, in submission order; a point light counts as one and costs six maps. The rest are ignored — warned the first frame. Only opaque draws block a light, and only this light is darkened — the sky’s own light and unlit materials are untouched. A shadow extends no further than the light: past its range there is no light left to block. Both faces of a mesh cast, so a light placed within an opaque mesh is blocked by its own caster.

Examples found in repository

examples/flock-parallelism.rs (line 748)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.apply_settings();

        let center = Vec3::from(self.butterflies.center());
        let elapsed = ctx.elapsed().as_secs_f32();
        ctx.set_camera(Self::camera(center, self.world, elapsed));
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        Self::draw_ground(ctx);
        self.draw_butterflies(ctx);
        self.panel(ctx);
    }

examples/isometric-board.rs (line 823)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Board>) {
        let camera = Self::camera();
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);
        ctx.light(Light::directional(Vec3::new(-0.35, -1.0, -0.5), SUN_COLOR).shadow());
        ctx.set_bloom(BLOOM);

        let hover = self.hovered(ctx);
        self.draw_ground(ctx);
        self.draw_board(ctx, hover);
        self.draw_current_mark(ctx);
        self.draw_rocks(ctx);
        self.draw_sprite(ctx, hover);
        self.draw_block(ctx, hover);
        self.draw_prompt(ctx, camera, hover);

        self.overlay(ctx);
    }

examples/stress-preview.rs (line 614)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.apply_settings();
        self.frame_times.record(ctx.dt());

        let elapsed = ctx.elapsed().as_secs_f32();
        self.handle_camera(ctx, elapsed);
        let camera = self.camera(elapsed);
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Day);

        let sun = Light::directional(SUN_DIRECTION, SUN_COLOR);
        ctx.light(if self.settings.sun_shadow {
            sun.shadow()
        } else {
            sun
        });

        Self::draw_ground(ctx);
        self.draw_field(ctx, elapsed);
        self.controls(ctx, &camera);
    }

examples/material-playground.rs (line 1014)

    fn lights(&self) -> Vec<Light> {
        let lamp = Light::point(LAMP_POSITION, self.lamp.scaled(), LAMP_RANGE);
        let spotlight = Light::spot(Spot {
            position: SPOT_POSITION,
            direction: SPOT_DIRECTION,
            color: self.spotlight.scaled(),
            range: SPOT_RANGE,
            angle: SPOT_ANGLE,
        });

        let mut lights = vec![
            if self.lamp.shadow {
                lamp.shadow()
            } else {
                lamp
            },
            if self.spotlight.shadow {
                spotlight.shadow()
            } else {
                spotlight
            },
        ];

        if let Some((direction, color, strength)) = self.sky.sun() {
            let sun = Light::directional(direction, scaled(color, strength));
            lights.push(if self.sun_shadow { sun.shadow() } else { sun });
        }

        lights
    }

examples/post-effects.rs (line 91)

    fn draw_scene(&self, ctx: &mut FrameContext<'_, Self>) {
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    GROUND_SIZE,
                    1.0,
                    GROUND_SIZE,
                )))
                .material(Material::lit(GROUND_COLOR)),
        );
        ctx.draw(
            Cube.at(Transform::from_scale_rotation_translation(
                Vec3::splat(GLOW_SIZE),
                Quat::IDENTITY,
                GLOW_POSITION,
            ))
            .material(Material::color(Color::BLACK).emissive(GLOW_COLOR)),
        );
        for position in SPHERE_POSITIONS {
            ctx.draw(
                Sphere {
                    subdivisions: SPHERE_SUBDIVISIONS,
                }
                .at(position)
                .material(Material::lit(SPHERE_COLOR)),
            );
        }
    }

examples/ui-fonts.rs (line 822)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        self.steer(ctx);

        let camera = self.orbit.camera();
        ctx.set_camera(camera);
        ctx.set_skybox(Sky::Dusk);
        ctx.light(Light::directional(SUN_DIRECTION, SUN_COLOR).shadow());

        ctx.draw(
            Plane
                .at(Transform::from_scale(Vec3::new(
                    PLATFORM_SIZE,
                    1.0,
                    PLATFORM_SIZE,
                )))
                .material(Material::lit(PLATFORM_COLOR)),
        );
        for station in StationKind::ALL {
            self.draw_station(ctx, station);
        }

        let hovered = Self::hovered(ctx);
        if !self.sheet_open {
            if let Some(station) = hovered {
                ctx.set_cursor(Cursor::Pointer);
                self.draw_bracket(ctx, camera, station);
            }
            self.draw_prompts(ctx, camera, hovered);
        }
        if self.dialogue.is_some() {
            self.draw_dialogue(ctx);
        }
        if self.sheet_open {
            ctx.ui(sheet);
        }
        self.panel(ctx);
    }

Additional examples can be found in:

• examples/sound-lab.rs
• examples/sprite-adventure.rs
• examples/breakout-game.rs
• examples/animation.rs

Trait Implementations

impl Clone for Light

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Light

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: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Light