Struct Camera 

pub struct Camera {
    pub viewport: Option<Viewport>,
    pub order: isize,
    pub is_active: bool,
    pub computed: ComputedCameraValues,
    pub output_mode: CameraOutputMode,
    pub msaa_writeback: MsaaWriteback,
    pub clear_color: ClearColorConfig,
    pub invert_culling: bool,
    pub sub_camera_view: Option<SubCameraView>,
}

The defining Component for camera entities, storing information about how and what to render through this camera.

The Camera component is added to an entity to define the properties of the viewpoint from which rendering occurs. It defines the position of the view to render, the projection method to transform the 3D objects into a 2D image, as well as the render target into which that image is produced.

Note that a Camera needs a CameraRenderGraph to render anything. This is typically provided by adding a Camera2d or Camera3d component, but custom render graphs can also be defined. Inserting a Camera with no render graph will emit an error at runtime.

Fields

viewport: Option<Viewport>

If set, this camera will render to the given Viewport rectangle within the configured RenderTarget.

order: isize

Cameras with a higher order are rendered later, and thus on top of lower order cameras.

is_active: bool

If this is set to true, this camera will be rendered to its specified RenderTarget. If false, this camera will not be rendered.

computed: ComputedCameraValues

Computed values for this camera, such as the projection matrix and the render target size.

output_mode: CameraOutputMode

The CameraOutputMode for this camera.

msaa_writeback: MsaaWriteback

Controls when MSAA writeback occurs for this camera. See MsaaWriteback for available options.

clear_color: ClearColorConfig

The clear color operation to perform on the render target.

invert_culling: bool

Whether to switch culling mode so that materials that request backface culling cull front faces, and vice versa.

This is typically used for cameras that mirror the world that they render across a plane, because doing that flips the winding of each polygon.

This setting doesn’t affect materials that disable backface culling.

sub_camera_view: Option<SubCameraView>

If set, this camera will be a sub camera of a large view, defined by a SubCameraView.

Implementations

impl Camera

pub fn to_logical(&self, physical_size: UVec2) -> Option<Vec2>

Converts a physical size in this Camera to a logical size.

pub fn physical_viewport_rect(&self) -> Option<URect>

The rendered physical bounds URect of the camera. If the viewport field is set to Some, this will be the rect of that custom viewport. Otherwise it will default to the full physical rect of the current RenderTarget.

pub fn logical_viewport_rect(&self) -> Option<Rect>

The rendered logical bounds Rect of the camera. If the viewport field is set to Some, this will be the rect of that custom viewport. Otherwise it will default to the full logical rect of the current RenderTarget.

pub fn logical_viewport_size(&self) -> Option<Vec2>

The logical size of this camera’s viewport. If the viewport field is set to Some, this will be the size of that custom viewport. Otherwise it will default to the full logical size of the current RenderTarget. For logic that requires the full logical size of the RenderTarget, prefer Camera::logical_target_size.

Returns None if either:

• the function is called just after the Camera is created, before camera_system is executed,
• the RenderTarget isn’t correctly set:
  • it references the PrimaryWindow when there is none,
  • it references a Window entity that doesn’t exist or doesn’t actually have a Window component,
  • it references an Image that doesn’t exist (invalid handle),
  • it references a TextureView that doesn’t exist (invalid handle).

pub fn physical_viewport_size(&self) -> Option<UVec2>

The physical size of this camera’s viewport (in physical pixels). If the viewport field is set to Some, this will be the size of that custom viewport. Otherwise it will default to the full physical size of the current RenderTarget. For logic that requires the full physical size of the RenderTarget, prefer Camera::physical_target_size.

pub fn logical_target_size(&self) -> Option<Vec2>

The full logical size of this camera’s RenderTarget, ignoring custom viewport configuration. Note that if the viewport field is Some, this will not represent the size of the rendered area. For logic that requires the size of the actually rendered area, prefer Camera::logical_viewport_size.

pub fn physical_target_size(&self) -> Option<UVec2>

The full physical size of this camera’s RenderTarget (in physical pixels), ignoring custom viewport configuration. Note that if the viewport field is Some, this will not represent the size of the rendered area. For logic that requires the size of the actually rendered area, prefer Camera::physical_viewport_size.

