Struct datafrost::Data

pub struct Data<K: Kind> { /* private fields */ }

References an object of a specific Kind. The object is backed by a single primary format and some number of derived formats.

Implementations

impl<K: Kind> Data<K>

pub fn view<F: Format<Kind = K>>(&self) -> View<F>

Creates a view of this data of the given format and mutability. The format must either be the primary format or one of the derived formats specified during object creation. If this is a mutable view, then the format must be the primary format. Using views with invalid mutability or formats will lead to panics when DataFrostContext::submit is called.

Examples found in repository

examples/derived.rs (line 88)

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<K: Kind> Clone for Data<K>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Kind> Debug for Data<K>

where K::FormatDescriptor: Debug,

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

Formats the value using the given formatter.

impl<K: Kind> Deref for Data<K>

type Target = <K as Kind>::FormatDescriptor

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.