Fog

Basic Fog

To turn on fog, create an object of class Fog, and then apply it using the NodePath.set_fog() method:

myFog = Fog("Fog Name")
myFog.setColor(R, G, B)
myFog.setExpDensity(Float 0 to 1)
render.setFog(myFog)

However, there is more here than meets the eye. We have created a fog node, which goes into the scene graph. Therefore, the fog has a position, a place where the fog is (conceptually) thickest.

If the fog object is not parented into the scene graph (in the example above, for instance), then the fog’s position is ignored, and the fog is camera-relative. Likewise, if the fog is exponential, the fog’s position is ignored, and the fog is camera-relative.

The set_fog() method creates a fog attribute object. Like any Render Attribute, the fog attribute affects the node that it is attached to, and any nodes below it in the scene graph. So you can easily cause only a subset of the objects (or just a single model) to be affected by the fog, by calling set_fog() on the root of the subgraph you want to be affected. To remove the fog attribute later, use the clear_fog() method:

render.clearFog()

While you have fog in effect, it is often desirable to set the background color to match the fog:

base.setBackgroundColor(myFogColor)

Fog Modes

There are three fog modes in Panda: Fog.MExponential, Fog.MExponentialSquared and Fog.MLinear. You can switch the mode of a Fog object using fog.get_mode() and fog.set_mode(Fog.Mode). This explicit mode switching isn’t normally necessary, as Fog methods implicitly switch the mode for you.

A Fog object in Panda3D is a node that can be parented into the scene graph with a position, colour and orientation like any other node (importantly, Fog is a subclass of PandaNode, not of NodePath) (do Fog nodes have a scale?).

The position of a Fog node in the scene graph does not determine which objects the fog affects, it determines the origin and direction of the fog when it is in linear mode. When a fog node is in exponential mode its position and orientation in the scene graph are irrelevant. Either way, a Fog node must be activated by calling nodePath.set_fog(fogNode) on some NodePath in the scene graph. Which NodePath you call the set_fog() method on determines which parts of the scene will be fogged: that NodePath and all its children.

Linear Fog

This is the default mode. In this mode the position and orientation of a Fog node are important. A linear-mode Fog node must first be parented into the scene graph, then activated by calling set_fog(fogNode) on some NodePath in the scene graph.

Setup a linear fog node at the origin:

color = (0.5, 0.8, 0.8)
linfog = Fog("A linear-mode Fog node")
linfog.setColor(*color)
linfog.setLinearRange(0, 320)
linfog.setLinearFallback(45, 160, 320)
render.attachNewNode(linfog)
render.setFog(linfog)

In linear mode, the onset and opaque distances of the fog are defined as offsets along the local forward (+Y) axis of the fog node. The onset distance is the distance from the fog node at which the fog will begin to have effect, and the opaque distance is the distance from the fog node at which the fog will be completely opaque. From reading the API page for the Fog class, it sounds as if beyond this opaque point there is no fog (rather than continuing opaque fog up to the location of the fog node as you might expect): “the fog will be rendered as if it extended along the vector from the onset point to the opaque point.”

These settings can be modified using the methods get_linear_onset_point(), get_linear_opaque_point(), set_linear_onset_point(), set_linear_opaque_point() and set_linear_range() of Fog.

There is a hardware issue with rendering fog which means that linear fog can break down and vanish depending on the angle from which it is viewed:

“the underlying fog effect supported by hardware is generally only one-dimensional, and must be rendered based on linear distance from the camera plane. Thus, this in-the-world effect is most effective when the fog vector from onset point to opaque point is most nearly parallel to the camera’s eye vector. As the angle between the fog vector and the eye vector increases, the accuracy of the effect diminishes, up to a complete breakdown of the effect at a 90 degree angle.”

The Fog method set_linear_fallback(float angle, float onset, float opaque) defines how the fog should be rendered when the fog effect is diminished in this way. angle is the minimum viewing angle (angle between the camera direction and fog direction) at which the fallback effect will be employed. onset and opaque specify camera-relative onset and opaque distances that will be fallen back on, overriding the Fog node’s own onset and opaque distances.

The linear fallback workaround will only look good in certain situations, for example when the fog is deep inside a dark cave. So in general, exponential mode fog is more useful than the default linear mode fog.

Exponential Fog

In exponential fog mode the position and orientation of your fog node in the scene graph and the onset and opaque points are ignored (in fact you don’t even have to put your fog node in the scene graph). Instead, fog is rendered camera relative according to a density factor: the fog begins at the camera and continues to infinity, with an exponentially increasing density determined by the density factor. The fog moves with the camera as the camera’s position and orientation changes:

“the onset point and opaque point are not used, and the fog effect is based on the value specified to set_exp_density(), and it doesn’t matter to which node the fog object is parented, or if it is parented anywhere at all.”

The Fog.set_exp_density() method determines the density value used for exponential fog calculations. The below example uses it to set up some scene- wide exponential fog:

color = (0.5, 0.8, 0.8)
expfog = Fog("Scene-wide exponential Fog object")
expfog.setColor(*color)
expfog.setExpDensity(0.005)
render.setFog(expfog)
base.setBackgroundColor(*color)

The last line in the sample above doesn’t actually affect the fog, however, it generally looks better if the scene background color matches the color of the fog.

Since set_fog() is called on render it affects the entire scene. set_fog() can just as easily be called on some other NodePath and will affect only that NodePath and its children.

The exponential fog effect can be turned off again using clear_fog():

render.clearFog()