pub fn target_scaling_factor(&self) -> Option<f32>

pub fn clip_from_view(&self) -> Mat4

The projection matrix computed using this camera’s Projection.

pub fn world_to_viewport( &self, camera_transform: &GlobalTransform, world_position: Vec3, ) -> Result<Vec2, ViewportConversionError>

Given a position in world space, use the camera to compute the viewport-space coordinates.

To get the coordinates in Normalized Device Coordinates, you should use world_to_ndc.

Panics

Will panic if glam_assert is enabled and the camera_transform contains NAN (see world_to_ndc).

Examples found in repository

examples/2d/2d_viewport_to_world.rs (line 33)

fn draw_cursor(
    camera_query: Single<(&Camera, &GlobalTransform)>,
    window: Single<&Window>,
    mut gizmos: Gizmos,
) {
    let (camera, camera_transform) = *camera_query;

    if let Some(cursor_position) = window.cursor_position()
        // Calculate a world position based on the cursor's position.
        && let Ok(world_pos) = camera.viewport_to_world_2d(camera_transform, cursor_position)
        // To test Camera::world_to_viewport, convert result back to viewport space and then back to world space.
        && let Ok(viewport_check) = camera.world_to_viewport(camera_transform, world_pos.extend(0.0))
        && let Ok(world_check) = camera.viewport_to_world_2d(camera_transform, viewport_check.xy())
    {
        gizmos.circle_2d(world_pos, 10., WHITE);
        // Should be the same as world_pos
        gizmos.circle_2d(world_check, 8., RED);
    }
}

examples/3d/blend_modes.rs (line 324)

fn example_control_system(
    mut materials: ResMut<Assets<StandardMaterial>>,
    controllable: Query<(&MeshMaterial3d<StandardMaterial>, &ExampleControls)>,
    camera: Single<
        (
            Entity,
            &mut Camera,
            &mut Transform,
            &GlobalTransform,
            Has<Hdr>,
        ),
        With<Camera3d>,
    >,
    mut labels: Query<(&mut Node, &ExampleLabel)>,
    mut display: Single<&mut Text, With<ExampleDisplay>>,
    labeled: Query<&GlobalTransform>,
    mut state: Local<ExampleState>,
    time: Res<Time>,
    input: Res<ButtonInput<KeyCode>>,
    mut commands: Commands,
) {
    if input.pressed(KeyCode::ArrowUp) {
        state.alpha = (state.alpha + time.delta_secs()).min(1.0);
    } else if input.pressed(KeyCode::ArrowDown) {
        state.alpha = (state.alpha - time.delta_secs()).max(0.0);
    }

    if input.just_pressed(KeyCode::Space) {
        state.unlit = !state.unlit;
    }

    let randomize_colors = input.just_pressed(KeyCode::KeyC);

    for (material_handle, controls) in &controllable {
        let mut material = materials.get_mut(material_handle).unwrap();

        if controls.color && randomize_colors {
            material.base_color = Srgba {
                red: random(),
                green: random(),
                blue: random(),
                alpha: state.alpha,
            }
            .into();
        } else {
            material.base_color.set_alpha(state.alpha);
        }

        if controls.unlit {
            material.unlit = state.unlit;
        }
    }

    let (entity, camera, mut camera_transform, camera_global_transform, hdr) = camera.into_inner();

    if input.just_pressed(KeyCode::KeyH) {
        if hdr {
            commands.entity(entity).remove::<Hdr>();
        } else {
            commands.entity(entity).insert(Hdr);
        }
    }

    let rotation = if input.pressed(KeyCode::ArrowLeft) {
        time.delta_secs()
    } else if input.pressed(KeyCode::ArrowRight) {
        -time.delta_secs()
    } else {
        0.0
    };

    camera_transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(rotation));

    for (mut node, label) in &mut labels {
        let world_position = labeled.get(label.entity).unwrap().translation() + Vec3::Y;

        let viewport_position = camera
            .world_to_viewport(camera_global_transform, world_position)
            .unwrap();

        node.top = px(viewport_position.y);
        node.left = px(viewport_position.x);
    }

    display.0 = format!(
        "  HDR: {}\nAlpha: {:.2}",
        if hdr { "ON " } else { "OFF" },
        state.alpha
    );
}

