Randomization

Randomization Basics

The randomization is defined by four elements: providers, receivers, strategies and randomization groups.
We will cover what are these elements in this introductory case in such manner it will allow us to use
randomization in SkyRenderer.

Agenda:

• Providers and Receivers
• Synchronization
• Custom synchronization

Providers and Receivers

Each asset source used in the rendering scene must have its provider. There are providers for:
textures from files:

• FileTextureProvider
• HDRTextureProvider

substance textures:

• SubstanceTextureProvider

mesh buffers:

• ObjBufferProvider
• AlembicBufferProvider

and others. Parameters are also a source of information, often randomized, so they are also handled by providers.
Each provider can have many receivers for its assets. For example, if there are 10 instances of an object
constructed from Alembic mesh and Substance textures, there will be one Alembic mesh provider,
one Substance texture provider, 10 materials (texture receivers) and 10 geometries (mesh buffers receivers).
Each receiver defines the strategy it uses for randomization and randomization group it's in.

Let's render a simple scene to demonstrate that:

We will now create a simple shader parameter provider.

There are 7 spheres in each row and column and their names have the following structure: "sphere{row}{col}".
We want to assign the Material of one of them to be a receiver of newly created provider. Firstly, we have
to create an instance of MaterialDefinition, and then we can assign it to the proper sphere.

Let's see the result of the render first.

To avoid verbosity from now on, we will use a custom method of scene composer called color_spheres() which wraps
above steps into a single line. So far there was no randomization involved. We will change that now.
Let's start by changing the red color to a random one. For this task we can use FloatInput.
Input is a special type used for creating random values.

To make sure that it is indeed random let's assign random color to every sphere on the scene.

Synchronization

To synchronize colors between spheres, we need to use randomization groups and randomization strategies.
By default, all the spheres are in the same group, so group synchronization will bind them all together.
That's why in the next example we don't have to set randomization groups and we can use a default one.
As for the strategies, there are quite a few predefined synchronization strategies to use out of the box:

• EQUAL
• EQUAL_IN_GROUP
• DISTINCT_EQUAL_GROUPS
• UNIQUE
• UNIQUE_IN_GROUP
• UNRESTRICTED

And the same with a helper.

Now lets put each row to a different synchronization group.

Now with the same group assignment we can synchronize inputs for the whole strategy.
All the spheres use the same strategy, so they are all the same.

Now we can start playing with the shapes. With 7 possible radii and 7 rows, the difference will be visible.
Let's see the default, randomized strategy.

And now let's force different radii inside groups. Each row is a different group. Note, that there are no
radius repetitions in rows.

There is one additional option. The value can be drawn distinctly for each group, which means that
it's synchronized in a group, but different groups cannot share the same value.

For the examples above we were working with a simple 3-dimensional FloatInput to generate colors, but
there are more advanced options available too. For example, if you want to synchronize the color intensity
without changing its hue or saturation, the natural solution would be to use HSV model.

First, let's reset the geometry and strategies to default.

Randomized intensity grayscale:

Randomized intensity red:

Custom synchronization

It's not possible to anticipate every possible synchronization problem, so if the provided options are not
sufficient, user can write their own synchronization rule. It must inherit a ICustomSynchronization interface
that enforces priority_value and forbidden_values methods.

In this example we'll write a special synchronization that will ensure that small spheres will be red and a large
ones - blue.

First, let's just create a parameter providers with 2 options (blue-red color and small-big radius).

Here a custom synchronization rule is defined.

And a strategy using this rule for 'base_color' and 'radius'.

To be able to recognize an object by a group_id, we have to put each sphere in a separate randomization group.

Summary

In this section you have learnt:

• SkyRenderer has implemented randomization system relying on Providers and Receivers.
• Properties of objects in the scene can be randomized and synchronized.
• There are some randomization strategies predefined.
• In case provided solution are not enough, a custom one can be created.