Jump to content
leplubodeslapin
leplubodeslapin

Source Lighting Technical Analysis: Part One

header_biiiig.jpg.abd3ae9ddc94c9668b5bce

 

After the announcement of the Reddit + Mapcore mapping contest, the website has welcomed many newcomers. A proof that, even if it is a twelve year old game engine, Source engine attracts map makers, and there are lots of reasons for that. It is common knowledge that technology has moved forward since 2003, and many new game engines have found various techniques and methods to improve their renderings, making the Source Engine older and older. Nevertheless, it still has its very specific visual aspect that makes it appealing. The lighting system in Source is most definitely one of the key aspects to that, and at the end of this article you will know why.

 

About the reality...

Light in the real world is still a subject with a lot of pending questions, we do not know exactly what it is, but we have a good idea of how it behaves. The most common physic model of light element is the photon, symbolized as a single-point particle moving in space. The more photons there are, the more powerful light is. But light is in the same time a wave, depending on the wavelengths light can have all kind of color properties (monochrome or combined colors). Light travels through space without especially needing matter to travel (the space is the best example; even without matter the sun can still light the earth). And when it encounters matter, different kind of things can happen:

  • Light can bounce and continue its travel to another direction
  • Light can be absorbed by the matter (and the energy can be transformed to heat)
  • Light can go through the matter, for example with air or water, some properties might change but it goes through it

And all these things can be combined or happen individually. If you can see any object outside, it is only because a massive amount of photons traveled into space, through the earth’s atmosphere, bounced on all the surfaces of the object you are looking at, and finally came into your eyes.

How can such a complex physical behavior from nature be simulated and integrated into virtual 3D renderings?

One of the oldest method is still used today because of its accuracy: the ray-tracing method. Just to be clear, it is NOT used in game engines because it is incredibly expensive, but I believe it is important to know how and why it has been made the way it is, since it probably influenced the way lighting is handled in Source and most videogame engines. Instead of simulating enormous amount of photons traveling from the lights to the eye/camera, it does the exact opposite. If you want a picture with a 1000x1000 resolution, you will only need to simulate the travel of 1 000 000 photons (or “rays”), 1 for each pixel. Each ray is calculated individually until it reaches the light origins, and at the end the result is 1 pixel color integrated in the full picture. 

By using the laws of physics we discovered centuries ago, we can obtain a physically-accurate rendering that looks incredibly realistic. This method is used almost everywhere, from architectural renderings to movies. As an example, you can watch The Third & The Seventh by Alex Roman, one of the most famous CGI videos of all time. And because it is an efficient way to render 3D virtual elements with great lighting, it will influence other methods, such as the lightmap baking method.

 

Lightmap baking

OKAY LET’S FINALLY TALK ABOUT THE SOURCE ENGINE, ALRIGHT!

A “lightmap” is a grid that is added on every single brush face you have on your map. The squares defined by the grid are called Luxels (they are kind of “lighting pixels”). Each luxel get its 2 own properties: a color and a brightness. You can see the lightmap grids in hammer by switching your 3D preview to 3D lightmap grid mode.

lightmap_preview_in_hammer.png.655c3bb2e
You can also see them in-game with the console command mat_luxels 1 (without and with).

During the compilation process, a program named VRAD.exe is used. Its role is to find the color and brightness to apply for every single luxel in your map. Light starts from the light entities and from the sky (from the tools/toolsskybox texture actually, using the parameter values that has been filled in the light_environment entity), travels through space and when it meets a brush face:

  • It is partially absorbed in the lightmap grid
  • A less bright ray bounces from the face

Here is an animated picture to show how a lightmap grid can be filled with a single light entity:

lightmap_compute.gif.741ae2a1ac11095b93a

When you compile your map, at first the lightmaps are all full black, but progressively VRAD will compute the lightmaps with all the light entities (one by one) and combine them all at the end. Finally, the lightmaps obtained are applied to the corresponding brush faces, as an additive layer to the texture used on that face. Let us take a look at a wall texture for example.

lightmap_application_example.png.b635371

On the left, you have the texture as you can see it in hammer. When you compile your map, it generates the lightmaps and at the end you obtain the result on the right in-game. Unfortunately, luxels are much rougher, with a lower resolution, more like this.

lightmap_application_realistic_example.p

