Struct luminance_glow::Glow

pub struct Glow { /* fields omitted */ }

The Luminance Glow backend

Implementations

impl Glow

pub fn from_context(ctx: Context) -> Result<Self, StateQueryError>

Create a glow backend instance from a glow Context

Trait Implementations

impl<T> Buffer<T> for Glow where
    T: Copy, 

type BufferRepr = Buffer<T>

The inner representation of the buffer for this backend.

unsafe fn new_buffer(
    &mut self,
    len: usize
) -> Result<Self::BufferRepr, BufferError> where
    T: Default, 

Create a new buffer with a given number of uninitialized elements.

unsafe fn len(buffer: &Self::BufferRepr) -> usize

unsafe fn from_vec(
    &mut self,
    vec: Vec<T>
) -> Result<Self::BufferRepr, BufferError>

unsafe fn repeat(
    &mut self,
    len: usize,
    value: T
) -> Result<Self::BufferRepr, BufferError>

unsafe fn at(buffer: &Self::BufferRepr, i: usize) -> Option<T>

unsafe fn whole(buffer: &Self::BufferRepr) -> Vec<T>

unsafe fn set(
    buffer: &mut Self::BufferRepr,
    i: usize,
    x: T
) -> Result<(), BufferError>

unsafe fn write_whole(
    buffer: &mut Self::BufferRepr,
    values: &[T]
) -> Result<(), BufferError>

unsafe fn clear(buffer: &mut Self::BufferRepr, x: T) -> Result<(), BufferError>

impl<T> BufferSlice<T> for Glow where
    T: Copy, 

type SliceRepr = BufferSlice<T>

type SliceMutRepr = BufferSliceMut<T>

unsafe fn slice_buffer(
    buffer: &Self::BufferRepr
) -> Result<Self::SliceRepr, BufferError>

unsafe fn slice_buffer_mut(
    buffer: &mut Self::BufferRepr
) -> Result<Self::SliceMutRepr, BufferError>

impl Debug for Glow

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

Formats the value using the given formatter.

impl<D> Framebuffer<D> for Glow where
    D: Dimensionable, 

type FramebufferRepr = Framebuffer<D>

unsafe fn new_framebuffer<CS, DS>(
    &mut self,
    size: D::Size,
    _: usize,
    _: &Sampler
) -> Result<Self::FramebufferRepr, FramebufferError> where
    CS: ColorSlot<Self, D>,
    DS: DepthSlot<Self, D>, 

unsafe fn attach_color_texture(
    framebuffer: &mut Self::FramebufferRepr,
    texture: &Self::TextureRepr,
    attachment_index: usize
) -> Result<(), FramebufferError>

unsafe fn attach_depth_texture(
    framebuffer: &mut Self::FramebufferRepr,
    texture: &Self::TextureRepr
) -> Result<(), FramebufferError>

unsafe fn validate_framebuffer(
    framebuffer: Self::FramebufferRepr
) -> Result<Self::FramebufferRepr, FramebufferError>

unsafe fn framebuffer_size(framebuffer: &Self::FramebufferRepr) -> D::Size

impl FramebufferBackBuffer for Glow

unsafe fn back_buffer(
    &mut self,
    size: <Dim2 as Dimensionable>::Size
) -> Result<Self::FramebufferRepr, FramebufferError>

impl<V, I, W> IndexSlice<V, I, W, Deinterleaved> for Glow where
    V: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>>,
    I: TessIndex,
    W: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>>, 

type IndexSliceRepr = BufferSlice<I>

type IndexSliceMutRepr = BufferSliceMut<I>

unsafe fn indices(
    tess: &mut Self::TessRepr
) -> Result<Self::IndexSliceRepr, TessMapError>

unsafe fn indices_mut(
    tess: &mut Self::TessRepr
) -> Result<Self::IndexSliceMutRepr, TessMapError>

impl<V, I, W> IndexSlice<V, I, W, Interleaved> for Glow where
    V: TessVertexData<Interleaved, Data = Vec<V>>,
    I: TessIndex,
    W: TessVertexData<Interleaved, Data = Vec<W>>, 

type IndexSliceRepr = BufferSlice<I>

type IndexSliceMutRepr = BufferSliceMut<I>

unsafe fn indices(
    tess: &mut Self::TessRepr
) -> Result<Self::IndexSliceRepr, TessMapError>

unsafe fn indices_mut(
    tess: &mut Self::TessRepr
) -> Result<Self::IndexSliceMutRepr, TessMapError>

impl<V, I, W, T> InstanceSlice<V, I, W, Deinterleaved, T> for Glow where
    V: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>>,
    I: TessIndex,
    W: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>> + Deinterleave<T>, 

type InstanceSliceRepr = BufferSlice<T>

type InstanceSliceMutRepr = BufferSliceMut<T>

unsafe fn instances(
    tess: &mut Self::TessRepr
) -> Result<Self::InstanceSliceRepr, TessMapError>

unsafe fn instances_mut(
    tess: &mut Self::TessRepr
) -> Result<Self::InstanceSliceMutRepr, TessMapError>

