Struct processing::vertex::VertexBuffer

pub struct VertexBuffer<T> where
    T: Copy,  { /* fields omitted */ }

A list of vertices loaded in the graphics card's memory.

Methods

impl<T> VertexBuffer<T> where
    T: Vertex, 

pub fn new<F>(facade: &F, data: &[T]) -> Result<VertexBuffer<T>, CreationError> where
    F: Facade + ?Sized, 

Builds a new vertex buffer.

Note that operations such as write will be very slow. If you want to modify the buffer from time to time, you should use the dynamic function instead.

Example

#[derive(Copy, Clone)]
struct Vertex {
    position: [f32; 3],
    texcoords: [f32; 2],
}

implement_vertex!(Vertex, position, texcoords);

let vertex_buffer = glium::VertexBuffer::new(&display, &[
    Vertex { position: [0.0,  0.0, 0.0], texcoords: [0.0, 1.0] },
    Vertex { position: [5.0, -3.0, 2.0], texcoords: [1.0, 0.0] },
]);

pub fn dynamic<F>(
    facade: &F,
    data: &[T]
) -> Result<VertexBuffer<T>, CreationError> where
    F: Facade + ?Sized, 

Builds a new vertex buffer.

This function will create a buffer that is intended to be modified frequently.

pub fn persistent<F>(
    facade: &F,
    data: &[T]
) -> Result<VertexBuffer<T>, CreationError> where
    F: Facade + ?Sized, 

Builds a new vertex buffer.

pub fn immutable<F>(
    facade: &F,
    data: &[T]
) -> Result<VertexBuffer<T>, CreationError> where
    F: Facade + ?Sized, 

Builds a new vertex buffer.

pub fn empty<F>(
    facade: &F,
    elements: usize
) -> Result<VertexBuffer<T>, CreationError> where
    F: Facade + ?Sized, 

Builds an empty vertex buffer.

The parameter indicates the number of elements.

pub fn empty_dynamic<F>(
    facade: &F,
    elements: usize
) -> Result<VertexBuffer<T>, CreationError> where
    F: Facade + ?Sized, 

Builds an empty vertex buffer.

The parameter indicates the number of elements.

pub fn empty_persistent<F>(
    facade: &F,
    elements: usize
) -> Result<VertexBuffer<T>, CreationError> where
    F: Facade + ?Sized, 

Builds an empty vertex buffer.

The parameter indicates the number of elements.

pub fn empty_immutable<F>(
    facade: &F,
    elements: usize
) -> Result<VertexBuffer<T>, CreationError> where
    F: Facade + ?Sized, 

Builds an empty vertex buffer.

The parameter indicates the number of elements.

impl<T> VertexBuffer<T> where
    T: Copy, 

pub unsafe fn new_raw<F>(
    facade: &F,
    data: &[T],
    bindings: Cow<'static, [(Cow<'static, str>, usize, AttributeType, bool)]>,
    elements_size: usize
) -> Result<VertexBuffer<T>, CreationError> where
    F: Facade + ?Sized, 

Builds a new vertex buffer from an indeterminate data type and bindings.

Example

use std::borrow::Cow;

let bindings = Cow::Owned(vec![(
        Cow::Borrowed("position"), 0,
        glium::vertex::AttributeType::F32F32,
    ), (
        Cow::Borrowed("color"), 2 * ::std::mem::size_of::<f32>(),
        glium::vertex::AttributeType::F32,
    ),
]);

let data = vec![
    1.0, -0.3, 409.0,
    -0.4, 2.8, 715.0f32
];

let vertex_buffer = unsafe {
    glium::VertexBuffer::new_raw(&display, &data, bindings, 3 * ::std::mem::size_of::<f32>())
};

pub unsafe fn new_raw_dynamic<F>(
    facade: &F,
    data: &[T],
    bindings: Cow<'static, [(Cow<'static, str>, usize, AttributeType, bool)]>,
    elements_size: usize
) -> Result<VertexBuffer<T>, CreationError> where
    F: Facade + ?Sized, 

Dynamic version of new_raw.

pub fn slice<R>(&self, range: R) -> Option<VertexBufferSlice<T>> where
    R: RangeArgument<usize>, 

Accesses a slice of the buffer.

Returns None if the slice is out of range.

pub fn get_bindings(
    &self
) -> &Cow<'static, [(Cow<'static, str>, usize, AttributeType, bool)]>

Returns the associated VertexFormat.

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

Creates a marker that instructs glium to use multiple instances.

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

impl<T> VertexBuffer<T> where
    T: Copy + Send + 'static, 

pub fn into_vertex_buffer_any(self) -> VertexBufferAny

DEPRECATED: use .into() instead. Discard the type information and turn the vertex buffer into a VertexBufferAny.

Methods from Deref<Target = Buffer<[T]>>

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