On the left you have a lightmap grid with the default luxel size of 16 units generated my VRAD, a blur filter is applied and you obtain something close to the result on the right in the game.

In case you did not know, you can change the lightmap grid scale with the “Lightmap Scale” value with the texture tool. It is better to use values that are squares of 2, such as 16, 8, 4 or even 2. Do not go below 2, it might cause issues (with decals for example). Only use lower values than the default 16 if you think it's really useful, because you will drastically increase your map file size and compilation time with precise lightmap grids. Of course, you can also use greater values in order to optimize your map, with values such as 32, 64 or even 128 on very flat areas or surfaces that are far away from the playable areas. You can get more infos about lightmaps on Valve’s Wiki page.

lightmap_scale_option.png.0ac375e75b7d94

But as we said before, light also bounces from the surface until it meets another brush, using radiosity algorithms. Because of that, even if a room does not have any light entity in it, rays can bounce on the floor and light the walls/ceiling, therefore it is not full black. 
Here’s an example:

light_bounce_animation.gif.8664e857c8867

The maximum amount of bounces can be fixed with the VRAD command -bounce X (with X being the maximum amount of bounces allowed). The 100 default value should be more than enough.

Another thing taken into account by VRAD is the normal direction of each luxel: if the light comes directly against the luxel or brushes against it, it will not behave in the same way. This is what we call the angle of incidence of light.

angle_of_incidence.png.0e8adff0277aabf1b

Let us take the example of a light_spot lighting a cylinder, the light will bright gradually the surface - from fully bright at the bottom to slightly visible at the top.

angle_of_incidence_example_hammer_ingame
In-hammer view on the left, in-game view on the right

 

Light Falloff laws

One of the things that made the Source Engine lighting much more realistic than any others in 2004 is the light falloff system. Alright, we saw that light can travel through space until it meets something, but how does it travel through space? At the same brightness, whatever the distance is between the light origin and destination? Maybe sometimes yes… but most of the time no.

3_bulbs.png.be8a5c1b06475dc8dacbb3593796

 

Imagine a simple situation of a room with 1 single point light inside. The light is turned on, it produces photons that are going in all the directions around it. As you might imagine, photons are all going in their own direction and have absolutely no reason to deviate from their trajectory.

 

 

 

At one time, let’s picture billions of photons going in all the directions possible around the light, the moment after, they are all a bit further in their own trajectory, and all the photons are still there, in this “wave”. But, as each photon follows its own trajectory, they will all spread apart, making the photon density lower and lower.

As we said before, the more photons there are, the more powerful light is. And the highest the density, the more intense light is. Intensity of light can be expressed like this:

equation1_intensity.png.3a83819c96791503

 

You have to keep in mind that all of this happens in 3D, therefore the “waves” of photons aren’t circles but spheres. And the area of a sphere is its surface, expressed like this:

equation2_area_fixed.png.b682105df13662d
(R is the radius of the sphere)

 

If we integrate that surface area in the previous equation:

equation3_intensity2_fixed.png.7346b29c3

With ♥ being a constant number. We can see the Intensity is therefore proportional to the reverse of the square of the distance between the photons and their light origin. 

So, the further light travels, the lower is its intensity. And the falloff is proportional to the inverse of the square of the distance.

Consequently, the corners of our room will get darker, because they are farther away from the light (plus they don’t directly face the light, the angle of incidence is lower than the walls/floor/ceiling).

falloff_light_all_directions_result2.png

This is what we call the Inverse-Square law, it’s a very well-known behavior of the light in the field of photography and cinema. People have to deal with it to make sure to get the best exposure they can get.

This law is true when light spreads in all possible directions, but you can also focus light in one direction and reduce the spread, with lenses for example. This is why, when Valve decided to integrate a lighting falloff law in their engine, they decided to use a method not only following the inverse-square law but also giving to mapmakers the opportunity to alter the law for each light entity.

 

Constant, Linear, Quadratic... Wait, what?

In math, there is a very frequent type of functions, named polynomial functions. The concept is simple, it’s a sum of several terms, like this:

equation4_f.png.436b97c4c60318fbe5f7b88b

Every time, there is a constant factor (the “a” thing, a0 being the first one, a1 the second one, a2 the third one...), multiplied with the variable x at a certain degree:

  • x^0 = 1 : degree 0
  • x^1 = x : degree 1
  • x^2 : degree 2
  • x^3 : degree 3
  • ...

