Struct rin_gl::renderer::Renderer

#[must_use = "Calling with on a renderer doesn't change that renderer, it returns a new one with the properties applied. Instead of calling `gl.with(...)` do `let gl = gl.with(...)`"]
pub struct Renderer<'c, R: RenderSurface + 'c = Screen> { /* fields omitted */ }

Object needed to render any rin object using OpenGL

It also contains a GL context, using gling which initializes all the OpenGL function calls

The renderer contains a state and new copies with different states can be created using the different with* methods.

The Renderer state keeps track of the GL properties as well as the camera and model matrices so when a new Renderer is created using any of the with methods drawing with afterwards will apply that state to whatever is being drawn.

The state changes are done by generating a diff of the current state with the Renderer state so the calls as are less as possible but grouping all the calls that use the same renderer is always a good idea since it reduces the number of state changes.

let gl = gl::Renderer::new(&mut window);
let gl_depth = gl.with_properties(&[gl::Property::DepthTest(true)]);

// draw without depth test:
gl.draw(&something);

// draw with depth test:
gl_depth.draw(&something);

Implementations

impl<'c> Renderer<'c>

pub fn new<'w, W: WindowExt + GlWindow>(
    window: &'w mut W
) -> Result<Renderer<'static>>

Creates a new renderer using a window that implments GLWindow so it can load the GL context using it

pub fn with_default_properties<'w, W: WindowExt + GlWindow>(
    window: &'w mut W,
    default_properties: &[Property]
) -> Result<Renderer<'static>>

Creates a new renderer with a set of default properties that will be applied over the GL defaults

pub unsafe fn reset_default_state(&mut self, state: State<'static>)

Sets the current state to the one passed as parameter.

Used to reset the current state, for example, after altering it doing external gl calls

impl<'c, R: RenderSurface + 'c> Renderer<'c, R>

pub fn resolution_factor(&self) -> f32

pub fn clear_color<C: ToRgba>(&self, color: &C)

Clear the color buffer with the specified color

pub fn clear_depth(&self, depth: f64)

Clear the depth buffer with the specified color

pub fn clear_stencil(&self, stencil: i32)

Clear the stencil buffer with the specified color

pub fn clear_all<C>(
    &self,
    color: Option<C>,
    depth: Option<f64>,
    stencil: Option<i32>
) where
    C: ToRgba, 

Optionally clear color, depth and stencil in one gl call

pub fn mvp(&self) -> &Mvp

Returns the current Mvp (Camera + Model matrices)

pub fn with_camera_viewport<C: CameraExt + ?Sized>(
    &self,
    camera: &C,
    viewport: &Rect<i32>
) -> Renderer<'_, R>

Create a copy of this renderer with new camera matrices using the passed camera and viewport

pub fn with_mvp<M: Into<Mvp>>(&self, mvp: M) -> Renderer<'_, R>

Create a copy of this renderer with a new Mvp (camera + model matrices)

pub fn with_model<M: Into<Model>>(&self, model: M) -> Renderer<'_, R>

Create a copy of this renderer with a new model matrix

The model parameter can be anything that can be converted into a model matrix like:

• a Pnt3
• a Node
• a Mat4
• a UnitQuat
• an Isometry2 or 3
• a Translation2 or 3
• a Rotation2 or 3

For example if we want to draw an object in 10, 10, 10 rotated 30 degrees along the z axis we could do:

let position = pnt3!(10.);
let angle = Deg(30.).to_rad().value();
let orientation = UnitQuat::from_axis_angle(Vec3::z_axis(), angle);
let node = Node::new(position, angle, one());
let gl = gl.with_model(&node);
gl.draw(&object);

or:

let position = pnt3!(10.);
let angle = Deg(30.).to_rad().value();
let orientation = UnitQuat::from_axis_angle(Vec3::z_axis(), angle);
let node = Isometry3::from_parts(position, angle);
let gl = gl.with_model(&node);
gl.draw(&object);

Model matrices don’t accumulate when calling with_model over an exisiting renderer, the new renderer just replaces the old model matrices so if you need to accumulate model transformations it has to be done outside the renderer by combining the transformations into one

pub fn with_properties<'a, P>(&self, properties: P) -> Renderer<'_, R> where
    P: IntoIterator<Item = &'a Property>, 

Creates a copy of this renderer with the current properties + the passed ones

See also Property for more info about available properties

pub fn with_model_matrices_as_attributes(&self) -> Renderer<'_, R>

Creates a new renderer which with a flag to upload model matrices as per instance vertex attributes instead of uniforms

This can speed up drawing by avoiding one upload per draw call and instead having the matrices in vaos as a per instance attribute

pub fn with_material<'m, M: Material>(
    &'m mut self,
    material: &'m M
) -> RendererWithMaterial<'m, R>

