Rendering basics

This case outlines the main building blocks of the SKY ENGINE AI rendering system.

Agenda:

• Rendering script basic elements
• Scene layout
• Geometry
• Material
• Lights
• Background
• Appendix: Camera

In this tutorial you will learn how to set up the script elements to render default scene, as well as scene loaded
from the prepared geometry files. You will get to know how to prepare a typical pipeline for rendering and
elements that can be changed.

Rendering script basic elements

In order to render a scene, you will need a couple of objects created for this sole task. These are the elements
that have to be set up before any time you call render function. Don't worry if you won't remember it though - you
can come back to this tutorial any time, and you will see those functions again several times.

Logger and root paths

In the first lines of the script, we recommend configuring the logger before anything else, this will help you
track possible errors and warnings.

The most important object in our rendering engine is the Renderer Context, and it will set it up in a second. To
initialize it, we need to specify root paths of assets, cache, configs and GPU sources (None means default).

Renderer Context

The SKY ENGINE AI renderer system is context-based. The RendererContext is responsible for memory,
state and randomization management. It stores all units, unit blueprints, possible configurations,
communicates with GPU and synchronizes the whole rendering process.

Example Assistant and Display Config

For convenience, you can create an ExampleAssistant. This is a utility class, which is used to handle
visualization. As with every other object, it is bound with RendererContext.
ExampleAssistant and is configured with the DisplayConfig.

Now that we explained all elements above...
... we will initialize them for you, so you don't have to be worried about unnecessary initialization.

The initialization of the above elements is hidden in the constructor of the class called SceneComposer.
Therefore, to focus only on the most important aspects of the rendering pipeline, we created new class derived
from SceneComposer. In this class all initialization, as well as logging and rendering functions are already
written in the base class, all that is left to do is to write function setting up the scene.

With SceneComposer, the initialization is equal to calling custom SceneComposer constructor.

In the beginning, there was nothing.

...Or there wasn't?
Some 3D software have starting cube being set up in the default layout, some - empty space with only grid lines,
ours - a sphere in the space origin.

This is the default scene that will welcome you when you try to render the scene, without adding any geometry nor
other scene elements.

Scene layout

We can print out the layout of the scene elements in the form of the scene tree. At this moment, while the scene
is being prepared, all elements are stored in the object called SceneLayoutTree.

The SceneLayoutTree is located in RendererContext, while RendererContext instance is stored in SceneComposer, so
to print the layout you need to call only:

The output of the above method is the scene layout tree that consist of nodes existing in the scene.
The layout that we will work on is called "user_defined", and it's empty, as we didn't load anything yet there.

Usually, the scene consists of several elements:

• geometries,
• materials,
• lights,
• background.

Each of such building blocks of the SKY ENGINE AI rendering engine share a similar structure to make it easier
for the user to build complex scenes using simple tools.
The structure consists of the following elements:

• provider - an asset loader, a link between the rendering engine and the assets,
• procedure - pack of programs responsible for GPU processing,
• parameter_provider - parameters that customize the procedure, each procedure can produce its own default
  parameter provider - there is a _create_parameterprovider class method in each procedure,
• strategy and randomization_group - rules for distribution and synchronization of the parameters.

More information of the above parts of each of scene entity, check out INTRO_Providers, INTRO_Procedures,
PROVIDER_Parameter_Provider, INTRO_Randomization.

In this tutorial we will start with loading geometry block into the scene.

Geometry

Geometry, or mesh, is a block storing information about the shape of the 3D object. There are multiple ways
to represent the 3D objects data, as well as multiple ways to store it in a file. More about geometry can be found
in the tutorial INTRO_Geometries.

For the case of this tutorial, we have already prepared the geometry to be loaded in the Alembic files. We will
load it for you with dedicated method:

Notice that we print for you new layout of the scene, just after loading the geometry. The layout now consists not
only 4 elements, but much more.

The scene wouldn't normally be visible, as there is no light in the scene, but to see any output we adjusted
ambient gain in the default shader, to be able to see the geometry.