impl<V, I, W> InstanceSlice<V, I, W, Interleaved, W> for Glow where
    V: TessVertexData<Interleaved, Data = Vec<V>>,
    I: TessIndex,
    W: TessVertexData<Interleaved, Data = Vec<W>>, 

type InstanceSliceRepr = BufferSlice<W>

type InstanceSliceMutRepr = BufferSliceMut<W>

unsafe fn instances(
    tess: &mut Self::TessRepr
) -> Result<Self::InstanceSliceRepr, TessMapError>

unsafe fn instances_mut(
    tess: &mut Self::TessRepr
) -> Result<Self::InstanceSliceMutRepr, TessMapError>

impl<D> Pipeline<D> for Glow where
    D: Dimensionable, 

unsafe fn start_pipeline(
    &mut self,
    framebuffer: &Self::FramebufferRepr,
    pipeline_state: &PipelineState
)

impl PipelineBase for Glow

type PipelineRepr = Pipeline

unsafe fn new_pipeline(&mut self) -> Result<Self::PipelineRepr, PipelineError>

impl<T> PipelineBuffer<T> for Glow where
    T: Copy, 

type BoundBufferRepr = BoundBuffer

unsafe fn bind_buffer(
    pipeline: &Self::PipelineRepr,
    buffer: &Self::BufferRepr
) -> Result<Self::BoundBufferRepr, PipelineError>

unsafe fn buffer_binding(bound: &Self::BoundBufferRepr) -> u32

impl<D, P> PipelineTexture<D, P> for Glow where
    D: Dimensionable,
    P: Pixel, 

type BoundTextureRepr = BoundTexture<D, P>

unsafe fn bind_texture(
    pipeline: &Self::PipelineRepr,
    texture: &Self::TextureRepr
) -> Result<Self::BoundTextureRepr, PipelineError> where
    D: Dimensionable,
    P: Pixel, 

unsafe fn texture_binding(bound: &Self::BoundTextureRepr) -> u32

impl RenderGate for Glow

unsafe fn enter_render_state(&mut self, rdr_st: &RenderState)

impl Shader for Glow

type StageRepr = Stage

type ProgramRepr = Program

type UniformBuilderRepr = UniformBuilder

unsafe fn new_stage(
    &mut self,
    ty: StageType,
    src: &str
) -> Result<Self::StageRepr, StageError>

unsafe fn new_program(
    &mut self,
    vertex: &Self::StageRepr,
    tess: Option<TessellationStages<'_, Self::StageRepr>>,
    geometry: Option<&Self::StageRepr>,
    fragment: &Self::StageRepr
) -> Result<Self::ProgramRepr, ProgramError>

unsafe fn apply_semantics<Sem>(
    program: &mut Self::ProgramRepr
) -> Result<Vec<VertexAttribWarning>, ProgramError> where
    Sem: Semantics, 

unsafe fn new_uniform_builder(
    program: &mut Self::ProgramRepr
) -> Result<Self::UniformBuilderRepr, ProgramError>

unsafe fn ask_uniform<T>(
    uniform_builder: &mut Self::UniformBuilderRepr,
    name: &str
) -> Result<Uniform<T>, UniformWarning> where
    T: Uniformable<Self>, 

unsafe fn unbound<T>(_: &mut Self::UniformBuilderRepr) -> Uniform<T> where
    T: Uniformable<Self>, 

impl ShadingGate for Glow

unsafe fn apply_shader_program(&mut self, shader_program: &Self::ProgramRepr)

impl<V, I, W> Tess<V, I, W, Deinterleaved> for Glow where
    V: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>>,
    I: TessIndex,
    W: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>>, 

type TessRepr = DeinterleavedTess<V, I, W>

unsafe fn build(
    &mut self,
    vertex_data: Option<V::Data>,
    index_data: Vec<I>,
    instance_data: Option<W::Data>,
    mode: Mode,
    vert_nb: usize,
    inst_nb: usize,
    _: Option<I>
) -> Result<Self::TessRepr, TessError>

unsafe fn tess_vertices_nb(tess: &Self::TessRepr) -> usize

unsafe fn tess_instances_nb(tess: &Self::TessRepr) -> usize

unsafe fn render(
    tess: &Self::TessRepr,
    start_index: usize,
    vert_nb: usize,
    inst_nb: usize
) -> Result<(), TessError>

impl<V, I, W> Tess<V, I, W, Interleaved> for Glow where
    V: TessVertexData<Interleaved, Data = Vec<V>>,
    I: TessIndex,
    W: TessVertexData<Interleaved, Data = Vec<W>>, 

type TessRepr = InterleavedTess<V, I, W>

unsafe fn build(
    &mut self,
    vertex_data: Option<V::Data>,
    index_data: Vec<I>,
    instance_data: Option<W::Data>,
    mode: Mode,
    vert_nb: usize,
    inst_nb: usize,
    _: Option<I>
) -> Result<Self::TessRepr, TessError>

