Rendering Pipeline Sequence Quick Reference

With a rising number of beginners inquiring about forward and deferred rendering, let’s explore the essence of rendering pipelines.

Just as in drawing, our rendering process begins with outlining the house (opaque objects). This strategic approach allows us to skip drawing the background and other elements hidden behind the house, saving on pigment. Following this, we proceed to sketch the background (skybox). Finally, we add the windows (transparent objects). Drawing these transparent elements last is essential, ensuring that the background and other non-transparent elements show through seamlessly.

Here’s a summary of the order: 1. Opaque objects -> 2. Skybox -> 3. Transparent objects. In fact, this represents the fundamental rendering process.

Now, let’s analyze the rendering order of opaque objects. Essentially, we commence by drawing those closest to the camera and progressively render those farther away. This approach ensures that objects blocked by closer elements are omitted, saving on paint and unnecessary rendering. The necessity for sorting opaque objects from nearest to farthest is depicted in the following diagram:

Next, let’s delve into the transparent objects. Since we aim to showcase objects that are farther from the camera, we begin by drawing the distant objects, followed by the ones closer in sequence. This process contrasts with that of opaque objects. Hence, sorting transparent objects from farthest to nearest is crucial, as depicted in the following diagram:

Moving on, let’s discuss the ZBuffer. Essentially, you can think of it as another canvas overlaying the one currently being painted. It records the distance from each pixel on the canvas to the camera. Every time we paint opaque objects, we interpret the painted area as individual pixels. Simultaneously, we check whether each pixel is closer to the camera than the ZBuffer’s recorded distance. If it is, we can paint it and update its distance (depth) in the ZBuffer. This way, we can utilize the ZBuffer to reduce the number of pixels being painted. This mechanism is known as “EarlyZ”.

Additionally, when rendering the skybox, it’s common practice to position it far from the camera. Essentially, when ZBuffer values are present, they won’t pass the ZTest. Consequently, we employ this strategy to minimize the number of pixels processed for the skybox.

Finally, let’s delve into the aspect concerning transparent objects and the ZBuffer. Generally, transparent objects have a tendency to unveil objects that are farther away. Consequently, we typically refrain from writing their depth values to the ZBuffer. Nonetheless, we still conduct checks against the current ZBuffer. As depth values are not written, it becomes imperative to sort transparent objects from farthest to nearest to ensure the correct display effect.

In conclusion, the rendering pipeline is not as intricate as one might initially perceive. With a grasp of the fundamental rendering process, understanding Forward and deferred rendering becomes more transparent. There’s an opportunity to explore additional advanced topics related to rendering pipelines in future discussions.