pub fn id(&self) -> usize

Id of this renderer

Mostly used internally to differentiate resources created by each renderer since some resources can only be used with the renderer they where originally created with

pub fn context(&self) -> &Context<'c, R>

Returns the internal glin context for more advanced usages

pub fn context_mut(&mut self) -> &mut Context<'c, R>

Returns the internal glin context for more advanced usages

pub fn new_texture(&self) -> Builder<'_>

Creates a new texture

Returns a texture::Builder that allows to configure the texture creation further

pub fn new_cubemap(&self) -> Builder<'_>

Creates a new cubemap

Returns a cubemap::Builder that allows to configure the cubemap creation further

pub fn new_buffer(&self) -> Builder<'_>

Creates a new buffer in gpu memory

Returns a buffer::Builder that allows to configure the buffer creation further

pub fn new_shared_buffer(&self) -> SharedBuilder<'_>

Creates a new shared buffer in gpu memory

Returns a buffer::SharedBuilder that allows to configure the buffer creation further

Shared buffers are reference counted so they can be shared from several owners

pub fn new_vao(&self) -> Builder

Creates a new VAO

Returns a vao::Builder that allows to configure the vao creation further

pub fn new_simple_vao(&self) -> Builder<'_>

Creates a new SimpleVao

Returns a simple_vao::Builder that allows to configure the vao creation further

pub fn new_program(&self) -> Builder<'_>

Creates a new glsl program

Returns a program::Builder that allows to configure the program creation further

pub fn new_sampler(&self) -> Sampler

Creates a new texture sampler

Directly returns a Sampler that can be configured through it’s own methods

pub fn new_timestamp_query(&self) -> TimeStamp

Creates a new counter query

Directly returns a TimeStamp query

pub fn new_duration_query(&self) -> Duration

Creates a new counter query

Directly returns a Duration query

pub fn new_fence(&self) -> Fence

pub fn new_debug_group(&self, id: u32, message: &str) -> DebugGroup

pub fn new_ttf<'a>(&'a self, path: &'a str, pt_height: f32) -> Builder<'a>

Creates a new ttf font

Returns a ttf::Builder that allows to configure the font creation further

Requires a path and a font height in pt as mandatory arguments

pub fn new_ttf_from_bytes<'a>(
    &'a self,
    bytes: &'a [u8],
    pt_height: f32
) -> Builder<'a>

Creates a new ttf font

Returns a ttf::Builder that allows to configure the font creation further

Requires a memory buffer with the ttf definition and a font height in pt as mandatory arguments

pub fn new_ttf_material<'a>(&self, ttf: &'a Ttf) -> MaterialBuilder<'a>

Creates a ttf material from a font

Returns a ttf::MaterialBuilder that allows to configure the font material creation further.

pub fn new_vao_mesh(&self) -> Builder

Creates a new VaoMesh

Returns a vao_mesh::Builder that allows to configure the VaoMesh creation further

pub fn new_vao_path(&self) -> Builder

Creates a new VaoPath

Returns a vao_path::Builder that allows to configure the VaoPath creation further

pub fn new_auto_program<P: AsRef<Path> + Clone + 'static>(
    &self,
    settings: ProgramSettings<P>
) -> AutoLoader<Program>

Creates a glsl program that can reload itself when the source changes

Directly returns a AutoLoader from the passed settings.

The AutoLoader watches the filesystem for changes in the original source for the shaders including any possible includes and reloads the program if any of them changes

pub fn new_object(&self) -> Builder

Creates a new ringl Object

Returns an object::Builder that allows to configure the Object further

An object is just a gpu geometry, usually a VAO and a Node to represent it’s model transformation

pub fn to_simple_vao<T, U, M: ToSimpleVao<T, U>>(
    &self,
    mesh: &M
) -> Result<SimpleVao<T>>

Returns a SimpleVao from a Mesh

let mesh = rin::graphics::sphere(10., 20, 20);
let sphere_vao = gl.to_simple_vao(&mesh);

