Struct GlGraphicsServer 

pub struct GlGraphicsServer {
    pub gl: Context,
    pub named_objects: Cell<bool>,
    /* private fields */
}

GlGraphicsServer implements the GraphicsServer trait using the glow crate. glow is “GL on Whatever: a set of bindings to run GL anywhere (Open GL, OpenGL ES, and WebGL) and avoid target-specific code.”

Fields

gl: Context

glow::Context provides access to the current rendering state. It creates buffers, creates textures, compiles shaders, accepts geometry data, and broadly provides access too all sorts of rendering services.

named_objects: Cell<bool>

Controls whether objects the glow::Context::object_label method should be used to assign labels to rendering objects. These labels can help with debugging.

Implementations

impl GlGraphicsServer

pub fn new( vsync: bool, msaa_sample_count: Option<u8>, window_target: &ActiveEventLoop, window_attributes: WindowAttributes, named_objects: bool, ) -> Result<(Window, Rc<dyn GraphicsServer>), FrameworkError>

pub fn weak(&self) -> Weak<GlGraphicsServer>

A weak reference to the Rc where the server is stored.

pub fn gl_kind(&self) -> GlKind

Determine if we are using the embedded version of OpenGL.

pub fn free_texture_unit(&self) -> Option<u32>

Find the number of a texture unit where no texture is bound, if possible.

pub fn delete_program(&self, program: <Context as HasContext>::Program)

Delete the given program. See glDeleteProgram from OpenGL.

Trait Implementations

impl GraphicsServer for GlGraphicsServer

fn create_buffer( &self, desc: GpuBufferDescriptor<'_>, ) -> Result<GpuBuffer, FrameworkError>

Creates a GPU buffer with the given size and kind. Usage is a hint to the video driver that allows to perform some potential performance optimizations.

fn create_texture( &self, desc: GpuTextureDescriptor<'_>, ) -> Result<GpuTexture, FrameworkError>

Creates a new GPU texture using the given descriptor.

fn create_sampler( &self, desc: GpuSamplerDescriptor, ) -> Result<GpuSampler, FrameworkError>

Creates a new GPU sampler that can be used to sample texels from a texture.

fn create_frame_buffer( &self, depth_attachment: Option<Attachment>, color_attachments: Vec<Attachment>, ) -> Result<GpuFrameBuffer, FrameworkError>

Creates a new frame buffer using the given depth and color attachments. Depth attachment not exist, but there must be at least one color attachment of a format that supports rendering.

fn back_buffer(&self) -> GpuFrameBuffer

Creates a frame buffer that “connected” to the final image that will be displayed to the screen.

fn create_query(&self) -> Result<GpuQuery, FrameworkError>

Creates a new GPU query, that can perform asynchronous data fetching from GPU. Usually it is used to create occlusion queries.

fn create_shader( &self, name: String, kind: ShaderKind, source: String, resources: &[ShaderResourceDefinition], line_offset: isize, ) -> Result<GpuShader, FrameworkError>

Creates a new named GPU shader. The name could be used for debugging purposes. The implementation of graphics server will generate proper resource bindings in the shader code for you.

fn create_program( &self, name: &str, vertex_source: String, vertex_source_line_offset: isize, fragment_source: String, fragment_source_line_offset: isize, resources: &[ShaderResourceDefinition], ) -> Result<GpuProgram, FrameworkError>

Creates a new named GPU program using source code of both vertex and fragment shaders. The name could be used for debugging purposes. The implementation of graphics server will generate proper resource bindings in the shader code for you.

fn create_program_from_shaders( &self, name: &str, vertex_shader: &GpuShader, fragment_shader: &GpuShader, resources: &[ShaderResourceDefinition], ) -> Result<GpuProgram, FrameworkError>

Creates a new named GPU program using a pair of vertex and fragment shaders. The name could be used for debugging purposes. The implementation of graphics server will generate proper resource bindings in the shader code for you.

fn create_async_read_buffer( &self, name: &str, pixel_size: usize, pixel_count: usize, ) -> Result<GpuAsyncReadBuffer, FrameworkError>

Creates a new read-back buffer, that can be used to obtain texture data from GPU. It can be used to read rendering result from GPU to CPU memory and save the result to disk.

fn create_geometry_buffer( &self, desc: GpuGeometryBufferDescriptor<'_>, ) -> Result<GpuGeometryBuffer, FrameworkError>

Creates a new geometry buffer, which consists of one or more vertex buffers and only one element buffer. Geometry buffer could be considered as a complex mesh storage allocated on GPU.

fn weak(&self) -> Weak<dyn GraphicsServer>

Creates a weak reference to the shared graphics server.

fn flush(&self)

Sends all scheduled GPU command buffers for execution on GPU without waiting for a certain threshold.

fn finish(&self)

Waits until all the scheduled GPU commands are fully executed. This is blocking operation, and it blocks the current thread until all the commands are fully executed.

fn invalidate_resource_bindings_cache(&self)

Unbinds the all bound resources from the graphics pipeline.

fn pipeline_statistics(&self) -> PipelineStatistics

Returns GPU pipeline statistics. See PipelineStatistics for more info.

fn swap_buffers(&self) -> Result<(), FrameworkError>

Swaps the front and back buffers and thus presenting the final image on screen. There could be more than two buffers, and it is up to the graphics server implementation to choose the right amount, but it can’t be less than two.

fn set_frame_size(&self, new_size: (u32, u32))

Notifies the graphics server that the size of the back buffer has changed. It has very limited use and there are very few platforms (Linux with Wayland mostly) that needs this function to be called.

fn generate_mipmap(&self, texture: &GpuTexture)

Generates mipmaps for the given texture. Graphics server implementation can pick any desired way of mipmaps generation, depending on the underlying GAPI capabilities.

fn capabilities(&self) -> ServerCapabilities

Returns current capabilities of the graphics server. See ServerCapabilities for more info.

fn set_polygon_fill_mode( &self, polygon_face: PolygonFace, polygon_fill_mode: PolygonFillMode, )

Sets current polygon fill mode for front faces, back faces, or both. The mode of front faces is controlled separately from the mode of back faces, and polygon_face determines which mode is set by this method. See PolygonFace and PolygonFillMode docs for more info.

fn memory_usage(&self) -> ServerMemoryUsage

Fetches the total amount of memory used by the graphics server.

fn push_debug_group(&self, name: &str)

Begins a new named debug group. It is recommended to use Self::begin_scope instead, so that the compiler will manage the scope lifetime for your correctly. Otherwise, a forgotten call to Self::pop_debug_group may cause stack overflow or underflow errors.

fn pop_debug_group(&self)

Ends the current debug group.

fn begin_scope(&self, name: &str) -> RenderingScope

Begins a new debug scope by creating a temporary object that automatically exits the scope on drop. The scope could be created like so: let _debug_scope = server.begin_scope("ScopeName"); Note the let _debug_scope = ... part - it is important to keep the produced object alive until the end of the current semantic scope. Do not call this method like so: server.begin_scope("VisibilityTest"); because it will enter and leave the scope instantly.

fn create_2d_render_target( &self, name: &str, pixel_kind: PixelKind, width: usize, height: usize, ) -> Result<GpuTexture, FrameworkError>

A shortcut for Self::create_texture, that creates a rectangular texture with the given size and pixel kind.

fn create_cube_render_target( &self, name: &str, pixel_kind: PixelKind, size: usize, ) -> Result<GpuTexture, FrameworkError>

A shortcut for Self::create_texture, that creates a cube texture with the given size and pixel kind.