Struct nannou::ui::backend::glium::glium::vertex::TransformFeedbackSession

pub struct TransformFeedbackSession<'a> { /* fields omitted */ }

Transform feedback allows you to obtain in a buffer the list of the vertices generated by the vertex shader, geometry shader, or tessellation evaluation shader of your program. This is usually used to cache the result in order to draw the vertices multiple times with multiple different fragment shaders.

To use transform feedback, you must create a transform feedback session. A transform feedback session mutably borrows the buffer where the data will be written. Each draw command submitted with a session will continue to append data after the data written by the previous draw command. You can only use the data when the session is destroyed.

Notes

Here are a few things to note if you aren't familiar with transform feedback:

• The program you use must have transform feedback enabled, either with attributes in the vertex shader's source code (for recent OpenGL versions only) or by indicating a list of vertex attributes when building the program.

• A transform feedback session is bound to a specific program and buffer. You can't switch them once the session has been created. An error is generated if you draw with a different program than the one you created the session with.

• The transform feedback process doesn't necessarily fill the whole buffer. To retrieve the number of vertices that are written to the buffer, use a query object (see the draw_parameters module). It is however usually easy to determine in advance the number of vertices that will be written based on the input data.

• The buffer will obtain either a list of points, a list of lines (two vertices), or a list of triangles (three vertices). If you draw a triangle strip or a triangle fan for example, individual triangles will be written to the buffer (meaning that some vertices will be duplicated).

• You can use the same session multiple times in a row, in which case the data will continue to be pushed in the buffer after the existing data. However you must always use the same type of primitives and the same program.

Example

#[derive(Copy, Clone, Debug, PartialEq)]
struct Vertex {
    output_val: (f32, f32),
}

implement_vertex!(Vertex, output_val);

let mut out_buffer: glium::VertexBuffer<Vertex> = glium::VertexBuffer::empty(&display, 6).unwrap();

{
    let session = glium::vertex::TransformFeedbackSession::new(&display, &program,
                                                               &mut out_buffer).unwrap();

    let params = glium::DrawParameters {
        transform_feedback: Some(&session),
        .. Default::default()
    };

    display.draw().draw(&vb, &ib, &program, &uniform!{}, &params).unwrap();
}

let result: Vec<Vertex> = out_buffer.read().unwrap();
println!("List of generated vertices: {:?}", result);

Methods

impl<'a> TransformFeedbackSession<'a>

fn new<F, V>(
    facade: &F,
    program: &'a Program,
    buffer: &'a mut Buffer<[V]>
) -> Result<TransformFeedbackSession<'a>, TransformFeedbackSessionCreationError> where
    F: Facade + ?Sized,
    V: Vertex + Copy + Send + 'static, 

Builds a new transform feedback session.

TODO: this constructor should ultimately support passing multiple buffers of different types

Trait Implementations

impl<'a> Debug for TransformFeedbackSession<'a>

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

Formats the value using the given formatter.

impl<'a> Drop for TransformFeedbackSession<'a>

fn drop(&mut self)

Executes the destructor for this type.