Allows to easily create a VAO, needed to draw any geometry, from a Mesh in RAM

pub fn to_simple_vao_bindings<T, U, M: ToSimpleVao<T, U>, B: Bindings>(
    &self,
    mesh: &M,
    bindings: &B
) -> Result<SimpleVao<T>>

Returns a SimpleVao from a Mesh

let mesh = rin::graphics::sphere(10., 20, 20);
let sphere_vao = gl.to_simple_vao(&mesh);

Allows to easily create a VAO, needed to draw any geometry, from a Mesh in RAM

pub fn to_simple_vao_usage<T, U, M: ToSimpleVao<T, U>>(
    &self,
    mesh: &M,
    usage: GLenum,
    program: &Program
) -> Result<SimpleVao<T>>

Returns a SimpleVao from a Mesh

let mesh = rin::graphics::sphere(10., 20, 20);
let sphere_vao = gl.to_simple_vao(&mesh);

Allows to easily create a VAO, needed to draw any geometry, from a Mesh in RAM

pub fn to_simple_vao_usage_bindings<T, U, M: ToSimpleVao<T, U>, B: Bindings>(
    &self,
    mesh: &M,
    usage: GLenum,
    bindings: &B
) -> Result<SimpleVao<T>>

Returns a SimpleVao from a Mesh

let mesh = rin::graphics::sphere(10., 20, 20);
let sphere_vao = gl.to_simple_vao(&mesh);

Allows to easily create a VAO, needed to draw any geometry, from a Mesh in RAM

pub fn creation_proxy(&self) -> CreationProxy

Returns a creation proxy that can be stored to create new gl objects from anywhere without needing a full Renderer

pub fn model_matrices_as_attributes(&self) -> bool

Returns true if this renderer is set to use model matrices as attributes instead of uniforms.

Usually used by materials to setup the shaders accordingly

pub fn clear<C: ToRgba>(&self, color: &C)

Clears the color buffer with the passed color and the depth buffer with the defailt value

pub fn draw_mesh<T, U, M: ToSimpleVao<T, U>>(&self, mesh: &M) where
    T: VertexFormat + Clone + 'static, 

Draws a mesh using a VAO from the internal pool and a default basic material

The mesh parameter can be anything that implements the ToSimpleVao trait, by default a graphics::Mesh of any of the supported VertexFormats but also a tuple of (&[Vertex], PrimitiveType) or (&[Vertex], &[IndexT], PrimitiveType)

pub fn draw_string<C: ToRgba>(
    &self,
    font: &Ttf,
    string: &str,
    pos: &Pnt2,
    color: &C
)

Draws the passed string with the passed font

pub fn draw_string_box<C: ToRgba>(
    &self,
    font: &Ttf,
    string: &str,
    pos: &Pnt2,
    w: BoxCoordinatesX,
    h: BoxCoordinatesY,
    flags: BoxFlags,
    color: &C
) -> Pnt2

Draws the passed string with the passed font in a box of the dimensions indicated by x, y, w, h

Also returns the next position whe text should start to be drawn to be next to this one

pub fn draw_bitmap_string<C: ToRgba>(&self, string: &str, pos: &Pnt2, color: &C)

Draws the passed string using a bitmap font

pub fn draw_line<C: ToRgba>(&self, from: &Pnt2, to: &Pnt2, color: &C)

Draws a 1px width line segment between from and to

pub fn draw_rectangle_fill<C: ToRgba>(
    &self,
    pos: &Pnt2,
    w: f32,
    h: f32,
    color: &C
)

Draws a filled rectangle at the passed position and size

pub fn draw_rectangle_lines<C: ToRgba>(
    &self,
    pos: &Pnt2,
    w: f32,
    h: f32,
    color: &C
)

Draws a rectangle contour at the passed position and size

pub fn draw_circle_fill<C: ToRgba>(
    &self,
    pos: &Pnt2,
    radius: f32,
    resolution: u32,
    color: &C
)

Draws a filled circle

pub fn draw_circle_lines<C: ToRgba>(
    &self,
    pos: &Pnt2,
    radius: f32,
    resolution: u32,
    color: &C
)

Draws a cicle contour

pub fn draw_ellipse_fill<C: ToRgba>(
    &self,
    pos: &Pnt2,
    w: f32,
    h: f32,
    resolution: u32,
    color: &C
)