Returns the context corresponding to this buffer.

pub fn get_size(&self) -> usize

Returns the size in bytes of this buffer.

pub fn is_persistent(&self) -> bool

Returns true if this buffer uses persistent mapping.

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 buffer. The data becomes undefined.

You should call this if you only use parts of a buffer. For example if you want to use the first half of the buffer, you invalidate the whole buffer then write the first half.

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

Implementation

Calls glInvalidateBufferData if supported. Otherwise, calls glBufferData with a null pointer for data. If glBufferStorage has been used to create the buffer and glInvalidateBufferData is not supported, does nothing.

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

Reads the content of the buffer.

pub fn map(&mut self) -> Mapping<T>

Maps the buffer in memory for both reading and writing.

Implementation

• For persistent-mapped buffers, waits until the data is no longer accessed by the GPU then returns a pointer to the existing mapping.
• For immutable buffers, creates a temporary buffer containing the data of the buffer and maps it. When the mapping object is destroyed, copies the content of the temporary buffer to the real buffer.
• For other types, calls glMapBuffer or glMapSubBuffer.

pub fn map_read(&mut self) -> ReadMapping<T>

Maps the buffer in memory for reading.

Implementation

• For persistent-mapped buffers, waits until the data is no longer accessed by the GPU then returns a pointer to the existing mapping.
• For immutable buffers, creates a temporary buffer containing the data of the buffer and maps it.
• For other types, calls glMapBuffer or glMapSubBuffer.

pub fn map_write(&mut self) -> WriteMapping<T>

Maps the buffer in memory for writing only.

Implementation

• For persistent-mapped buffers, waits until the data is no longer accessed by the GPU then returns a pointer to the existing mapping.
• For immutable buffers, creates a temporary buffer and maps it. When the mapping object is destroyed, copies the content of the temporary buffer to the real buffer.
• For other types, calls glMapBuffer or glMapSubBuffer.

pub fn copy_to<'a, S>(&self, target: S) -> Result<(), CopyError> where
    S: Into<BufferSlice<'a, T>>,
    T: 'a, 

Copies the content of the buffer to another buffer.

Panic

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

pub unsafe fn slice_custom<F, R>(&self, f: F) -> BufferSlice<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 unsafe fn slice_custom_mut<F, R>(&mut self, f: F) -> BufferMutSlice<R> where
    F: for<'r> FnOnce(&'r T) -> &'r R,
    R: Content + ?Sized, 

Same as slice_custom but returns a mutable slice.

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

pub fn as_slice(&self) -> BufferSlice<T>

Builds a slice containing the whole subbuffer.

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

pub fn as_mut_slice(&mut self) -> BufferMutSlice<T>

Builds a slice containing the whole subbuffer.

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

pub fn as_slice_any(&self) -> BufferAnySlice

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 buffer.

pub fn slice<R>(&self, range: R) -> Option<BufferSlice<[T]>> where
    R: RangeArgument<usize>, 

Builds a slice of this subbuffer. 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 slice_mut<R>(&mut self, range: R) -> Option<BufferMutSlice<[T]>> where
    R: RangeArgument<usize>, 

Builds a slice of this subbuffer. 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<T> DerefMut for VertexBuffer<T> where
    T: Copy, 

fn deref_mut(&mut self) -> &mut Buffer<[T]>

Mutably dereferences the value.

impl<T> From<Buffer<[T]>> for VertexBuffer<T> where
    T: Vertex + Copy, 

fn from(buffer: Buffer<[T]>) -> VertexBuffer<T>

Performs the conversion.

impl<T> From<VertexBuffer<T>> for VertexBufferAny where
    T: Copy + Send + 'static, 

fn from(buf: VertexBuffer<T>) -> VertexBufferAny

Performs the conversion.

impl<'a, T> From<&'a VertexBuffer<T>> for BufferSlice<'a, [T]> where
    T: Copy, 

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

Performs the conversion.

impl<'a, T> From<&'a mut VertexBuffer<T>> for BufferMutSlice<'a, [T]> where
    T: Copy, 

fn from(b: &'a mut VertexBuffer<T>) -> BufferMutSlice<'a, [T]>

Performs the conversion.

impl<T> Debug for VertexBuffer<T> where
    T: Debug + Copy, 

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

Formats the value using the given formatter.

impl<T> GlObject for VertexBuffer<T> where
    T: Copy, 

type Id = u32

The type of identifier for this object.

fn get_id(&self) -> u32

Returns the id of the object.

impl<T> Deref for VertexBuffer<T> where
    T: Copy, 

type Target = Buffer<[T]>

The resulting type after dereferencing.

fn deref(&self) -> &Buffer<[T]>

Dereferences the value.

impl<'a, T> Into<VerticesSource<'a>> for &'a VertexBuffer<T> where
    T: Copy, 

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

Performs the conversion.