Struct VertexBufferSlice

pub struct VertexBufferSlice<'b, T>
where
    T: 'b + Copy,
{ /* private fields */ }

Represents a slice of a VertexBuffer.

Implementations

impl<'b, T> VertexBufferSlice<'b, T>

where T: 'b + Copy + Content,

pub fn per_instance(&'b self) -> Result<PerInstance<'b>, InstancingNotSupported>

Creates a marker that instructs glium to use multiple instances.

Instead of calling surface.draw(&vertex_buffer.slice(...).unwrap(), ...) you can call surface.draw(vertex_buffer.slice(...).unwrap().per_instance(), ...). This will draw one instance of the geometry for each element in this buffer slice. The attributes are still passed to the vertex shader, but each entry is passed for each different instance.

Methods from Deref<Target = BufferSlice<'a, [T]>>

pub fn get_size(&self) -> usize

Returns the size in bytes of this slice.

pub fn get_context(&self) -> &Rc<Context>

Returns the context corresponding to this buffer.

pub fn write(&self, data: &T)

Uploads some data in this buffer.

Implementation

• For persistent-mapped buffers, waits untils the data is no longer used by the GPU then memcpies the data to the mapping.
• For immutable buffers, creates a temporary buffer that contains the data then calls glCopyBufferSubData to copy from the temporary buffer to the real one.
• For other types, calls glBufferSubData.

Panic

Panics if the length of data is different from the length of this buffer.

pub fn invalidate(&self)

Invalidates the content of the slice. The data becomes undefined.

This operation is a no-op if the backend doesn’t support it and for persistent-mapped buffers.

Implementation

Calls glInvalidateBufferSubData if supported.

pub fn read(&self) -> Result<<T as Content>::Owned, ReadError>

Reads the content of the buffer.

pub fn copy_to<S>(&self, target: S) -> Result<(), CopyError>

where S: Into<BufferSlice<'a, T>>,

Copies the content of this slice to another slice.

Panic

Panics if T is unsized and the other buffer is too small.

pub unsafe fn slice_custom<F, R>(&self, f: F) -> BufferSlice<'a, R>

where F: for<'r> FnOnce(&'r T) -> &'r R, R: Content + ?Sized,

Builds a slice that contains an element from inside the buffer.

This method builds an object that represents a slice of the buffer. No actual operation OpenGL is performed.

Example

#[derive(Copy, Clone)]
struct BufferContent {
    value1: u16,
    value2: u16,
}
let slice = unsafe { buffer.slice_custom(|content| &content.value2) };

Safety

The object whose reference is passed to the closure is uninitialized. Therefore you must not access the content of the object.

You must return a reference to an element from the parameter. The closure must not panic.

pub fn as_slice_any(&self) -> BufferAnySlice<'a>

Builds a slice-any containing the whole subbuffer.

This method builds an object that represents a slice of the buffer. No actual operation OpenGL is performed.

pub fn len(&self) -> usize

Returns the number of elements in this slice.

pub fn slice<R>(&self, range: R) -> Option<BufferSlice<'a, [T]>>

where R: RangeArgument<usize>,

Builds a subslice of this slice. Returns None if out of range.

This method builds an object that represents a slice of the buffer. No actual operation OpenGL is performed.

pub fn read_as_texture_1d<S>(&self) -> Result<S, ReadError>

where S: Texture1dDataSink<T>,

Reads the content of the buffer.

Trait Implementations

impl<'a, T> Deref for VertexBufferSlice<'a, T>

where T: Copy,

type Target = BufferSlice<'a, [T]>

The resulting type after dereferencing.

fn deref(&self) -> &BufferSlice<'a, [T]>

Dereferences the value.

impl<'a, T> DerefMut for VertexBufferSlice<'a, T>

where T: Copy,

fn deref_mut(&mut self) -> &mut BufferSlice<'a, [T]>

Mutably dereferences the value.

impl<'a, T> From<VertexBufferSlice<'a, T>> for BufferSlice<'a, [T]>

where T: Copy,

fn from(b: VertexBufferSlice<'a, T>) -> BufferSlice<'a, [T]>

Converts to this type from the input type.

impl<'a, T> Into<VerticesSource<'a>> for VertexBufferSlice<'a, T>

where T: Copy,

fn into(self) -> VerticesSource<'a>

Converts this type into the (usually inferred) input type.