Struct Context

Source

pub struct Context(/* private fields */);

Expand description

The main dunge context.

Implementations§

Source §

impl Context

Source

pub fn make_shader<I, S>(&self, render: Render<I, S>) -> Shader<I, S>

Source

pub fn make_set<I, G, const N: usize>( &self, shader: &Shader<I, G::Inner>, set: G, ) -> UniqueSet<G::Inner>
where G: Groups<N>,

Source

pub fn make_uniform<V>(&self, value: &V) -> Uniform<V>
where V: Value + Bytes,

Creates a uniform from the given value.

Source

pub fn make_storage<V>(&self, value: &V) -> Option<Storage<V>>
where V: StorageValue + ?Sized,

Creates a storage from the given value.

Source

pub fn make_layer<V, I, S, C>( &self, shader: &RenderShader<S, V, I>, conf: C, ) -> Layer<Input<V, I, S>>
where C: Into<Config>,

Creates a layer for the given render shader.

This method also accepts a config which defines the layer’s properties.

Source

pub fn make_mesh<V>(&self, data: &MeshData<'_, V>) -> Mesh<V>
where V: Bytes,

Creates a mesh with the given data.

Source

pub fn make_row<V>(&self, value: &[V]) -> Option<Row<V>>
where V: Value + Bytes,

Creates a row with the given data.

Source

pub fn make_texture(&self, data: TextureData<'_, U>) -> TextureBuffer<2, U>
where U: TextureUsages,

Creates a 2D texture with the given data.

Source

pub fn make_sampler(&self, filter: Filter) -> TextureSampler

Creates a sampler with the filter value.

Source

pub fn make_buffer(&self, data: BufferData<'_, U>) -> Buffer
where U: BufferUsages,

Creates a buffer with the given data.

§Examples

use dunge::buffer::BufferData;

let cx = dunge::context().await?;

// Create a buffer filled with four `i32` numbers
let data = BufferData::new(&[1, 2, 3, 4])
    .read()     // set a usage to read from the buffer
    .copy_to(); // set a usage to copy to the buffer

let buffer = cx.make_buffer(data);

Source

pub async fn read<'buf, U>( &self, buf: &'buf mut Buffer, ) -> Result<Read<'buf>, ReadFailed>
where U: Read,

Reads from a buffer.

Source

pub async fn write<'buf, U>( &self, buf: &'buf mut Buffer, ) -> Result<Write<'buf>, WriteFailed>
where U: Write,

Writes to a buffer.

Source

pub async fn shed<F>(&self, f: F)
where F: FnOnce(&mut Scheduler),

Runs a closure that schedules GPU work.

The closure receives a scheduler object capable of scheduling various GPU operations, such as rendering, compute, or data copying. All scheduled operations will begin executing as soon as possible. This function is asynchronous and awaiting it will wait until all scheduled operations have completed.

§Examples

Typical window render loop:

use dunge::Options;

let cx = dunge::context().await?;
let (window, layer, mesh) = ..

loop {
    let redraw = window.redraw().await;

    cx.shed(|s| {
        let opts = Options::default();
        s.render(&redraw, opts).layer(&layer).draw(&mesh);
    })
    .await;

    redraw.present();
}