And

  • a0 is the constant named “constant coefficient” (associated to degree 0)
  • a1 is the constant named “linear coefficient” (associated to degree 1)
  • a2 is the constant named “quadratic coefficient” (associated to degree 2)

Usually, the function has an end, and we call it by the highest degree of x it uses. For example, a “polynomial of the second degree” is written:

equation5_f2.png.236d6aa2b373f44ce855a68

Then, if we take the expression from the inverse-square law, which was:

equation6_intensity3.png.bdc80a91372c6e0

With a2 = 1 and D being the variable of distance from the light origin.

In Source, the constant ♥ is actually the brightness (the value you configure here).

It is simply an inverse polynomial of the second degree, with a0 and a1 equal to zero. And we could write it like this:

equation7_intensity4.png.260f5c51d5134b6

Or...

equation8_intensity5.png.3205f541452db79

And here you have it! This is approximately the equation used by VRAD to determine the intensity of light for each luxel during the compilation. And you can alter it by changing the values of the 3 variables constant, linear and quadratic, for any of your light / light_spot entity in your level.

Actually you set proportions of each variable against the other two, and only a percentage for each variable is saved. For example:

table1.png.fd580ea156b1484a45382a55b1453

Another example:

table2.png.4402e418d192d6e6de1ff48255ec2

By default, constant and linear are set to 0 and quadratic to 1, which means a 100%quadratic lighting attenuation. Therefore, by default lights in Source Engine follows the classic Inverse-Square law.

If you look at the page dedicated to the constant-linear-quadratic falloff system on Valve’s Wiki, it’s explained that the intensity of light is boosted by 100 for the linear part of equation and 10 000 for the quadratic part of equation. This is due to the fact that inverse formulas in equations always drop drastically at the beginning, and therefore a light with a brightness of 200 would only be efficient in a distance of 5 units and therefore completely pointless.

graph1.png.4cc9ee6c996c891a1aa861ccea004

You would have to boost your brightness a lot in hammer to make the light visible, that's what Valve decided to make automatically.

The following equation is a personal guess of what could be the one used by VRAD:

equation9_intensity6.png.64f085b051bfaa5

With constant, linear and quadratic being percentage values. The blue part is here to determine the brightness to apply, allowing to boost the value set in hammer if it is as least partially using linear or quadratic falloff. The orange part is the falloff part of equation, making the brightness attenuation depending of the distance the point studied is from the light origin. 

The best way to see how this equation works is to visualize it in a 2D graph: 
https://www.desmos.com/calculator/1oboly7cl0

This website provides a great way to see 2D graphics associated to functions. On the left, you can find all the elements needed with at first the inputs (in a folder named “INPUTS”), which are:

  • a0 is the Constant coefficient that you enter in hammer 
  • a1 is the Linear coefficient
  • a2 is the Quadratic coefficient
  • B is the Brightness coefficient

In another folder are the 3 coefficients constant, linear and quadratic, automatically transformed into a percentage form. And finally, the function I(D) is the Intensity function depending on the distance D. The drawing of the function is visible in the rest of the webpage. 

Try to interact with it!

This concludes the first part, the second part will come in about two weeks. We will see some examples of application of this Constant-Linear-Quadratic Falloff system, and a simpler alternative. We will also see how lighting works on models and dynamic lighting systems integrated in source games.Thank you for reading!

 

Part Two : link





User Feedback

Recommended Comments

Sorry if I'm asking a stupid question but isn't the area of a sphere: 4πR^2?

xD ahah you're god damn right i feel really stupid right now. I confused and mixed the volume and area of a sphere (Area = 4πR^2 and Volume = (4/3)πR^3 ). It doesn't really change the logic because it's just a part of the constant but i'm going to fix this right now !! :x

Sry about that and thanks for noticing it doom

 

Edit : ok, should be fixed now. Thanks again for noticing that mistake!

Edited by leplubodeslapin

Share this comment


Link to comment
Share on other sites

I wonder why there are many more articles about light than sound. Sound behaves much like light, it's a wave too.

I guess one of the reason is that on Source engine we don't have any control on sound :x

Oh no sry, we can control the volume ! \o/

Share this comment


Link to comment
Share on other sites


Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now


×