Draws a filled ellipse

pub fn draw_ellipse_lines<C: ToRgba>(
    &self,
    pos: &Pnt2,
    w: f32,
    h: f32,
    resolution: u32,
    color: &C
)

Dreas an ellipse contour

pub fn origin(&self) -> CoordinateOrigin

Returns the current coordinate origin of these renderer

impl<'c> Renderer<'c>

pub fn with_fbo<F: UntypedOffscreenBuffer + Clone>(
    &self,
    fbo: F
) -> Renderer<'_, F>

Creates a copy of this Renderer but drawing to the passed fbo instead of to the screen

pub fn new_fbo(&self) -> Builder<'_>

Creates a new FBO

Returns an fbo::Builder that allows to configure the fbo further

pub fn new_fbo_color_attachment(&self) -> ColorAttachmentBuilder<'_>

Creates a new FBO color attachment

Returns an fbo::ColorAttachmentBuilder that allows to configure the attachment further

pub fn new_fbo_depth_attachment(&self) -> DepthAttachmentBuilder<'_>

Creates a new FBO depth attachment

Returns an fbo::DepthAttachmentBuilder that allows to configure the attachment further

pub fn new_render_buffer(&self) -> RenderBufferBuilder<'_>

Creates a new FBO render buffer

Returns an fbo::RenderBufferBuilder that allows to configure the render buffer further

pub fn new_simple_fbo(
    &self,
    w: u32,
    h: u32,
    format: ColorFormat
) -> Result<SimpleFbo>

Creates a new SimpleFbo

Directly returns a SimpleFbo if it could be created or the corresponding error

pub fn new_simple_fbo_multisampled(
    &self,
    w: u32,
    h: u32,
    samples: u32,
    format: ColorFormat
) -> Result<SimpleFbo>

Creates a new mutlisampled SimpleFbo

Directly returns a SimpleFbo if it could be created or the corresponding error

pub fn dispatch_compute<U, I>(
    &self,
    program: &Program,
    x: u32,
    y: u32,
    z: u32,
    uniforms: I
) -> Result<()> where
    U: Borrow<Uniform>,
    I: IntoIterator<Item = U>, 

Trait Implementations

impl<'c, R: RenderSurface> CreationContext for Renderer<'c, R>

fn new_ttf<'a>(&'a self, path: &'a str, pt_height: f32) -> Builder<'a>

fn new_ttf_from_bytes<'a>(
    &'a self,
    bytes: &'a [u8],
    pt_height: f32
) -> Builder<'a>

fn new_ttf_material<'a>(&self, ttf: &'a Ttf) -> MaterialBuilder<'a>

fn new_vao_mesh(&self) -> Builder

fn new_vao_path(&self) -> Builder

fn new_auto_program<P: AsRef<Path> + Clone + 'static>(
    &self,
    settings: ProgramSettings<P>
) -> AutoLoader<Program>

fn new_object(&self) -> Builder

fn to_simple_vao<T, U, M: ToSimpleVao<T, U>>(
    &self,
    mesh: &M
) -> Result<SimpleVao<T>>

impl<'c, R: RenderSurface> CreationContext for Renderer<'c, R>

fn capabilities(&self) -> &Capabilities

fn new_texture(&self) -> Builder<'_>

fn new_cubemap(&self) -> Builder<'_>

fn new_buffer(&self) -> Builder<'_>

fn new_shared_buffer(&self) -> SharedBuilder<'_>

fn new_vao(&self) -> Builder

fn new_simple_vao(&self) -> Builder<'_>

fn new_program(&self) -> Builder<'_>

fn new_sampler(&self) -> Sampler

fn new_timestamp_query(&self) -> TimeStamp

fn new_duration_query(&self) -> Duration

fn new_fence(&self) -> Fence

fn creation_proxy(&self) -> &Rc<CreationProxy>

impl<'c, R: RenderSurface + 'c> Renderer2d for Renderer<'c, R>

fn draw_mesh_with_material<T, U, M: Material, G: ToSimpleVao<T, U>>(
    &self,
    mesh: &G,
    material: &M
) where
    T: VertexFormat + Clone + 'static, 

Draws a mesh in RAM using the passed material

fn draw_meshes_with_material<T, U, M: Material, G: ToSimpleVao<T, U>, I: IntoIterator<Item = G>>(
    &self,
    meshes: I,
    material: &M
) where
    T: VertexFormat + Clone + 'static, 

