Struct luminance_glutin::GlutinSurface

pub struct GlutinSurface {
    pub ctx: WindowedContext<PossiblyCurrent>,
    // some fields omitted
}

The Glutin surface.

You want to create such an object in order to use any luminance construct.

Fields

ctx: WindowedContext<PossiblyCurrent>

The windowed context.

Implementations

impl GlutinSurface

pub fn new_gl33_from_builders<'a, WB, CB>(
    window_builder: WB,
    ctx_builder: CB
) -> Result<(Self, EventLoop<()>), GlutinError> where
    WB: FnOnce(&mut EventLoop<()>, WindowBuilder) -> WindowBuilder,
    CB: FnOnce(&mut EventLoop<()>, ContextBuilder<'a, NotCurrent>) -> ContextBuilder<'a, NotCurrent>, 

Create a new GlutinSurface by consuming a [WindowBuilder].

This is an alternative method to new_gl33 that is more flexible as you have access to the whole glutin types.

window_builder is the default object when passed to your closure and ctx_builder is already initialized for the OpenGL context (you’re not supposed to change it!).

pub fn new_gl33(
    window_builder: WindowBuilder,
    samples: u16
) -> Result<(Self, EventLoop<()>), GlutinError>

Create a new GlutinSurface from scratch.

pub fn size(&self) -> [u32; 2]

Get the underlying size (in physical pixels) of the surface.

This is equivalent to getting the inner size of the windowed context and converting it to a physical size by using the HiDPI factor of the windowed context.

pub fn back_buffer(
    &mut self
) -> Result<Framebuffer<GL33, Dim2, (), ()>, FramebufferError>

Get access to the back buffer.

pub fn swap_buffers(&mut self)

Swap the back and front buffers.

Trait Implementations

impl GraphicsContext for GlutinSurface

type Backend = GL33

Internal type used by the backend to cache, optimize and store data. This roughly represents the GPU data / context a backend implementation needs to work correctly.

fn backend(&mut self) -> &mut Self::Backend

Access the underlying backend.

pub fn new_pipeline_gate(&mut self) -> PipelineGate<'_, Self::Backend>

Create a new pipeline gate

pub fn new_buffer<T>(
    &mut self,
    len: usize
) -> Result<Buffer<Self::Backend, T>, BufferError> where
    T: Copy + Default,
    Self::Backend: Buffer<T>, 

Create a new buffer.

pub fn new_buffer_from_vec<T, X>(
    &mut self,
    vec: X
) -> Result<Buffer<Self::Backend, T>, BufferError> where
    T: Copy,
    X: Into<Vec<T, Global>>,
    Self::Backend: Buffer<T>, 

Create a new buffer from a slice.

pub fn new_buffer_repeating<T>(
    &mut self,
    len: usize,
    value: T
) -> Result<Buffer<Self::Backend, T>, BufferError> where
    T: Copy,
    Self::Backend: Buffer<T>, 

Create a new buffer by repeating a value.

pub fn new_framebuffer<D, CS, DS>(
    &mut self,
    size: <D as Dimensionable>::Size,
    mipmaps: usize,
    sampler: Sampler
) -> Result<Framebuffer<Self::Backend, D, CS, DS>, FramebufferError> where
    D: Dimensionable,
    CS: ColorSlot<Self::Backend, D>,
    DS: DepthSlot<Self::Backend, D>,
    Self::Backend: Framebuffer<D>, 

Create a new framebuffer.

pub fn new_shader_stage<R>(
    &mut self,
    ty: StageType,
    src: R
) -> Result<Stage<Self::Backend>, StageError> where
    R: AsRef<str>,
    Self::Backend: Shader, 

Create a new shader stage.

pub fn new_shader_program<Sem, Out, Uni>(
    &mut self
) -> ProgramBuilder<'_, Self, Sem, Out, Uni> where
    Sem: Semantics,
    Self::Backend: Shader, 

Create a new shader program.

pub fn new_tess(
    &mut self
) -> TessBuilder<'_, Self::Backend, (), (), (), Interleaved> where
    Self::Backend: Tess<(), (), (), Interleaved>, 

Create a TessBuilder.

pub fn new_deinterleaved_tess<V, W>(
    &mut self
) -> TessBuilder<'_, Self::Backend, V, (), W, Deinterleaved> where
    W: TessVertexData<Deinterleaved>,
    V: TessVertexData<Deinterleaved>,
    Self::Backend: Tess<V, (), W, Deinterleaved>, 

Create a TessBuilder with deinterleaved memory.

pub fn new_texture<D, P>(
    &mut self,
    size: <D as Dimensionable>::Size,
    mipmaps: usize,
    sampler: Sampler
) -> Result<Texture<Self::Backend, D, P>, TextureError> where
    D: Dimensionable,
    P: Pixel,
    Self::Backend: Texture<D, P>, 

Create a new texture.