Struct glium::VertexBuffer [−] [src]

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

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

Methods

impl<T> VertexBuffer<T> where T: Vertex
[src]

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

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] },
]);

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

Builds a new vertex buffer.

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

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

Builds a new vertex buffer.

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

Builds a new vertex buffer.

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

Builds an empty vertex buffer.

The parameter indicates the number of elements.

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

Builds an empty vertex buffer.

The parameter indicates the number of elements.

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

Builds an empty vertex buffer.

The parameter indicates the number of elements.

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

Builds an empty vertex buffer.

The parameter indicates the number of elements.

impl<T> VertexBuffer<T> where T: Copy
[src]

unsafe fn new_raw<F>(facade: &F, data: &[T], bindings: VertexFormat, elements_size: usize) -> Result<VertexBuffer<T>, CreationError> where F: Facade

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>())
};

unsafe fn new_raw_dynamic<F>(facade: &F, data: &[T], bindings: VertexFormat, elements_size: usize) -> Result<VertexBuffer<T>, CreationError> where F: Facade

Dynamic version of new_raw.

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

Accesses a slice of the buffer.

Returns None if the slice is out of range.

fn get_bindings(&self) -> &VertexFormat

Returns the associated VertexFormat.

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
[src]

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]>>

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

Returns the context corresponding to this buffer.

fn get_size(&self) -> usize

Returns the size in bytes of this buffer.

fn is_persistent(&self) -> bool

Returns true if this buffer uses persistent mapping.

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.

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.

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

Reads the content of the buffer.

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.

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.

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.

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.

unsafe fn slice_custom<F, R: ?Sized>(&self, f: F) -> BufferSlice<R> where F: for<'r> FnOnce(&'r T) -> &'r R, R: Content

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.

unsafe fn slice_custom_mut<F, R: ?Sized>(&mut self, f: F) -> BufferMutSlice<R> where F: for<'r> FnOnce(&'r T) -> &'r R, R: Content

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.

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.

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.

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.

fn len(&self) -> usize

Returns the number of elements in this buffer.

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

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.

fn slice_mut<R: RangeArgument<usize>>(&mut self, range: R) -> Option<BufferMutSlice<[T]>>

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.

fn read_as_texture_1d<S>(&self) -> Result<S, ReadError> where S: Texture1dDataSink<T>

Reads the content of the buffer.

Trait Implementations

impl<T: Copy> GlObject for VertexBuffer<T>
[src]

type Id = GLuint

The type of identifier for this object.

fn get_id(&self) -> GLuint

Returns the id of the object.

impl<T: Debug> Debug for VertexBuffer<T> where T: Copy
[src]

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

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

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

Performs the conversion.

impl<T> Deref for VertexBuffer<T> where T: Copy
[src]

type Target = Buffer<[T]>

The resulting type after dereferencing

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

The method called to dereference a value

impl<T> DerefMut for VertexBuffer<T> where T: Copy
[src]

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

The method called to mutably dereference a value

impl<'a, T> IntoVerticesSource<'a> for &'a VertexBuffer<T> where T: Copy
[src]

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

Builds the VerticesSource.