Struct CameraFrame 

pub struct CameraFrame {
    pub pos: DVec3,
    pub up: DVec3,
    pub facing: DVec3,
    pub near: f64,
    pub far: f64,
    pub perspective_blend: f64,
    pub frame_height: f64,
    pub scale: f64,
    pub fovy: f64,
}

The data of a camera

The CameraFrame has a CameraFrame::perspective_blend property (default is 0.0), which is used to blend between orthographic and perspective projection.

Fields

pos: DVec3

The position

up: DVec3

The up unit vec

facing: DVec3

The facing unit vec

near: f64

The near pane

far: f64

The far pane

perspective_blend: f64

The perspective blend value in [0.0, 1.0]

frame_height: f64

Ortho: Top - Bottom

scale: f64

Ortho: The scaling factor

fovy: f64

Perspective: The field of view angle, used in perspective projection

Implementations

impl CameraFrame

pub fn new() -> Self

Create a new CameraFrame at the origin facing to the negative z-axis and use Y as up vector with default projection settings.

impl CameraFrame

pub fn set_view_matrix(&mut self, view_matrix: DMat4)

Set the view matrix of the camera.

pub fn with_view_matrix(self, view_matrix: DMat4) -> Self

Set the view matrix of the camera and return the modified Self.

pub fn view_matrix(&self) -> DMat4

The view matrix of the camera

pub fn orthographic_mat(&self, aspect_ratio: f64) -> DMat4

Use the given frame size as left, right, bottom, top to construct an orthographic matrix

pub fn perspective_mat(&self, aspect_ratio: f64) -> DMat4

Use the given frame aspect ratio to construct a perspective matrix

pub fn projection_matrix(&self, aspect_ratio: f64) -> DMat4

Use the given frame size to construct projection matrix

pub fn view_projection_matrix(&self, aspect_ratio: f64) -> DMat4

Use the given frame size to construct view projection matrix

impl CameraFrame

pub fn from_spherical(phi: f64, theta: f64, distance: f64) -> Self

Create a perspective camera positioned using spherical coordinates (Z-up), looking at the origin.

• phi: polar angle from +Z axis in radians (0 = straight up along +Z, π/2 = XY plane)
• theta: azimuth angle in radians (0 = +X direction, π/2 = +Y direction)
• distance: distance from the origin

pub fn set_spherical( &mut self, phi: f64, theta: f64, distance: f64, target: DVec3, ) -> &mut Self

Position the camera using spherical coordinates (Z-up) around a target point.

• phi: polar angle from +Z axis in radians (0 = straight up along +Z, π/2 = XY plane)
• theta: azimuth angle in radians (0 = +X direction, π/2 = +Y direction)
• distance: distance from target
• target: the point the camera looks at

pub fn look_at(&mut self, target: DVec3) -> &mut Self

Set the camera to look at a target point.

pub fn orbit( &mut self, target: DVec3, total_angle: f64, ) -> impl Eval<Output = Self> + Placeable + use<>

Create an orbit animation that rotates the camera around target by total_angle radians in the XY plane (Z-up).

The camera’s current position is used to derive the spherical coordinates (distance, elevation) which are kept constant during the orbit.

Example

use std::f64::consts::TAU;

let mut cam = CameraFrame::from_spherical(phi, theta, distance);
r.play(
    cam.orbit(DVec3::ZERO, TAU)
        .with_duration(8.0)
        .with_rate_func(linear),
);

impl CameraFrame

pub fn center_canvas_in_frame( &mut self, center: DVec3, width: f64, height: f64, up: DVec3, normal: DVec3, aspect_ratio: f64, ) -> &mut Self

Center the canvas in the frame when CameraFrame::perspective_blend is 1.0

Trait Implementations

impl Alignable for CameraFrame

fn is_aligned(&self, _other: &Self) -> bool

Checking if two items are aligned

fn align_with(&mut self, _other: &mut Self)

Aligning two items

impl Clone for CameraFrame

fn clone(&self) -> CameraFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for CameraFrame

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>].

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Self>>

Returns [ComponentRelationshipAccessor] required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add [ComponentHook] for this [Component] if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert [ComponentHook] for this [Component] if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard [ComponentHook] for this [Component] if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove [ComponentHook] for this [Component] if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn [ComponentHook] for this [Component] if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given [EntityMapper]. This is used to remap entities in contexts like scenes and entity cloning. When deriving [Component], this is populated by annotating fields containing entities with #[entities]

impl Debug for CameraFrame

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

Formats the value using the given formatter.

impl Default for CameraFrame

fn default() -> Self

Returns the “default value” for a type.

impl Extract for CameraFrame

type Target = CoreItem

Extraction target.

fn extract_into(&self, buf: &mut Vec<Self::Target>)

Append extracted values to buf.

fn extract(&self) -> Vec<Self::Target>

Extract into a newly allocated vector.

impl Interpolatable for CameraFrame

fn lerp(&self, target: &Self, t: f64) -> Self

Lerping between values

impl PartialEq for CameraFrame

fn eq(&self, other: &CameraFrame) -> 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 StructuralPartialEq for CameraFrame