Trait GraphicsServer

pub trait GraphicsServer: Downcast {
    // Required methods
    fn create_buffer(
        &self,
        size: usize,
        buffer_kind: BufferKind,
        buffer_usage: BufferUsage,
    ) -> Result<Box<dyn Buffer>, FrameworkError>;
    fn create_texture(
        &self,
        desc: GpuTextureDescriptor<'_>,
    ) -> Result<Rc<RefCell<dyn GpuTexture>>, FrameworkError>;
    fn create_frame_buffer(
        &self,
        depth_attachment: Option<Attachment>,
        color_attachments: Vec<Attachment>,
    ) -> Result<Box<dyn FrameBuffer>, FrameworkError>;
    fn back_buffer(&self) -> Box<dyn FrameBuffer>;
    fn create_query(&self) -> Result<Box<dyn Query>, FrameworkError>;
    fn create_program(
        &self,
        name: &str,
        vertex_source: &str,
        fragment_source: &str,
    ) -> Result<Box<dyn GpuProgram>, FrameworkError>;
    fn create_program_with_properties(
        &self,
        name: &str,
        vertex_source: &str,
        fragment_source: &str,
        properties: &[ShaderResourceDefinition],
    ) -> Result<Box<dyn GpuProgram>, FrameworkError>;
    fn create_async_read_buffer(
        &self,
        pixel_size: usize,
        pixel_count: usize,
    ) -> Result<Box<dyn AsyncReadBuffer>, FrameworkError>;
    fn create_geometry_buffer(
        &self,
        desc: GeometryBufferDescriptor<'_>,
    ) -> Result<Box<dyn GeometryBuffer>, FrameworkError>;
    fn weak(self: Rc<Self>) -> Weak<dyn GraphicsServer>;
    fn flush(&self);
    fn finish(&self);
    fn invalidate_resource_bindings_cache(&self);
    fn pipeline_statistics(&self) -> PipelineStatistics;
    fn swap_buffers(&self) -> Result<(), FrameworkError>;
    fn set_frame_size(&self, new_size: (u32, u32));
    fn capabilities(&self) -> ServerCapabilities;
    fn set_polygon_fill_mode(
        &self,
        polygon_face: PolygonFace,
        polygon_fill_mode: PolygonFillMode,
    );

    // Provided method
    fn create_2d_render_target(
        &self,
        pixel_kind: PixelKind,
        width: usize,
        height: usize,
    ) -> Result<Rc<RefCell<dyn GpuTexture>>, FrameworkError> { ... }
}

Graphics server is an abstraction layer over various graphics APIs used on different platforms supported by the engine. Such abstraction layer tries to provide more or less high-level and unified interface, that can be used to build graphics pipelines quickly and more or less efficiently.

Low-level GAPI-specific optimizations could be performed using direct access to the underlying API, by downcasting to a specific type.

Required Methods

fn create_buffer( &self, size: usize, buffer_kind: BufferKind, buffer_usage: BufferUsage, ) -> Result<Box<dyn Buffer>, 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<Rc<RefCell<dyn GpuTexture>>, FrameworkError>

Creates a new GPU texture using the given descriptor.

fn create_frame_buffer( &self, depth_attachment: Option<Attachment>, color_attachments: Vec<Attachment>, ) -> Result<Box<dyn FrameBuffer>, 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) -> Box<dyn FrameBuffer>

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

fn create_query(&self) -> Result<Box<dyn Query>, FrameworkError>

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

fn create_program( &self, name: &str, vertex_source: &str, fragment_source: &str, ) -> Result<Box<dyn GpuProgram>, FrameworkError>

Creates a new named GPU program using a pair of vertex and fragment shaders. The name could be used for debugging purposes.

fn create_program_with_properties( &self, name: &str, vertex_source: &str, fragment_source: &str, properties: &[ShaderResourceDefinition], ) -> Result<Box<dyn GpuProgram>, FrameworkError>

Almost the same as Self::create_program, but accepts additional array of resource definitions. The implementation of graphics server will generate proper resource bindings in the shader code for you.

fn create_async_read_buffer( &self, pixel_size: usize, pixel_count: usize, ) -> Result<Box<dyn AsyncReadBuffer>, 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: GeometryBufferDescriptor<'_>, ) -> Result<Box<dyn GeometryBuffer>, 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: Rc<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 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. See PolygonFace and PolygonFillMode docs for more info.

Provided Methods

fn create_2d_render_target( &self, pixel_kind: PixelKind, width: usize, height: usize, ) -> Result<Rc<RefCell<dyn GpuTexture>>, FrameworkError>

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

Implementors

impl GraphicsServer for GlGraphicsServer