Making for with turbidity

Using Turbidity is a great way of making fog simulations with Real 3D. What many probably have a problem with, is the fact that the effect of turbidity depends on the size of the scene using the fog. The same amount of turbidity will produce different results depending on the size of the scene. Because of this you would often set the turbidity slider to 1 (to minimize the effect) and turbid saturation to 100 (to make it very depth sensitive), but the results would still not look good because the turbid level is way to high, even when set to 1. But since the turbidity is a floating point value it is possible to get even smaller values by setting the scope handler to formula and write tu=0.15 in the expression field.

Do you start to see the possibilities here? By using this technique you can set the turbidity level by various means. To simulate a foggy room, this would be the way to do it. However, fog is a lot more than this. Consider haze instead; it is a foggy kind of behaviour that increases greatly with distance. Close to the camera there would be no haze at all, but far away it would get very foggy. Also consider that fog is often gasious 'phenomena' that is heavier than air (as it is made of waterdrops) and thus the fog will be denser close to the ground.

Here is a method of how to make 'normal', even distributed fog:

• Create the scene (a room or whatever), set up the lights and a camera.
• Create a sphere (a 3D object) around the whole scene in a level below everything else in the hierarchy. This is important, because the way Real 3D uses the hierarchy to determine what should be rendered.
• Create a material with brilliancy, transparency, refraction, and turbid saturation set to maximum 100%. Set the smooth toggle on. Set the scope handler to formula and write tu=0.25 in the expression field.
• Assign the material to the object and render the scene in an appropriate mode. Remember to set the recursion level high enough, and it may be wise to set the material sampling to at least one. This is not critical as long as the 'foggyness' is fairly constant, but it gives a more pleasing result.
• Render the scene, but remember that if you increase the material sampling value the rendertime will increase a lot.

Here is a way of how to make 'haze', distance distributed fog:

Change the scope handler formula of the above example to tu=relx. Remember that relx of a parallell map is the same as a normalized lenght of the x axis of the map, meaning that the first point is zero, and the second point is one. Assign this material from a top view, click the first point close to the camera (zero meaning there will be no fog at all), and the second point where you want the fog to reach its maximum value.

Here is a way of how to make 'gasious fog', distributed with height:

Well, this one should be pretty obvious if you got the right results with the above method. Just rotate the mapping primitive in such a way that the first point (relx=zero) is located at the top of the room, and the second point (relz=one) on the bottom. You have now made a simulation of a foggy gas that is heavier than air. To make it like smoke (lighter than air), just mirror the mapping primitive to switch the points.

Some points about the above methods

• If relx doesn't set the value high enough by itself, you can always modify the result by some simple mathematical ways. tu=relx*20 will produce a value between 0 and 20. tu=relx*15+5 will produce a value between 5 and 20, and so forth.
• Using relx will offcourse produce a linear increase of foggyness. To make it increase potensially (?!?) just change it to tu=relx*relx.
• Set the scope formula to tu=relx*rely*relz to get a spherical increase of fog. Setting it to tu=10*sin(2*PI*relx*3)+5 will make 3 layers of fog with values ranging from 5 to 15... lookes very weird :-)
• Off course it is also possible to add noise to these kinds of functions, but then we will have to use RPL instead of a mathematical function. The last picture in the table below, I use the following RPL procedure: relx FFETCH rely FFETCH 0.01 F* relz FFETCH 0.1 0.9 1.3 5 NOISE rely FFETCH DUP F* F* tu FSTORE DROP DROP. It uses standard noise (with small variations in the y axis to give the impression of foggy streaks) resulting in a value 0-1), multiplies the first vector result with rely squared to get a nice nonlinear falloff, and stores the result (still between 0 and 1) in tu. I then just get rid of the remaining two vector left on the stack. I know this is pretty advanced stuff, but I'll explain it more later.

Below are some examples of different kind of fogs. It is an old 'barscene' of mine but it was never quite finished, so there are a lot of stuff missing.

Examples of fogmaterials with different scope
Fig. 1. No fog, just the basic scene	Fig. 2. tu=1, this produces way to much fog	Fig. 3. tu=0.15, so this is starting to look better
Fig. 4. Fog with falloff, denser fog at bottom	Fig. 5. Squared falloff, more rapidly denser	Fig. 6. Here noise have been added. See note above

As you can see from these pictures this method of making an object shine is quite useful and powerful. I will recommend to make separate textures which is going to be used as specularity maps because you can add inn some noise (speckle) to give he impression of a wethered material. Also the rendering will be faster if the map doesn't need any additional scaling with the formulae. Remember that if you have additional materials (color, bump etc.) assigned to the object, you will need to change the 'redefine reflected' setting in the extras part of the material for each material to the same. The reason is that this information is always mixed. So setting white in one and nothing in the other (if using two materials) would result in a 'redefine reflected' which is grey.