Module luminance::buffer[−][src]

Static GPU typed arrays.

A GPU buffer is a typed continuous region of data. It has a size and can hold several elements.

Buffers are created with the new associated function. You pass in the number of elements you want in the buffer along with the GraphicsContext to create the buffer in.

ⓘThis example is not tested
let buffer: Buffer<f32> = Buffer::new(&mut ctx, 5);

Once the buffer is created, you can perform several operations on them:

  • Writing to them.
  • Reading from them.
  • Passing them around as uniforms.
  • Etc.

However, you cannot change their size at runtime.

Writing to a buffer

Buffers support several write methods. The simple one is clearing. That is, replacing the whole content of the buffer with a single value. Use the clear function to do so.

ⓘThis example is not tested
buffer.clear(0.);

If you want to clear the buffer by providing a value for each elements, you want filling. Use the fill function:

ⓘThis example is not tested
buffer.fill([1., 2., 3., 4., 5.]);

You want to change a value at a given index? Easy, you can use the set function:

ⓘThis example is not tested
buffer.set(3, 3.14);

Reading from the buffer

You can either retrieve the whole content of the Buffer or get a value with an index.

ⓘThis example is not tested
// get the whole content
let all_elems = buffer.whole();
assert_eq!(all_elems, vec![1., 2., 3., 3.14, 5.]); // admit floating equalities

// get the element at index 3
assert_eq!(buffer.at(3), Some(3.14));

Uniform buffer

It’s possible to use buffers as uniform buffers. That is, buffers that will be in bound at rendering time and which content will be available for a shader to read (no write).

In order to use your buffers in a uniform context, the inner type has to implement UniformBlock. Keep in mind alignment must be respected and is a bit peculiar. TODO: explain std140 here.

Structs

Buffer

A Buffer is a GPU region you can picture as an array. It has a static size and cannot be resized. The size is expressed in number of elements lying in the buffer – not in bytes.
BufferSlice

A buffer slice mapped into GPU memory.
BufferSliceMut

A buffer mutable slice into GPU memory.
RawBuffer

Raw buffer. Any buffer can be converted to that type. However, keep in mind that even though type erasure is safe, creating a buffer from a raw buffer is not.

Enums

BufferError

Buffer errors.

Traits

UniformBlock

Typeclass of types that can be used inside a uniform block. You have to be extra careful when using uniform blocks and ensure you respect the OpenGL std140 alignment / size rules. This will be fixed in a future release.