Struct datafrost::Derived

pub struct Derived<F: Format> { /* private fields */ }

Marks a derived format that should be accessible and kept automatically up-to-date when the parent object changes.

Implementations

impl<F: Format> Derived<F>

pub fn new<D: DerivedDescriptor<F>>(descriptor: D) -> Self

Specifies how a derived object should be created to track an object of type F.

Examples found in repository

examples/derived.rs (line 78)

fn main() {
    // Create a new context.
    let ctx = DataFrostContext::new(ContextDescriptor {
        label: Some("my context"),
    });

    // Allocate a new primary array object, which has a doubled
    // array as a derived format.
    let data = ctx.allocate::<PrimaryArray>(AllocationDescriptor {
        descriptor: NumberArrayDescriptor { len: 7 },
        label: Some("my data"),
        derived_formats: &[Derived::new(DoublePrimaryArray)],
    });

    // Create a command buffer to record operations to execute
    // on our data.
    let mut command_buffer = CommandBuffer::new(CommandBufferDescriptor {
        label: Some("my command buffer"),
    });

    // Schedule a command to fill the primary number array with some data.
    let view = data.view::<PrimaryArray>();
    let view_clone = view.clone();
    command_buffer.schedule(CommandDescriptor {
        label: Some("fill array"),
        views: &[&view.as_mut(4..6)],
        command: move |ctx| ctx.get_mut(&view_clone).0[4..6].fill(33),
    });

    // Schedule a command to map the contents of the derived acceleration structure
    // so that we may view them synchronously.
    let derived = command_buffer.map(&data.view::<DoubledArray>().as_const());

    // Submit the buffer for processing.
    ctx.submit(command_buffer);

    // The doubled acceleration structure automatically contains the
    // correct, up-to-date data!
    assert_eq!(&[0, 0, 0, 0, 66, 66, 0], &ctx.get(&derived).0[..]);
}

Trait Implementations

impl<F: Format> Clone for Derived<F>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Format> Debug for Derived<F>

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

Formats the value using the given formatter.