pub fn world_to_viewport_with_depth( &self, camera_transform: &GlobalTransform, world_position: Vec3, ) -> Result<Vec3, ViewportConversionError>

Given a position in world space, use the camera to compute the viewport-space coordinates and depth.

To get the coordinates in Normalized Device Coordinates, you should use world_to_ndc.

Panics

Will panic if glam_assert is enabled and the camera_transform contains NAN (see world_to_ndc).

pub fn viewport_to_world( &self, camera_transform: &GlobalTransform, viewport_position: Vec2, ) -> Result<Ray3d, ViewportConversionError>

Returns a ray originating from the camera, that passes through everything beyond viewport_position.

The resulting ray starts on the near plane of the camera.

If the camera’s projection is orthographic the direction of the ray is always equal to camera_transform.forward().

To get the world space coordinates with Normalized Device Coordinates, you should use ndc_to_world.

Example

fn system(camera_query: Single<(&Camera, &GlobalTransform)>, window: Single<&Window>) {
    let (camera, camera_transform) = *camera_query;

    if let Some(cursor_position) = window.cursor_position()
        // Calculate a ray pointing from the camera into the world based on the cursor's position.
        && let Ok(ray) = camera.viewport_to_world(camera_transform, cursor_position)
    {
        println!("{ray:?}");
    }
}

// Run the system after transform propagation so the camera's global transform is up-to-date.
app.add_systems(PostUpdate, system.after(TransformSystems::Propagate));

Panics

