Gfx Engine - Offscreen Render Target
An offscreen render target, also known as an offscreen framebuffer, is a technique used in computer graphics to render images or scenes to a location in memory that is not directly visible on the screen. Instead of rendering it directly on the screen, the graphics engine renders the scene to a buffer in memory
Using offscreen render targets can speed up rendering of multiple sprites by minimizing the number of draw calles required to render them on the screen. Here is how it works:
-
Batching: When rendering sprites individually, each sprite requires a separate draw call. Each draw call incurs overhead in the form of CPU-GPU communication and setup time. By rendering multiple sprites to an offscreen render target in a single draw call, you can batch together the rendering of multiple sprites into one operation, significantly reducing the overhead associated with individial draw calls.
-
Efficient Rendering: Rendering sprites to an offscreen render target allows for more efficient rendering techniques. For example, sprites can be sorted and grouped before rendering to minimize overdraw (the process of rendering pixels that will later be covered by other objects), leading to imporved performance.
-
Caching: Once multiple sprites are rendered to an offscreen render target, the resulting image can be cached and reused if the sprites don't change frequently. This means that if the same set of sprites needs to be rendered again in a subsequent frame, the cached image can be quickly drawn onto the screen without the need for recomputation, saviung valuable device resources.
Overall, by consolidating the rendering of multiple sprites into a single operation and optimizing the rendering process, offscreen render targets can significantly improve rendering performance when dealing with large numbers of sprites in a scene.
So, in order to creaate and use an offscreen render target whth GFX Engine, we need to do the following:
- Create an
OffscreenRenderTargetobject and register it in the scene - Add visual objects to the render target inside its own
Begin()-End()block
then
- Add the render target object to the screen inside the
Begin()-End()block in theon_Render()function - Dispose the render target object when it's not needed anymore to free system resources
Let's look at each step separately.
Step 1 - Initialization
The OffscreenRenderTarget class has just one constructor:
As you can see from the source above, the render target can be creted with different resolutions and pixel formats. The pixel format parameter defines how many bits per color definition of one pixel of a render targets must be used. The "higher" pixel format is, more memory is required for creation of an offscreen render target.
-
u32_t width
Render target width, in pixels -
u32_t height
Render target height, in pixels -
Cubios::GFX_PixelFormat_t format
Render target pixel format. Please see GFX Engine documentation for available formats
Please pay attention, none of these parameters can be changed on-the-fly once the render target object is created. In order to change render target parameters, you will have to dispose current render target object and create a new one from scratch.
Registering an offscreen render target object in a scene can be done this way:
Step 2 - Adding visuals to the render target
Once your render target is created, you would want to add (or to "draw") some objects onto it before rendering the render target image on the screen.
The process of adding visual objects to a render target is no different to the way you add objects to a screen directly: a render target object has its own Begin and End methods, and the objects should be simply added inside the Begin-End block:
Obviously, the visual objects to add must be created and registered in a scene beforehand.
Step 3 - Rendering
All renderable GFX Engine objects are drawn by adding them to the current screen, and an OffscreenRenderTarget is not an exclusion. The addition is done inside the Begin()-End() block, which is used to inform the engine about the start and end of the process of adding objects, as well as about the orientation control mode and automatic rotation.
An elementary example looks like this:
The Screen::Add() function returns a pointer to the object that was added. Therefore, if it is necessary to dynamically change any object parameters (for example, the position on the screen), in-place setters are used, as shown below:
Step 4 - Disposing render target object
When the offscreen render target object is not needed anymore, the object MUST be deleted. Although there is a dedicated native function GFX_removeBakedImage, an OffscreenRenderTarget object can be simply disposed with
as its descructor performs the neccessary cleanup automatically.
The Example
In this example, we will create and render an offscreen render target bitmap.
The first step, as always, is the initialization of resources in the InitializeResources() function. We create some tile sprites that will then be used to compose a complex scene rendered onto the offscreen render target:
Note the last funcion, prepareOffscreenResource(). In that function, the offscreen render target object is created and the composition of tile sprites is done.
Now that the images are loaded and the render target is prepared and assigned with GfxObjects::myRT identifier, we can simply render it same way we render ordinary sprites. This is done in on_Render() function:
Done!