A GPU based renderer for the web.
It serves as an experimental render backend for Servo, but it can also be used as such in a standalone application.
WebRender currently depends on FreeType
The main entry point to WebRender is the
RenderApi instance, which is responsible for managing resources
and documents. A worker thread is used internally to untie the workload from the application
thread and therefore be able to make better use of multicore systems.
What is referred to as a
frame, is the current geometry on the screen.
A new Frame is created by calling
RenderApi. When the geometry is processed, the application will be
informed via a
RenderNotifier, a callback which you pass to
More information about stacking contexts.
set_display_list() also needs to be supplied with
BuiltDisplayLists. These are obtained by finalizing a
DisplayListBuilder. These are used to draw your geometry. But it
doesn't only contain trivial geometry, it can also store another
StackingContext, as they're nestable.
Internal representation of clips in WebRender.
A generic backing store for caches.
Overview of the GPU cache.
The interning module provides a generic data structure interning container. It is similar in concept to a traditional string interning container, but it is specialized to the WR thread model.
A picture represents a dynamically rendered image.
The high-level module responsible for managing the pipeline and preparing
commands to be issued by the
This module contains the render task graph.
The high-level module responsible for interfacing with the GPU.
Screen capture infrastructure for the Gecko Profiler and Composition Recorder.
A handle to a screenshot that is being asynchronously captured and scaled.
A handle to a recorded frame that was captured.
Return type from render(), which contains some repr(C) statistics as well as some non-repr(C) data.
The renderer is responsible for submitting to the GPU the work prepared by the RenderBackend.
Some basic statistics about the rendered scene, used in Gecko, as well as in wrench reftests to ensure that tests are batching and/or allocating on render targets as we expect them to.
Flags that control how shaders are pre-cached, if at all.
Method of uploading texel data from CPU to GPU.
Allows callers to hook into the main render_backend loop and provide additional frame ops for generate_frame transactions. These functions are all called from the render backend thread.
Defines the interface for hooking up an external profiler to WR.
The interfaces that an application can implement to handle ProgramCache update
Allows callers to hook in at certain points of the async scene build. These functions are all called from the scene builder thread.
Creates heap-allocated strings for both vertex and fragment shaders. Public to be accessible to tests.
Set the profiler callbacks, or None to disable the profiler. This function must only ever be called before any WR instances have been created, or the hooks will not be set.