Struct rendy_graph::present::PresentBuilder

pub struct PresentBuilder<B: Backend> { /* fields omitted */ }

Presentation node description.

Implementations

impl<B> PresentBuilder<B> where
    B: Backend, 

pub fn add_dependency(&mut self, dependency: NodeId) -> &mut Self

Add dependency. Node will be placed after its dependencies.

pub fn with_dependency(self, dependency: NodeId) -> Self

Add dependency. Node will be placed after its dependencies.

pub fn with_image_count(self, image_count: u32) -> Self

Request a number of images in the swapchain. This is not guaranteed to be the final image count, but it will be if supported by the hardware.

Check PresentBuilder::image_count() after calling this function but before building to see the final image count.

pub fn with_blit_filter(self, filter: Filter) -> Self

Set up filter used for resizing when backbuffer size does not match source image size.

Default is Nearest.

pub fn with_present_modes_priority<PF>(self, present_modes_priority: PF) -> Self where
    PF: Fn(PresentMode) -> Option<usize>, 

Request a priority of present modes when creating the swapchain for the PresentNode. Lower index means higher priority.

Check PresentBuilder::present_mode() after calling this function but before building to see the final present mode.

Parameters

• present_modes_priority: A function which takes a rendy_core::hal::PresentMode and returns an Option<usize>. None indicates not to use this mode, and a higher number returned indicates a higher prioirity for that mode.

Panics

• Panics if none of the provided PresentModes are supported.

pub fn image_count(&self) -> u32

Get image count in presentable swapchain.

pub fn present_mode(&self) -> PresentMode

Get present mode used by node.

Trait Implementations

impl<B: Debug + Backend> Debug for PresentBuilder<B>

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

Formats the value using the given formatter.

impl<B, T> NodeBuilder<B, T> for PresentBuilder<B> where
    B: Backend,
    T: ?Sized, 

fn family(
    &self,
    factory: &mut Factory<B>,
    families: &Families<B>
) -> Option<FamilyId>

Pick family for this node to be executed onto.

fn buffers(&self) -> Vec<(BufferId, BufferAccess)>

Get buffer accessed by the node.

fn images(&self) -> Vec<(ImageId, ImageAccess)>

Get images accessed by the node.

fn dependencies(&self) -> Vec<NodeId>

Indices of nodes this one dependes on.

fn build<'a>(
    self: Box<Self>,
    ctx: &GraphContext<B>,
    factory: &mut Factory<B>,
    family: &mut Family<B>,
    _queue: usize,
    _aux: &T,
    buffers: Vec<NodeBuffer>,
    images: Vec<NodeImage>
) -> Result<Box<dyn DynNode<B, T>>, NodeBuildError>

Build node.