Draws several meshes in RAM using the passed material

fn draw_meshes_with_trafos_and_material<V, U, M: Material, G: ToSimpleVao<V, U>, T: Into<Model>, I: IntoIterator<Item = (G, T)>>(
    &self,
    meshes: I,
    material: &M
) where
    V: VertexFormat + Clone + 'static, 

Draws several meshes in RAM using the passed material

fn draw_mesh_with_trafos_and_material<V, U, M, G, T, I>(
    &self,
    mesh: &G,
    trafos: I,
    material: &M
) where
    V: VertexFormat + Clone + 'static,
    M: Material,
    G: ToSimpleVao<V, U>,
    T: Into<Model>,
    I: IntoIterator<Item = T>, 

Draws several meshes in RAM using the passed material

fn draw_pos<M: Material, O: Render2d<Material = M>>(&self, obj: O, pos: &Pnt2)

Draws any Render2d at the passed position

fn draw_size<M: Material, O: Render2d<Material = M>>(
    &self,
    obj: O,
    pos: &Pnt2,
    size: &Vec2
)

Draws any Render2d at the passed position and size

fn draw_rect<M: Material, O: Render2d<Material = M>>(
    &self,
    obj: O,
    rect: &Rect<f32>
)

Draws any Render2d at the position of the passed rectangle and it’s size

fn draw_pos_with_material<M: Material, M2: Material, O: Render2d<Material = M>>(
    &self,
    obj: O,
    pos: &Pnt2,
    mat: &M2
)

Draws any Render2d at the passed position with the passed material

fn draw_size_with_material<M: Material, M2: Material, O: Render2d<Material = M>>(
    &self,
    obj: O,
    pos: &Pnt2,
    size: &Vec2,
    mat: &M2
)

Draws any Render2d at the passed position and size with the passed material

fn draw_rect_with_material<M: Material, M2: Material, O: Render2d<Material = M>>(
    &self,
    obj: O,
    rect: &Rect<f32>,
    mat: &M2
)

Draws any Render2d at the position of the passed rectangle and it’s size with the passed material

impl<'c, R: RenderSurface + 'c> Renderer3d for Renderer<'c, R>

fn draw<O: Render3d>(&self, obj: &O)

Draw a Render3d

fn draw_with_material<V, M>(&self, obj: &Object<V>, material: &M) where
    &'a V: VaoDraw,
    M: Material, 

Draw a Render3d with the passed material

fn draw_vao_with_material<V, M>(&self, vao: V, material: &M) where
    V: VaoDraw,
    M: Material, 

Draw a VAO with the passed material

fn draw_vao_with_model_material<V, M, MO>(
    &self,
    vao: V,
    model: MO,
    material: &M
) where
    V: VaoDraw,
    M: Material,
    MO: Into<Model>, 

Draw a VAO with the passed material and Into model matrix

fn draw_instanced_vao_with_material<V, M>(
    &self,
    vao: V,
    num_instances: usize,
    material: &M
) where
    V: VaoDraw,
    M: Material, 

Draw several instances of the passed VAO with the passed materlal

fn draw_vao_with_model<'a, V, M, U>(
    &self,
    vao_range: V,
    model: M,
    program: &Program,
    uniforms: U
) where
    V: VaoDraw,
    U: IntoIterator<Item = &'a Uniform>,
    M: Into<Model>, 

Draw a VAO with the passed Into model matrix, program and uniforms

fn draw_vao<'a, V, U>(&self, vao_range: V, program: &Program, uniforms: U) where
    V: VaoDraw,
    U: IntoIterator<Item = &'a Uniform>, 

Draw a VAO with the passed program and uniforms

fn draw_instanced_vao<'a, V, U>(
    &self,
    vao_range: V,
    num_instances: usize,
    program: &Program,
    uniforms: U
) where
    V: VaoDraw,
    U: IntoIterator<Item = &'a Uniform>, 

Draw several instances of the passed VAO with the passed program and uniforms

impl<'c> SurfaceCreationContext for Renderer<'c>

fn new_fbo(&self) -> Builder<'_>

fn new_fbo_color_attachment(&self) -> ColorAttachmentBuilder<'_>

fn new_fbo_depth_attachment(&self) -> DepthAttachmentBuilder<'_>

fn new_render_buffer(&self) -> RenderBufferBuilder<'_>