Struct mallumo_gls::draw::DrawCommand

pub struct DrawCommand<'a> {
    pub framebuffer: Option<&'a GeneralFramebuffer>,
    pub attachments: Option<&'a DrawTextureTarget<'a>>,
    pub pipeline: Option<&'a Pipeline>,
    pub compute: Option<&'a ComputeProgram>,
    pub draw_command_type: DrawCommandType<'a>,
    pub mode: DrawMode,
    pub images: Vec<(&'a Texture, usize, usize, ImageInternalFormat)>,
    pub images_3d: Vec<(&'a Texture3D, usize, usize, ImageInternalFormat)>,
    pub images_read: Vec<(&'a Texture, usize, usize, ImageInternalFormat)>,
    pub images_write: Vec<(&'a Texture, usize, usize, ImageInternalFormat)>,
    pub textures_1d: Vec<(&'a Texture1D, usize)>,
    pub textures_2d: Vec<(&'a Texture2D, usize)>,
    pub textures_3d: Vec<(&'a Texture3D, usize)>,
    pub textures_cubemap: Vec<(&'a TextureCubemap, usize)>,
    pub texture_1d_arrays: Vec<(&'a [Option<&'a Texture1D>], usize)>,
    pub texture_2d_arrays: Vec<(&'a [Option<&'a Texture2D>], usize)>,
    pub texture_3d_arrays: Vec<(&'a [Option<&'a Texture3D>], usize)>,
    pub texture_cubemap_arrays: Vec<(&'a [Option<&'a TextureCubemap>], usize)>,
    pub storages: Vec<(&'a MutableBuffer, usize)>,
    pub storages_read: Vec<(&'a Buffer, usize)>,
    pub storage_ranges: Vec<(&'a MutableBuffer, usize, usize, usize)>,
    pub storage_range_reads: Vec<(&'a Buffer, usize, usize, usize)>,
    pub uniforms: Vec<(UniformValue<'a>, usize)>,
    pub uniform_buffers: Vec<(&'a Buffer, usize)>,
    pub uniform_ranges: Vec<(&'a Buffer, usize, usize, usize)>,
    pub atomic_counters: Vec<(&'a MutableBuffer, usize)>,
    pub barriers: Option<MemoryBarriers>,
}

Fields

framebuffer: Option<&'a GeneralFramebuffer>

attachments: Option<&'a DrawTextureTarget<'a>>

pipeline: Option<&'a Pipeline>

compute: Option<&'a ComputeProgram>

draw_command_type: DrawCommandType<'a>

mode: DrawMode

images: Vec<(&'a Texture, usize, usize, ImageInternalFormat)>

images_3d: Vec<(&'a Texture3D, usize, usize, ImageInternalFormat)>

images_read: Vec<(&'a Texture, usize, usize, ImageInternalFormat)>

images_write: Vec<(&'a Texture, usize, usize, ImageInternalFormat)>

textures_1d: Vec<(&'a Texture1D, usize)>

textures_2d: Vec<(&'a Texture2D, usize)>

textures_3d: Vec<(&'a Texture3D, usize)>

textures_cubemap: Vec<(&'a TextureCubemap, usize)>

texture_1d_arrays: Vec<(&'a [Option<&'a Texture1D>], usize)>

texture_2d_arrays: Vec<(&'a [Option<&'a Texture2D>], usize)>

texture_3d_arrays: Vec<(&'a [Option<&'a Texture3D>], usize)>

texture_cubemap_arrays: Vec<(&'a [Option<&'a TextureCubemap>], usize)>

storages: Vec<(&'a MutableBuffer, usize)>

storages_read: Vec<(&'a Buffer, usize)>

storage_ranges: Vec<(&'a MutableBuffer, usize, usize, usize)>

storage_range_reads: Vec<(&'a Buffer, usize, usize, usize)>

uniforms: Vec<(UniformValue<'a>, usize)>

uniform_buffers: Vec<(&'a Buffer, usize)>

uniform_ranges: Vec<(&'a Buffer, usize, usize, usize)>

atomic_counters: Vec<(&'a MutableBuffer, usize)>

barriers: Option<MemoryBarriers>

Methods

impl<'a> DrawCommand<'a>

pub fn arrays(
    pipeline: &'a Pipeline,
    first: usize,
    count: usize
) -> DrawCommand<'a>

pub fn arrays_indirect(
    pipeline: &'a Pipeline,
    indirect: &'a Buffer,
    offset: usize
) -> DrawCommand<'a>

pub fn arrays_instanced(
    pipeline: &'a Pipeline,
    first: usize,
    count: usize,
    primitive_count: usize
) -> DrawCommand<'a>

pub fn multi_draw_arrays(
    pipeline: &'a Pipeline,
    first: &'a [u32],
    count: &'a [u32],
    draw_count: usize
) -> DrawCommand<'a>

pub fn multi_draw_arrays_indirect(
    pipeline: &'a Pipeline,
    indirect: &'a Buffer,
    draw_count: usize,
    stride: usize
) -> DrawCommand<'a>

pub fn compute(
    program: &'a ComputeProgram,
    num_groups_x: usize,
    num_groups_y: usize,
    num_groups_z: usize
) -> DrawCommand<'a>

pub fn framebuffer(self, framebuffer: &'a GeneralFramebuffer) -> Self

pub fn attachments(self, attachments: &'a DrawTextureTarget<'a>) -> Self

pub fn mode(self, mode: DrawMode) -> Self

pub fn image<T: Texture>(
    self,
    image: &'a T,
    unit: usize,
    level: usize,
    format: ImageInternalFormat
) -> Self

pub fn image_3d(
    self,
    image: &'a Texture3D,
    unit: usize,
    level: usize,
    format: ImageInternalFormat
) -> Self

pub fn image_read<T: Texture>(
    self,
    image: &'a T,
    unit: usize,
    level: usize,
    format: ImageInternalFormat
) -> Self

pub fn image_write<T: Texture>(
    self,
    image: &'a T,
    unit: usize,
    level: usize,
    format: ImageInternalFormat
) -> Self

pub fn texture_1d<T: Into<Option<&'a Texture1D>>>(
    self,
    texture: T,
    unit: usize
) -> Self

pub fn texture_2d<T: Into<Option<&'a Texture2D>>>(
    self,
    texture: T,
    unit: usize
) -> Self

pub fn texture_3d<T: Into<Option<&'a Texture3D>>>(
    self,
    texture: T,
    unit: usize
) -> Self

pub fn texture_cubemap(self, texture: &'a TextureCubemap, unit: usize) -> Self

pub fn texture_1d_array(
    self,
    textures: &'a [Option<&'a Texture1D>],
    starting_location: usize
) -> Self

pub fn texture_2d_array(
    self,
    textures: &'a [Option<&'a Texture2D>],
    starting_location: usize
) -> Self

pub fn texture_3d_array(
    self,
    textures: &'a [Option<&'a Texture3D>],
    starting_location: usize
) -> Self

pub fn texture_cubemap_array(
    self,
    textures: &'a [Option<&'a TextureCubemap>],
    starting_location: usize
) -> Self

pub fn storage(self, storage: &'a MutableBuffer, location: usize) -> Self

pub fn storage_read(self, storage: &'a Buffer, location: usize) -> Self

pub fn storage_range<T>(
    self,
    storage: &'a MutableBuffer,
    location: usize,
    offset: usize,
    size: usize
) -> Self

pub fn storage_range_read<T>(
    self,
    storage: &'a Buffer,
    location: usize,
    offset: usize,
    size: usize
) -> Self

pub fn uniform_1f(self, v0: f32, location: usize) -> Self

pub fn uniform_2f(self, v0: f32, v1: f32, location: usize) -> Self

pub fn uniform_3f(self, v0: f32, v1: f32, v2: f32, location: usize) -> Self

pub fn uniform_4f(
    self,
    v0: f32,
    v1: f32,
    v2: f32,
    v3: f32,
    location: usize
) -> Self

pub fn uniform_1i(self, v0: i32, location: usize) -> Self

pub fn uniform_2i(self, v0: i32, v1: i32, location: usize) -> Self

pub fn uniform_3i(self, v0: i32, v1: i32, v2: i32, location: usize) -> Self

pub fn uniform_4i(
    self,
    v0: i32,
    v1: i32,
    v2: i32,
    v3: i32,
    location: usize
) -> Self

pub fn uniform_1ui(self, v0: u32, location: usize) -> Self

pub fn uniform_2ui(self, v0: u32, v1: u32, location: usize) -> Self

pub fn uniform_3ui(self, v0: u32, v1: u32, v2: u32, location: usize) -> Self

pub fn uniform_4ui(
    self,
    v0: u32,
    v1: u32,
    v2: u32,
    v3: u32,
    location: usize
) -> Self

pub fn uniform_1fv(self, array: &'a [f32], location: usize) -> Self

pub fn uniform_2fv(self, array: &'a [[f32; 2]], location: usize) -> Self

pub fn uniform_3fv(self, array: &'a [[f32; 3]], location: usize) -> Self

pub fn uniform_4fv(self, array: &'a [[f32; 4]], location: usize) -> Self

pub fn uniform_1iv(self, array: &'a [i32], location: usize) -> Self

pub fn uniform_2iv(self, array: &'a [[i32; 2]], location: usize) -> Self

pub fn uniform_3iv(self, array: &'a [[i32; 3]], location: usize) -> Self

pub fn uniform_4iv(self, array: &'a [[i32; 4]], location: usize) -> Self

pub fn uniform_1uiv(self, array: &'a [u32], location: usize) -> Self

pub fn uniform_2uiv(self, array: &'a [[u32; 2]], location: usize) -> Self

pub fn uniform_3uiv(self, array: &'a [[u32; 3]], location: usize) -> Self

pub fn uniform_4uiv(self, array: &'a [[u32; 4]], location: usize) -> Self

pub fn uniform_matrix_2f(self, mat2: [f32; 4], location: usize) -> Self

pub fn uniform_matrix_3f(self, mat3: [f32; 9], location: usize) -> Self

pub fn uniform_matrix_4f(self, mat4: [f32; 16], location: usize) -> Self

pub fn uniform(self, storage: &'a Buffer, location: usize) -> Self

pub fn uniform_range<T>(
    self,
    storage: &'a Buffer,
    location: usize,
    offset: usize,
    size: usize
) -> Self

pub fn atomic_counter(self, storage: &'a MutableBuffer, location: usize) -> Self

pub fn barriers(self, barriers: MemoryBarriers) -> Self

Trait Implementations