Procedural texturing: cobblestone texture generation

We write a generator that takes a dozen input parameters and gives the texture of the cobblestone.

Introduction

My hobby is computer graphics and the invention of bicycles. After playing in .kkrieger and reading this and this post, I had a burning desire to write my own texture generator. Choosing as a theme texture - cobblestones, began to google. Honestly, google cobble stone texture generator was difficult, even with the option-minecraft. Spitting on this thing began to think for himself.

Where to begin

The course of my thoughts was approximately as follows:
- i need stones
- you need more stones! For a great texture. And the larger the texture, the longer the generation time. This is bad.
- stones are different (in size and color)
- stones convex (relief)
- rough stones texture
- different types of stones have different types of roughness
- since the texture has color and relief, it would not be bad to separate these components. Let there be a pure color texture and a normal map.
In our generator, the texture will be built in stages: first we create one texture, apply filters to it, mix it with another texture, etc. Now we need to remember or find known algorithms that can help us. I will simply list and briefly describe all the methods that I used in my generator, simultaneously talking about optimizations.
I decided to write the generator in C ++ using the Qt 4.XY library in QtCreator. However, the generator class itself, I tried to write without Qt.
')

Cellular texture

This is the basis of the algorithm. It is she who creates the frame for the stones. Here is described in detail what a mesh texture is and how to create it.
In my code, the generateCelluarTexture function is responsible for this:


The function takes the size of the cell, returns a black and white image of the texture. Now not much about optimization.
First, in order not to go through all the points, I divided the image into rectangular areas of a given size (size). Thus, in order to find the nearest point to the current pixel, you need to view 9 points from the current and neighboring cells. This is written in the link above.
Secondly, we don’t have to look for an “honest” distance. I'm talking about the distance between two points. The square of the distance will completely disappear (we get rid of the extraction of the root) - the picture as a result turns out to be more contrast, but does not have a negative effect on the final texture.

Brightness and Contrast

I think many people used this filter in Photoshop or other graphic editors. Now we will write its implementation.

The function takes as input a pointer to an image and the coefficients of brightness and contrast. Formulas for calculation are described here .

Perlin noise

There are quite a lot of articles written on the noise of the pearl (including on the habr), I will not describe the algorithm, I will tell only about the optimizations and give an example of the code.


First optimization: we get rid of the calculation of the interpolation coefficient (1.0f-cosf (a)) * 0.5f) - for this we simply calculate all the options in advance. And there are not so many options here - the maximum amount is piled up. Therefore, before calculating each octave, we calculate all the coefficients and enter them into the interpolateTable array.
The second optimization is similar to the first - all the places where squares are calculated are replaced by pre-calculated values ​​(powTable).
I also tried to simplify RNG as much as possible and get rid of floating point numbers as much as possible.

Soft jagged effect

I invented this effect myself (and perhaps invented a bicycle - I don’t know). But the name he had better come up with failed - sorry. What is similar to the effect of posterization in Photoshop, only it not only cuts the palette, but also smooths the transitions. I will try to portray its essence in the form of a graph:
It is necessary to convert a straight line linear gradient graph into a kind of ladder with smoothed corners.

To do this, take the intensity value of the color of the current pixel, divide it by the number of iterations (steps). We remember the integer part and the remainder of the division. From the remainder we subtract half of its maximum diazon and multiply by the coefficient of smoothness. The resulting number is added back to the integer part. Oh, easier to show in the code:

 void ProceduralTexture::postEffect(unsigned char *img, int iterations, float smooth){ for (int i=0; i<n; i++){ float s = (float)img[i]/255.0f; float ds = s*(float)iterations-(float)((int)(s*iterations)); ds = smooth*(ds-0.5f)+0.5f; if (ds>1) ds = 1; if (ds<0) ds = 0; s = ((float)((int)(s*(float)iterations))+ds)/(float)iterations; img[i] = s*255; } } 

The function takes as input a pointer to an image that needs to be converted, the number of iterations and the degree of smoothness. To feel exactly how this image filter changes, I will give an example:
the number of iterations is always five. The degree of smoothness from left to right: 1, 1.5, 2.5

By the way, this filter is used in the second picture in the post title.

Mixing

A blend filter is required to combine two images. For example, cellular texture and noise of pearl. Mixing can be implemented in many different ways. I did as follows:
When mixing, the valueTest parameter is indicated - this number characterizes the intensity of the pixel above which it (the pixel) is not processed. The opacity parameter is also indicated - the transparency itself when blending.

Colour

Each pebble has its own unique color. But in general, all these colors are similar to each other. For example, pebbles can be called green or brown, but among them there will be many different shades of green or brown. The RGB palette for such purposes is not very suitable, as it is difficult for her to command “give all shades of a gray-brown-crimson color in the range of, say, 10%”. Therefore, I chose the HSV palette. Through it is convenient to set the color: the brightness of the stones, saturation and hue. You can also specify a hue range. So, for example, if I need shades of yellow, I can set the hue component to 60 plus or minus 10. In the RGB palette, I would have to tinker with all the channels.
However, when using the HSV model, there is a need for color conversion - because in the final image we have an RGB model. Taking the algorithm from the same wiki, we will write the code:


It now remains to write the function of painting the pebbles. I just overloaded the mesh generation function. In fact, the whole filling is reduced to the fact that we, when generating the initial set of random points, assign them a color.

Normal map

To give relief, I wrote a shader, which using a texture and a normal map creates a picture that you saw in the post title. A normal map can be generated from the source image. To do this, I calculate the difference between adjacent pixels - this is the angle of deviation of the normal. After going through all the pixels, finding the minimum and maximum angle I normalize them (angles).


And here is the shader itself. For clarity, I made point lighting in the position of the mouse cursor (in the pictures in the title, the mouse cursor was in the upper left corner

Glue it all together

I applied the above functions in the following order:
- creation of cellular texture
- applying brightness / contrast filter
- creating texture with the noise of the pearl
- application of effect of gradation to perlin noise
- applying a brightness / contrast filter to perlin noise
- mixing of cellular texture and perlin noise
- create normal map
- coloring
Each of the steps described has its own input parameters. By changing them you can get a huge amount of unique textures.

But what about the seamless texture?

Honestly, I wanted to make the ability to create a seamless texture. But for some reason it was lazy. The recipe is simple: when generating a cellular texture, when searching for distances at the borders, you need to use points from the opposite side of the texture. And when generating noise perlin ... if you honestly did not even think. Probably something similar.

Few optimizations. It was worth it?

In fact, the initial implementation of the code worked rather slowly, there were a lot of floating-point numbers, unnecessary iterations and calculations. All I did was, if possible, endure the calculations and translate into numbers with a fixed point. As a result, the performance between the original version and the current version has grown about 10 times. There was an idea to parallelize the algorithm, but because of the suspicion that everything depends on the work with memory, I threw this idea away.

Source

The main class to generate is called ProceduralTexture. I tried to write more or less beautifully, how much a 5th year student can do. All the rest is a body kit, the interface part is needed only for demonstration. Beautifully, I did not really try to write there.
source code