Struct Projection 

pub struct Projection { /* private fields */ }

Screen extent of the world, and its foreshortening by depth.

The view is always the drawing area’s shape; games never need an aspect ratio.

Implementations

impl Projection

pub const fn perspective(fov_degrees: f32) -> Self

Foreshortened by depth, over a vertical field of view, in degrees.

Examples found in repository

examples/material-playground.rs (line 790)

    fn camera(&self) -> Camera {
        Camera::new(
            View::look_at(self.eye, self.eye + self.forward()),
            Projection::perspective(CAMERA_FOV),
        )
    }

examples/stress-preview.rs (line 290)

    fn camera(&self) -> Camera {
        Camera::new(
            View::look_at(self.eye, self.eye + self.forward()),
            Projection::perspective(CAMERA_FOV),
        )
    }
}

struct StressPreview {
    settings: Settings,
    applied_instance_count: u32,
    applied_seed_count: u32,
    field: Vec<FieldEntry>,
    frame_times: FrameTimer,
    /// Set at the instant a pan, a wheel step or a drag first moves the
    /// camera; from then on the orbit never runs again.
    player: Option<Player>,
}

impl StressPreview {
    fn init(_ctx: &mut InitContext<'_, Self>) -> Result<Self, Error> {
        let settings = Settings::default();
        let field = build_field(settings.instance_count, settings.seed_count);
        Ok(Self {
            applied_instance_count: settings.instance_count,
            applied_seed_count: settings.seed_count,
            settings,
            field,
            frame_times: FrameTimer::new(),
            player: None,
        })
    }

    /// Rebuilds the field where the instance count or the seed count
    /// changed since the last frame.
    fn apply_settings(&mut self) {
        if self.settings.instance_count == self.applied_instance_count
            && self.settings.seed_count == self.applied_seed_count
        {
            return;
        }
        self.field = build_field(self.settings.instance_count, self.settings.seed_count);
        self.applied_instance_count = self.settings.instance_count;
        self.applied_seed_count = self.settings.seed_count;
    }

    /// The camera's place along the orbit at `elapsed`, before the player
    /// takes it over.
    fn orbit_eye(elapsed: f32) -> Vec3 {
        let angle = elapsed * CAMERA_ANGULAR_SPEED;
        Vec3::new(
            angle.cos() * CAMERA_ORBIT_RADIUS,
            CAMERA_HEIGHT,
            angle.sin() * CAMERA_ORBIT_RADIUS,
        )
    }

    /// The frame's camera: the orbit at `elapsed`, or the player's own
    /// place once they have taken over.
    fn camera(&self, elapsed: f32) -> Camera {
        match &self.player {
            Some(player) => player.camera(),
            None => Camera::new(
                View::look_at(Self::orbit_eye(elapsed), Vec3::ZERO),
                Projection::perspective(CAMERA_FOV),
            ),
        }
    }

examples/breakout-game.rs (line 585)

    fn camera() -> Camera {
        Camera::new(
            View::look_at(Vec3::new(0.0, 13.5, 12.5), Vec3::new(0.0, 0.0, 0.5)),
            Projection::perspective(50.0),
        )
    }

examples/sprite-adventure.rs (line 1039)

    fn camera(position: Vec3, offset: Vec3) -> Camera {
        Camera::new(
            View::look_at(position + offset, position),
            Projection::perspective(CAMERA_FOV),
        )
    }

examples/sound-lab.rs (line 457)

    fn camera(player: Vec2) -> Camera {
        let ground = Vec3::new(player.x, 0.0, player.y);
        Camera::new(
            View::look_at(
                ground + Vec3::new(0.0, CHASE_UP, CHASE_BACK),
                ground + Vec3::Y * 0.5,
            ),
            Projection::perspective(55.0),
        )
    }

examples/post-effects.rs (line 159)

    fn frame(&mut self, ctx: &mut FrameContext<'_, Self>) {
        ctx.set_camera(Camera::new(
            View::look_at(Vec3::new(0.0, 3.4, 4.6), Vec3::new(0.0, 0.2, 0.0)),
            Projection::perspective(45.0),
        ));
        ctx.set_bloom(SCENE_BLOOM);

        self.draw_scene(ctx);
        self.panel(ctx);
    }

Additional examples can be found in:

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

pub const fn orthographic(world_height: f32) -> Self

No foreshortening; world_height meters of world are visible over the drawing area’s height.

Examples found in repository

examples/isometric-board.rs (line 386)

    fn camera() -> Camera {
        let eye = Vec3::new(9.0, 9.0, 9.0);
        Camera::new(
            View::look_at(eye, Vec3::ZERO),
            Projection::orthographic(11.0),
        )
    }

pub const fn clip(self, clip: Range<f32>) -> Self

Sets the distances, in meters, between which the world is visible; 0.1..1000.0 by default.

pub const fn lens(&self) -> Lens

This projection’s lens, and the number shaping it.

pub const fn near(&self) -> f32

This projection’s near clip distance, in meters.

pub const fn far(&self) -> f32

This projection’s far clip distance, in meters.

Trait Implementations

impl Clone for Projection

fn clone(&self) -> Projection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Projection

impl Debug for Projection

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

Formats the value using the given formatter.

impl PartialEq for Projection

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Projection