Struct nannou::ui::backend::glium::glium::vertex::VertexBuffer[−][src]

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

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

Builds a new vertex buffer.

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

Builds a new vertex buffer.

Builds a new vertex buffer.

Builds an empty vertex buffer.

The parameter indicates the number of elements.

Builds an empty vertex buffer.

The parameter indicates the number of elements.

Builds an empty vertex buffer.

The parameter indicates the number of elements.

Builds an empty vertex buffer.

The parameter indicates the number of elements.

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

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

Dynamic version of new_raw.

Accesses a slice of the buffer.

Returns None if the slice is out of range.

Returns the associated VertexFormat.

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]

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

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

Returns the context corresponding to this buffer.

Returns the size in bytes of this buffer.

Returns true if this buffer uses persistent mapping.

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.

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.

Reads the content of the buffer.

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.

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.

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.

Copies the content of the buffer to another buffer.

Panic

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

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.

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.

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.

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.

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.

Returns the number of elements in this buffer.

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.

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.

Reads the content of the buffer.

Trait Implementations

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

Mutably dereferences the value.

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

Formats the value using the given formatter. Read more

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

Performs the conversion.

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

The type of identifier for this object.

Returns the id of the object.

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

The resulting type after dereferencing.

Dereferences the value.

Auto Trait Implementations

impl<T> !Send for VertexBuffer<T>

impl<T> !Sync for VertexBuffer<T>