unsafe fn tess_vertices_nb(tess: &Self::TessRepr) -> usize

unsafe fn tess_instances_nb(tess: &Self::TessRepr) -> usize

unsafe fn render(
    tess: &Self::TessRepr,
    start_index: usize,
    vert_nb: usize,
    inst_nb: usize
) -> Result<(), TessError>

impl<V, I, W> TessGate<V, I, W, Deinterleaved> for Glow where
    V: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>>,
    I: TessIndex,
    W: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>>, 

unsafe fn render(
    &mut self,
    tess: &Self::TessRepr,
    start_index: usize,
    vert_nb: usize,
    inst_nb: usize
)

impl<V, I, W> TessGate<V, I, W, Interleaved> for Glow where
    V: TessVertexData<Interleaved, Data = Vec<V>>,
    I: TessIndex,
    W: TessVertexData<Interleaved, Data = Vec<W>>, 

unsafe fn render(
    &mut self,
    tess: &Self::TessRepr,
    start_index: usize,
    vert_nb: usize,
    inst_nb: usize
)

impl<D, P> Texture<D, P> for Glow where
    D: Dimensionable,
    P: Pixel, 

unsafe fn new_texture(
    &mut self,
    size: D::Size,
    mipmaps: usize,
    sampler: Sampler
) -> Result<Self::TextureRepr, TextureError>

unsafe fn mipmaps(texture: &Self::TextureRepr) -> usize

unsafe fn clear_part(
    texture: &mut Self::TextureRepr,
    gen_mipmaps: GenMipmaps,
    offset: D::Offset,
    size: D::Size,
    pixel: P::Encoding
) -> Result<(), TextureError>

unsafe fn clear(
    texture: &mut Self::TextureRepr,
    gen_mipmaps: GenMipmaps,
    size: D::Size,
    pixel: P::Encoding
) -> Result<(), TextureError>

unsafe fn upload_part(
    texture: &mut Self::TextureRepr,
    gen_mipmaps: GenMipmaps,
    offset: D::Offset,
    size: D::Size,
    texels: &[P::Encoding]
) -> Result<(), TextureError>

unsafe fn upload(
    texture: &mut Self::TextureRepr,
    gen_mipmaps: GenMipmaps,
    size: D::Size,
    texels: &[P::Encoding]
) -> Result<(), TextureError>

unsafe fn upload_part_raw(
    texture: &mut Self::TextureRepr,
    gen_mipmaps: GenMipmaps,
    offset: D::Offset,
    size: D::Size,
    texels: &[P::RawEncoding]
) -> Result<(), TextureError>

unsafe fn upload_raw(
    texture: &mut Self::TextureRepr,
    gen_mipmaps: GenMipmaps,
    size: D::Size,
    texels: &[P::RawEncoding]
) -> Result<(), TextureError>

unsafe fn get_raw_texels(
    texture: &Self::TextureRepr,
    size: D::Size
) -> Result<Vec<P::RawEncoding>, TextureError> where
    P::RawEncoding: Copy + Default, 

impl TextureBase for Glow

type TextureRepr = Texture

impl<'a> Uniformable<Glow> for &'a [i32]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[i32; 2]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[f32; 3]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[f32; 4]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[[f32; 2]; 2]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[[f32; 3]; 3]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[[f32; 4]; 4]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [bool]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[bool; 2]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[bool; 3]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[bool; 4]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[i32; 3]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[i32; 4]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [u32]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[u32; 2]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[u32; 3]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[u32; 4]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [f32]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<'a> Uniformable<Glow> for &'a [[f32; 2]]

unsafe fn ty() -> UniformType

unsafe fn update(self, program: &mut Program, uniform: &Uniform<Self>)

impl<V, I, W, T> VertexSlice<V, I, W, Deinterleaved, T> for Glow where
    V: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>> + Deinterleave<T>,
    I: TessIndex,
    W: TessVertexData<Deinterleaved, Data = Vec<DeinterleavedData>>, 

type VertexSliceRepr = BufferSlice<T>

type VertexSliceMutRepr = BufferSliceMut<T>

unsafe fn vertices(
    tess: &mut Self::TessRepr
) -> Result<Self::VertexSliceRepr, TessMapError>

unsafe fn vertices_mut(
    tess: &mut Self::TessRepr
) -> Result<Self::VertexSliceMutRepr, TessMapError>

impl<V, I, W> VertexSlice<V, I, W, Interleaved, V> for Glow where
    V: TessVertexData<Interleaved, Data = Vec<V>>,
    I: TessIndex,
    W: TessVertexData<Interleaved, Data = Vec<W>>, 

type VertexSliceRepr = BufferSlice<V>

type VertexSliceMutRepr = BufferSliceMut<V>

unsafe fn vertices(
    tess: &mut Self::TessRepr
) -> Result<Self::VertexSliceRepr, TessMapError>

unsafe fn vertices_mut(
    tess: &mut Self::TessRepr
) -> Result<Self::VertexSliceMutRepr, TessMapError>