Struct Renderer

pub struct Renderer(/* private fields */);

Implementations

impl Renderer

pub fn new() -> Renderer

Instantiates a new (unconnected) Renderer object. A Renderer represents a means to render. It encapsulates the selection of an underlying driver, such as OpenGL or OpenGL-ES and a selection of a window system binding API such as GLX, or EGL or WGL.

While the renderer is unconnected it can be configured so that applications may specify backend constraints, such as “must use x11” for example via Renderer::add_constraint.

There are also some platform specific configuration apis such as cogl_xlib_renderer_set_foreign_display that may also be used while the renderer is unconnected.

Once the renderer has been configured, then it may (optionally) be explicitly connected using Renderer::connect which allows errors to be handled gracefully and potentially fallback configurations can be tried out if there are initial failures.

If a renderer is not explicitly connected then Display::new will automatically connect the renderer for you. If you don’t have any code to deal with error/fallback situations then its fine to just let Cogl do the connection for you.

Once you have setup your renderer then the next step is to create a Display using Display::new.

<note>Many applications don’t need to explicitly use Renderer::new or Display::new and can just jump straight to Context::new and pass a None display argument so Cogl will automatically connect and setup a renderer and display.</note>

Returns

A newly created Renderer.

pub fn add_constraint(&self, constraint: RendererConstraint)

This adds a renderer selection constraint.

Applications should ideally minimize how many of these constraints they depend on to ensure maximum portability.

constraint

A RendererConstraint to add

pub fn check_onscreen_template( &self, onscreen_template: &OnscreenTemplate, ) -> Result<bool, Error>

Tests if a given onscreen_template can be supported with the given self.

onscreen_template

A OnscreenTemplate

Returns

true if the onscreen_template can be supported, else false.

pub fn connect(&self) -> Result<bool, Error>

Connects the configured self. Renderer connection isn’t a very active process, it basically just means validating that any given constraint criteria can be satisfied and that a usable driver and window system backend can be found.

Returns

true if there was no error while connecting the given self. false if there was an error.

pub fn foreach_output<P: FnMut(&Output)>(&self, callback: P)

Iterates all known display outputs for the given self and passes a corresponding Output pointer to the given callback for each one, along with the given user_data.

callback

A CoglOutputCallback to be called for each display output

user_data

A user pointer to be passed to callback

pub fn get_driver(&self) -> Driver

Queries what underlying driver is being used by Cogl.

This may only be called on a connected Renderer.

pub fn get_n_fragment_texture_units(&self) -> i32

Queries how many texture units can be used from fragment programs

Returns

the number of texture image units.

pub fn get_winsys_id(&self) -> WinsysID

Queries which window system backend Cogl has chosen to use.

This may only be called on a connected Renderer.

Returns

The WinsysID corresponding to the chosen window system backend.

pub fn remove_constraint(&self, constraint: RendererConstraint)

This removes a renderer selection constraint.

Applications should ideally minimize how many of these constraints they depend on to ensure maximum portability.

constraint

A RendererConstraint to remove

pub fn set_driver(&self, driver: Driver)

Requests that Cogl should try to use a specific underlying driver for rendering.

If you select an unsupported driver then Renderer::connect will fail and report an error. Most applications should not explicitly select a driver and should rely on Cogl automatically choosing the driver.

This may only be called on an un-connected Renderer.

pub fn set_winsys_id(&self, winsys_id: WinsysID)

This allows you to explicitly select a winsys backend to use instead of letting Cogl automatically select a backend.

if you select an unsupported backend then Renderer::connect will fail and report an error.

This may only be called on an un-connected Renderer.

winsys_id

An ID of the winsys you explicitly want to use.

Trait Implementations

impl Clone for Renderer

fn clone(&self) -> Renderer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Renderer

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

Formats the value using the given formatter.

impl Default for Renderer

fn default() -> Self

Returns the “default value” for a type.

impl Display for Renderer

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

Formats the value using the given formatter.

impl Hash for Renderer

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Renderer

fn cmp(&self, other: &Renderer) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: ObjectType> PartialEq<T> for Renderer

fn eq(&self, other: &T) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: ObjectType> PartialOrd<T> for Renderer

fn partial_cmp(&self, other: &T) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Renderer

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Renderer

impl IsA<Object> for Renderer