If you want to learn how to load geometry into SkyRenderer, feel free to inspect above function. For more
information about loading geometries, check out INTRO_Geometries, INTRO_Intersectors and tutorials with
GEOMETRY tag. More about loading mesh from Alembic file can be found in GEOMETRY_MeshABC.

Materials

Materials, or rather MaterialDefinition in SkyRenderer, are recipies used to define material properties of
the geometries' surfaces existing in the scene. For instance, we can create sphere geometry, but whether it will
appear to be made of glass or plastic, is dependent of the sphere's material definition.
For more information about materials, check out INTRO_Materials tutorial.

Bare materials

First, we will start with adding some materials, more or less in correct colors, to the objects. To add the
materials into the scene, we will use dedicated method:

Notice the difference between the coffee glass and other materials. That's because even without the textures, we
can assign materials of different physical properties, thanks to using different shaders for specific objects.
Our most common shader is PBRShader which is used for the majority of surfaces rendered in our examples. This is
the shader used in this scene for everything except coffee and window glass - which is rendered with GlassShader -
and coffee liquid rendered with TranslucentShader.

If you want to know more about shaders, be sure to visit INTRO_Shaders and tutorials in SHADER section.

Materials with textures

In order to load textures to our materials, we have to reinitialize them, adding proper texture provider to chosen
materials. Don't worry, our function load_materials has predicted that possibility, and has dedicated flag just
to load texture files into texture providers and pass this parameter to appropriate materials.

You can notice that window received transparent texture, window frame is now wooden and mat under the coffee cup
is now stained with coffee. Loading textures added also details in the surface roughness like fingerprints on the
metal part of the window frame or scratches on the metal of the chair. They might be now visible at first glance
because of the lack of lighting in the scene but after adding the lights it will significantly boost the realism
of the scene.

More information about the texture files can be found in ASSETS_Textures and ASSETS_Substances.

Background

Background is the definition of the surrounding environment. Background definition is used to determine what
should be displayed in the image for pixels where rays do not intersect with any surface.

By default, it is a constant color of very dark gray - RGB (8,8,8). You can notice the same color, just behind the
window.
For most of the scenes, displaying such color for background in not sufficient to render realistic scenes.
In order to enhance the realism, you can load environmental image texture and bind it to the definition of the
displayed background. In our engine we use HDR files of equirectangular environment map. Due to the fact that
High-Dynamic-Range environmental maps store information regarding strength of colors, we can identify in them
brighter regions allowing us to illuminate the scene in a natural way. Let's load such image with a function below
and see how light from the environmental map is added:

To learn more about environmental image mapping and HDR assets, check out PROVIDER_HDRTextureProvider and
ASSETS_HDR.

Lights

The assets for our scene are loaded, and you might think it lacks this... something. You are correct.

One of the most important things, yet in many cases deeply underestimated, is lighting of the scene. As there are
no custom assets for lights (except partially environment maps), scene lighting is left default or is set up
very roughly.

In this part we will set up the lights. First, we will remove the ambient light factor from the materials, and
we will add 4 lights to the scene:

• light imitating sun from the outside of the window,
• light from the outside, serving as the contrasting light to the sun lighting,
• indoor light from the ceiling,
• indoor light, to brighten the objects inside the room softly.

In a moment, you will see how much the scene changes when proper lighting is introduced to the scene:

The difference between the previous scene render and the new one is enormous. The importance of the proper
lighting in the scene should not be neglected, as its lack might completely ruin the final render.

Appendix: Camera

As the supplement part of this tutorial we will show you how to change last significant part of the scene setup:
the camera. As it is not essential part from the scene setup perspective, treat this part as a supplement chapter
to see other views on our scene.

To learn how to set up camera yourself, check out tutorial INTRO_CameraRenderStep and lens tutorials:
INTRO_Lens and SENSOR tutorial section.

Summary

In this section you have learnt:

• Usual scene setup consists of setting up elements such as: geometry, materials, lights, background, camera.