Will panic if the camera’s projection matrix is invalid (has a determinant of 0) and glam_assert is enabled (see ndc_to_world.

Examples found in repository

examples/ecs/observers.rs (line 203)

fn handle_click(
    mouse_button_input: Res<ButtonInput<MouseButton>>,
    camera: Single<(&Camera, &GlobalTransform)>,
    windows: Query<&Window>,
    mut commands: Commands,
) {
    let Ok(windows) = windows.single() else {
        return;
    };

    let (camera, camera_transform) = *camera;
    if let Some(pos) = windows
        .cursor_position()
        .and_then(|cursor| camera.viewport_to_world(camera_transform, cursor).ok())
        .map(|ray| ray.origin.truncate())
        && mouse_button_input.just_pressed(MouseButton::Left)
    {
        commands.trigger(ExplodeMines { pos, radius: 1.0 });
    }
}

examples/3d/3d_viewport_to_world.rs (line 23)

fn draw_cursor(
    camera_query: Single<(&Camera, &GlobalTransform)>,
    ground: Single<&GlobalTransform, With<Ground>>,
    window: Single<&Window>,
    mut gizmos: Gizmos,
) {
    let (camera, camera_transform) = *camera_query;

    if let Some(cursor_position) = window.cursor_position()
        // Calculate a ray pointing from the camera into the world based on the cursor's position.
        && let Ok(ray) = camera.viewport_to_world(camera_transform, cursor_position)
        // Calculate if and where the ray is hitting the ground plane.
        && let Some(point) = ray.plane_intersection_point(ground.translation(), InfinitePlane3d::new(ground.up()))
    {
        // Draw a circle just above the ground plane at that position.
        gizmos.circle(
            Isometry3d::new(
                point + ground.up() * 0.01,
                Quat::from_rotation_arc(Vec3::Z, ground.up().as_vec3()),
            ),
            0.2,
            Color::WHITE,
        );
    }
}

examples/3d/irradiance_volumes.rs (line 469)

fn handle_mouse_clicks(
    buttons: Res<ButtonInput<MouseButton>>,
    windows: Query<&Window, With<PrimaryWindow>>,
    cameras: Query<(&Camera, &GlobalTransform)>,
    mut main_objects: Query<&mut Transform, With<MainObject>>,
) {
    if !buttons.pressed(MouseButton::Left) {
        return;
    }
    let Some(mouse_position) = windows.iter().next().and_then(Window::cursor_position) else {
        return;
    };
    let Some((camera, camera_transform)) = cameras.iter().next() else {
        return;
    };

    // Figure out where the user clicked on the plane.
    let Ok(ray) = camera.viewport_to_world(camera_transform, mouse_position) else {
        return;
    };
    let Some(plane_intersection) =
        ray.plane_intersection_point(Vec3::ZERO, InfinitePlane3d::new(Vec3::Y))
    else {
        return;
    };
    // Move all the main objects.
    for mut transform in main_objects.iter_mut() {
        transform.translation = vec3(
            plane_intersection.x,
            transform.translation.y,
            plane_intersection.z,
        );
    }
}

examples/3d/mirror.rs (line 478)

fn move_fox_on_mouse_down(
    mut scene_roots_query: Query<&mut Transform, With<WorldAssetRoot>>,
    windows_query: Query<&Window, With<PrimaryWindow>>,
    cameras_query: Query<(&Camera, &GlobalTransform)>,
    interactions_query: Query<&Interaction, With<RadioButton>>,
    buttons: Res<ButtonInput<MouseButton>>,
    app_status: Res<AppStatus>,
) {
    // Only process the mouse motion if the left mouse button is pressed, the
    // mouse action is set to move the fox, and the pointer isn't over a UI
    // widget.
    if app_status.drag_action != DragAction::MoveFox
        || !buttons.pressed(MouseButton::Left)
        || interactions_query
            .iter()
            .any(|interaction| *interaction != Interaction::None)
    {
        return;
    }

    // Find out where the user clicked the mouse.
    let Some(mouse_position) = windows_query
        .iter()
        .next()
        .and_then(Window::cursor_position)
    else {
        return;
    };

    // Grab the camera.
    let Some((camera, camera_transform)) = cameras_query.iter().next() else {
        return;
    };

    // Figure out where the user clicked on the plane.
    let Ok(ray) = camera.viewport_to_world(camera_transform, mouse_position) else {
        return;
    };
    let Some(ray_distance) = ray.intersect_plane(Vec3::ZERO, InfinitePlane3d::new(Vec3::Y)) else {
        return;
    };
    let plane_intersection = ray.origin + ray.direction.normalize() * ray_distance;

    // Move the fox.
    for mut transform in scene_roots_query.iter_mut() {
        transform.translation = transform.translation.with_xz(plane_intersection.xz());
    }
}

pub fn viewport_to_world_2d( &self, camera_transform: &GlobalTransform, viewport_position: Vec2, ) -> Result<Vec2, ViewportConversionError>

Returns a 2D world position computed from a position on this Camera’s viewport.

Useful for 2D cameras and other cameras with an orthographic projection pointing along the Z axis.

To get the world space coordinates with Normalized Device Coordinates, you should use ndc_to_world.

Example

fn system(camera_query: Single<(&Camera, &GlobalTransform)>, window: Single<&Window>) {
    let (camera, camera_transform) = *camera_query;

    if let Some(cursor_position) = window.cursor_position()
        // Calculate a world position based on the cursor's position.
        && let Ok(world_pos) = camera.viewport_to_world_2d(camera_transform, cursor_position)
    {
        println!("World position: {world_pos:.2}");
    }
}

// Run the system after transform propagation so the camera's global transform is up-to-date.
app.add_systems(PostUpdate, system.after(TransformSystems::Propagate));

Panics

Will panic if the camera’s projection matrix is invalid (has a determinant of 0) and glam_assert is enabled (see ndc_to_world.

Examples found in repository

examples/showcase/desk_toy.rs (line 214)

fn get_cursor_world_pos(
    mut cursor_world_pos: ResMut<CursorWorldPos>,
    primary_window: Single<&Window, With<PrimaryWindow>>,
    q_camera: Single<(&Camera, &GlobalTransform)>,
) {
    let (main_camera, main_camera_transform) = *q_camera;
    // Get the cursor position in the world
    cursor_world_pos.0 = primary_window.cursor_position().and_then(|cursor_pos| {
        main_camera
            .viewport_to_world_2d(main_camera_transform, cursor_pos)
            .ok()
    });
}

examples/asset/asset_saving_with_subassets.rs (line 280)

fn spawn_box(
    event: On<Pointer<Press>>,
    window: Query<(), With<Window>>,
    camera: Single<(&Camera, &GlobalTransform)>,
    mut commands: Commands,
) {
    if event.button != PointerButton::Primary {
        return;
    }
    if !window.contains(event.entity) {
        return;
    }

    let (camera, camera_transform) = camera.into_inner();
    let Ok(click_point) =
        camera.viewport_to_world_2d(camera_transform, event.pointer_location.position)
    else {
        return;
    };
    commands.spawn((
        Sprite::from_color(tailwind::RED_500, Vec2::new(100.0, 100.0)),
        Transform::from_translation(click_point.extend(0.0)),
        Pickable::default(),
        Box,
    ));
}

examples/2d/2d_viewport_to_world.rs (line 31)

fn draw_cursor(
    camera_query: Single<(&Camera, &GlobalTransform)>,
    window: Single<&Window>,
    mut gizmos: Gizmos,
) {
    let (camera, camera_transform) = *camera_query;

    if let Some(cursor_position) = window.cursor_position()
        // Calculate a world position based on the cursor's position.
        && let Ok(world_pos) = camera.viewport_to_world_2d(camera_transform, cursor_position)
        // To test Camera::world_to_viewport, convert result back to viewport space and then back to world space.
        && let Ok(viewport_check) = camera.world_to_viewport(camera_transform, world_pos.extend(0.0))
        && let Ok(world_check) = camera.viewport_to_world_2d(camera_transform, viewport_check.xy())
    {
        gizmos.circle_2d(world_pos, 10., WHITE);
        // Should be the same as world_pos
        gizmos.circle_2d(world_check, 8., RED);
    }
}

examples/2d/rotate_to_cursor.rs (line 47)

fn player_movement_system(
    mut player: Single<&mut Transform, With<Player>>,
    camera_query: Single<(&Camera, &GlobalTransform)>,
    window: Single<&Window>,
) {
    let (camera, camera_transform) = *camera_query;

    if let Some(cursor_position) = window.cursor_position()
        // Calculate a world position based on the cursor's position.
        && let Ok(cursor_world_pos) = camera.viewport_to_world_2d(camera_transform, cursor_position)
    {
        // The angle an entity needs to rotate to face a point is defined
        // by the vector between the two points (Vec2 - Vec2), which we can then
        // turn into radians using to_angle.
        //
        // FRAC_PI_2 is because our sprite's ship is facing "up" so we rotate it an additional 90 degrees
        // so that it faces the cursor.
        player.rotation = Quat::from_rotation_z(
            (cursor_world_pos - player.translation.xy()).to_angle() - FRAC_PI_2,
        );
    }
}

examples/ecs/delayed_commands.rs (line 45)

fn click(
    click: On<Pointer<Click>>,
    mut commands: Commands,
    squares: Query<(Entity, &Transform), With<BlinkySquare>>,
    cameras: Query<(&Camera, &GlobalTransform)>,
) {
    let (camera, camera_transform) = cameras.single().unwrap();
    let mut delayed = commands.delayed();
    for (entity, transform) in squares.iter() {
        // convert the pointer position to world position
        let mouse_world_pos = camera
            .viewport_to_world_2d(camera_transform, click.pointer_location.position)
            .unwrap();

        // delay the blinkiness by distance to cursor
        let dist = mouse_world_pos.distance(transform.translation.truncate());
        let delay = dist / 1000.0;
        delayed
            .secs(delay)
            .entity(entity)
            .insert(Sprite::from_color(Color::WHITE, SQUARE_SIZE));
        delayed
            .secs(delay + 0.1)
            .entity(entity)
            .insert(Sprite::from_color(Color::BLACK, SQUARE_SIZE));
    }
}

examples/asset/asset_saving.rs (line 220)

fn try_plot(
    event: On<TryPlot>,
    sprite: Query<(&Sprite, &Anchor, &GlobalTransform), With<SpriteToSave>>,
    camera: Single<(&Camera, &GlobalTransform)>,
    texture_atlases: Res<Assets<TextureAtlasLayout>>,
    draw_color: Res<DrawColor>,
    mut images: ResMut<Assets<Image>>,
) {
    let Ok((sprite, anchor, sprite_transform)) = sprite.get(event.entity) else {
        return;
    };
    let (camera, camera_transform) = camera.into_inner();
    let Ok(world_position) = camera.viewport_to_world_2d(camera_transform, event.location.position)
    else {
        return;
    };
    let relative_to_sprite = sprite_transform
        .affine()
        .inverse()
        .transform_point3(world_position.extend(0.0));
    let Ok(pixel_space) = sprite.compute_pixel_space_point(
        relative_to_sprite.xy(),
        *anchor,
        &images,
        &texture_atlases,
    ) else {
        return;
    };
    let pixel_coordinates = pixel_space.floor().as_uvec2();
    let mut image = images.get_mut(&sprite.image).unwrap();
    // For an actual drawing app, you'd at least draw a line from the last point, but this is
    // simpler.
    image
        .set_color_at(pixel_coordinates.x, pixel_coordinates.y, draw_color.0)
        .unwrap();
}

Additional examples can be found in:

• examples/math/cubic_splines.rs

pub fn world_to_ndc<V>( &self, camera_transform: &GlobalTransform, world_point: V, ) -> Option<V>

where V: Into<Vec3A> + From<Vec3A>,

Given a point in world space, use the camera’s viewport to compute the Normalized Device Coordinates of the point.

When the point is within the viewport the values returned will be between -1.0 (bottom left) and 1.0 (top right) on the X and Y axes, and between 0.0 (far) and 1.0 (near) on the Z axis. To get the coordinates in the render target’s viewport dimensions, you should use world_to_viewport.

Returns None if the camera_transform, the world_position, or the projection matrix defined by Projection contain NAN.

Panics

Will panic if the camera_transform contains NAN and the glam_assert feature is enabled.

pub fn ndc_to_world<V>( &self, camera_transform: &GlobalTransform, ndc_point: V, ) -> Option<V>

where V: Into<Vec3A> + From<Vec3A>,

Given a position in Normalized Device Coordinates, use the camera’s viewport to compute the world space position.

The input is expected to be in NDC: x and y in the range [-1.0, 1.0], and z in [0.0, 1.0] (with z = 0.0 at the far plane and z = 1.0 at the near plane). The returned value is a position in world space (your game’s world units) and is not limited to [-1.0, 1.0]. To convert from a viewport position to world space, you should use viewport_to_world.

Returns None if the camera_transform, the ndc_point, or the projection matrix defined by Projection contain NAN.

Panics

Will panic if the projection matrix is invalid (has a determinant of 0) and glam_assert is enabled.

pub fn depth_ndc_to_view_z(&self, ndc_depth: f32) -> f32

Converts the depth in Normalized Device Coordinates to linear view z for perspective projections.

Note: Depth values in front of the camera will be negative as -z is forward

pub fn depth_ndc_to_view_z_2d(&self, ndc_depth: f32) -> f32

Converts the depth in Normalized Device Coordinates to linear view z for orthographic projections.

Note: Depth values in front of the camera will be negative as -z is forward

pub fn viewport_to_ndc( &self, viewport_position: Vec2, ) -> Result<Vec2, ViewportConversionError>

Converts a position in viewport coordinates to NDC.

Trait Implementations

impl Clone for Camera

fn clone(&self) -> Camera

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for Camera

where Camera: Send + Sync + 'static,

Required Components: Frustum, CameraMainTextureUsages, VisibleEntities, Transform, Visibility, RenderTarget.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

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<Camera>>

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 Camera

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

Formats the value using the given formatter.

impl Default for Camera

fn default() -> Camera

Returns the “default value” for a type.

impl FromArg for Camera

type This<'from_arg> = Camera

The type to convert into.

fn from_arg(arg: Arg<'_>) -> Result<<Camera as FromArg>::This<'_>, ArgError>

Creates an item from an argument.

impl FromReflect for Camera

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<Camera>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetOwnership for Camera

fn ownership() -> Ownership

Returns the ownership of Self.

impl GetTypeRegistration for Camera

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl IntoReturn for Camera

fn into_return<'into_return>(self) -> Return<'into_return>

where Camera: 'into_return,

Converts Self into a Return value.

impl PartialReflect for Camera

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Camera>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Camera>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Camera>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

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

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for Camera

fn into_any(self: Box<Camera>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Camera>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Struct for Camera

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for Camera

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Camera

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.