Struct bevy::render::camera::Camera

pub struct Camera {
    pub viewport: Option<Viewport>,
    pub priority: isize,
    pub is_active: bool,
    pub computed: ComputedCameraValues,
    pub target: RenderTarget,
    pub hdr: bool,
}

Expand description

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.

Adding a camera is typically done by adding a bundle, either the Camera2dBundle or the Camera3dBundle.

Fields§

§viewport: Option<Viewport>

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

§priority: isize

Cameras with a lower priority will be rendered before cameras with a higher priority.

§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.

§target: RenderTarget

The “target” that this camera will render to.

§hdr: bool

If this is set to true, the camera will use an intermediate “high dynamic range” render texture. Warning: we are still working on this feature. If MSAA is enabled, there will be artifacts in some cases. When rendering with WebGL, this will crash if MSAA is enabled. See https://github.com/bevyengine/bevy/pull/3425 for details.

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<(UVec2, UVec2)>

The rendered physical bounds (minimum, maximum) 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<(Vec2, Vec2)>

The rendered logical bounds (minimum, maximum) 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.

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

The physical 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 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, 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 projection_matrix(&self) -> Mat4

The projection matrix computed using this camera’s CameraProjection.

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

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.

pub fn viewport_to_world(
 &self,
 camera_transform: &GlobalTransform,
 viewport_position: Vec2
) -> Option<Ray>

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.

pub fn world_to_ndc(
 &self,
 camera_transform: &GlobalTransform,
 world_position: Vec3
) -> Option<Vec3>

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

When the position is within the viewport the values returned will be between -1.0 and 1.0 on the X and Y axes, and between 0.0 and 1.0 on the Z axis. To get the coordinates in the render target’s viewport dimensions, you should use world_to_viewport.

pub fn ndc_to_world(
 &self,
 camera_transform: &GlobalTransform,
 ndc: Vec3
) -> Option<Vec3>

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

When the position is within the viewport the values returned will be between -1.0 and 1.0 on the X and Y axes, and between 0.0 and 1.0 on the Z axis. To get the world space coordinates with the viewport position, you should use world_to_viewport.