**Contents**

**News (August, 31)**: We are working on Scratchapixel 3.0 at the moment (current version of 2). The idea is to make the project open source by storing the content of the website on GitHub as Markdown files. In practice, that means you and the rest of the community will be able to edit the content of the pages if you want to contribute (typos and bug fixes, rewording sentences). You will also be able to contribute by translating pages to different languages if you want to. Then when we publish the site we will translate the Markdown files to HTML. That means new design as well.

That's what we are busy with right now and why there won't be a lot of updates in the weeks to come. More news about SaP 3.0 soon.

We are looking for native Engxish (yes we know there's a typo here) speakers that will be willing to readproof a few lessons. If you are interested please get in touch on Discord, in the #scratchapixel3-0 channel. Also looking for at least one experienced full dev stack dev that would be willing to give us a hand with the next design.

Feel free to send us your requests, suggestions, etc. (on Discord) to help us improve the website.

And you can also donate). Donations go directly back into the development of the project. The more donation we get the more content you will get and the quicker we will be able to deliver it to you.

Now that we reviewed the parameters that influence the appearance of objects (how bright they are, their color, etc.) we are ready to start studying some simple shading techniques.

## Normals

Normals play a central role in shading. Everybody knows that an object becomes brighter if we orient it towards a light source. The orientation of an object surface plays an important role in the amount of light it reflects (and thus how bright it looks like). This orientation can be represented at any point \(P\) on the surface of an object, by a normal \(N\) which is perpendicular to the surface at \(P\) as shown in figure 1. Note in figure 1, how the brightness of the sphere decreases as the angle between the light direction and the normal increases. This decrease in brightness is something we can see everyday and yet probably few people know why it happens. We will explain the cause of this phenomenon in a short while. For now, you should only remember that:

- What we call normal (which we denote with the capital letter \(N\)) is the vector perpendicular to the surface tangent at \(P\) a point on the surface of the object. In other words, to find the normal at \(P\) we need to trace a line tangent to the surface at \(P\) and then take the vector perpendicular to that tangent line (note that in 3D, this would be tangent plane).
- That the brightness of a point on the surface of an object depends on the normal direction which defines the orientation of the object surface at that point with respect to the light. Another way of saying this, is that the brightness of the object at any given point of its surface depends on the angle between the normal at that point and the light direction.

The question now is how do we compute this normal? The complexity of the solution to this problem can be vary greatly depending on the type of geometry being rendered. The normal of sphere can generally be easily found. If we know the position of the point on the surface of a sphere and the center of the sphere, the normal at this point can be computed by subtracting the point position to the sphere center:

If the object is a triangle mesh, then each triangle defines a plane and the vector perpendicular to the plane is the normal of any point lying on the surface of that triangle. The vector perpendicular to the triangle plane can easily be obtained with the cross product of two edges of that triangle. Keep in mind that v1xv2 = -v2xv1. So the choice of edges will influence the direction of the normal. If you declare the triangle vertices in counter clockwise order, then you can use the following code:

If the triangle lies in the xz plane, then the resulting normal should be (0,1,0) and not (0,-1,0) as shown in figure 2

Computing the normal that way gives what we call a **face normal** (because the normal is the same for the entire face, regardless of the point you pick on that face or triangle). Normals of triangle meshes can also be defined at the triangles vertices, in which case we call these normals **vertex normals**. Vertex normals are used in a technique called **smooth shading** that you will find described at the end of this chapter. For now, we will only deal with face normals.

How and when in the program you compute the surface normal at the point you are about to shade doesn't really matter. What matters and what is essential is that you have this information at hand when you are about to shade the point. In the few programs for this section in which we did some basic shading, we implemented a special method in every geometry class called getSurfaceProperties() in which we computed the normal at the intersection point (in case ray-tracing is used) and other variables such as the texture coordinates which we will talk about later in this lesson. Here is what the implementation of these methods could look like for the sphere and the triangle-mesh geometry type:

## A Simple Shading Effect: Facing Ratio

Now that we know how to compute the normal of a point on the surface of an object, we have enough information already to create a simple shading effect called **facing ratio**. This technique consists of computing the dot product of the normal of the point that we want to shade and the viewing direction. Computing the viewing direction is also very simple. When ray-tracing is used, it is simply the opposite direction of the ray that intersected the surface at \(P\). In you don't use ray-tracing, the viewing direction can also simply be found by tracing a line from the point on the surface \(P\) to the eye \(E\):

Keep in mind that the dot product of two vectors returns 1 if the vectors are parallel and pointing in the same direction and 0 when the two vectors are perpendicular to each other. If the vectors point in opposite directions the dot product is negative, but if we use the result of this dot product as a color, then we are not interested in negative values anyway. If you need a reminder on the dot product, check the lesson on Geometry. To avoid negative results, we will need to clamp the result to 0:

When the normal and the vector V point in the same direction then we the dot product returns 1. If the two vectors are perpendicular the result is 0. If we use this simple technique to shade a sphere centred in the middle of the frame, then the center of the sphere will be white and the sphere will get darker as we move away from its center, towards the edge (as shown in following figure).

Congratulation! You have just learned about your first shading technique. Let's now learn about a more realistic shading method that will simulate the effect of a light on a diffuse object. But before we learn about this method, we first need to introduce and learn about the concept of light.

## Flat Shading vs. Smooth Shading and Vertex Normals

The problem with triangle meshes is that they can't represent perfectly smooth surfaces (unless the triangles are very small). If we wish to apply the facing-ratio technique we just described to a polygon mesh, we would need to compute the normal of the triangle intersected by the ray and compute the facing-ratio as the dot product between this face normal and the view direction. The problem with this approach is that it gives the object a faceted look as shown in the images below. This shading method is actually called for this reason **flat shading**

As mentioned a few times in the previous lessons, the normal of a triangle can simply be found, by computing the cross product of let's say the vector v0v1 and the vector v0v2, where v0, v1 and v2 represent the vertices of the triangle. To address this problem, **Henri Gouraud** introduced a method in 1971 which is now known as **smooth shading**, or **Gouraud shading**. The idea behind this technique is to produce continuous shading across the surface of a polygon mesh, despite the fact that precisely the object that the mesh represents is not continuous as it is built from a collection of flat surfaces (the polygons or the triangles). In order to do so, Gouraud introduced the concept of **vertex normal**. The idea is simple. Rather than computing or storing the normal for the face, we store a normal at each vertex of the mesh, where the orientation of the normal is determined by the underlying smooth surface that the triangle mesh was converted from. When we want to compute the color of a point on the surface a triangle, rather than using the face normal, we can compute a "fake smooth" normal by **linearly interpolating** the vertex normals defined at the triangle's vertices using the hit point barycentric coordinates.

The technique is illustrated in the image above. Vertex normals are defined at the triangles vertices. You can see that they are oriented perpendicular to the smooth underlying surface that the triangle mesh was built from. Sometimes triangles mesh are not directly converted from a smooth surface, and vertex normals have to be computed on the fly. Different techniques for computing vertex normals when there is not smooth surface to compute them from exist, but we won't study them in this lesson. For now, use a software such as Maya or Blender to do this job for you (in Maya you can select your polygon mesh and select the option Soften Edge in the Normals menu).

In fact, from a practical and technical point of view, each triangle has its own set of 3 vertex normals. Which means that the total of vertex normals for triangle mesh is actually equal to the number of triangles multiplied by 3. In some cases, the vertex normals defined on a vertex shared by 2, 3 or more triangles are the same (they point in the same direction) but you can achieve different effects by providing them different directions (you can for example fake some hard edges in the surface).

The source code for computing the interpolated normal on any point on the surface of a triangle is simple as long as we know the vertex normal for the triangle, the barycentric coordinates of this point on the triangle as well as the triangle index. Both the rasterization or the ray-tracing provide you with this information. Vertex normals are generated on the model by the 3D program that you have been using to create the model. They are then exported to the geometry file, with the triangles connectivity information, the vertex positions, and the triangles's texture coordinates. All you need to do then, is to combine the point barycentric coordinate and the triangle vertex normals to compute the point interpolated smooth normal (lines 17-20 below):

Note that this only produces the impression that the surface is smooth. If you look at the polygon sphere in the image below, you can still see that the silhouette is facetted, even though the surface appears smooth inside. The technique definitely improves the look of triangle meshes but doesn't of course solve the problem of their faceted look completely. The only solution to this problem is to use subdivision surface which we will talk about in a different section, or of course increase the number of triangle used when smooth surfaces are converted to triangle meshes.

We are not ready to learn how to reproduce the appearance of diffuse surfaces. Though diffuse surfaces need a light to be visible. Thus, before we can study this technique, we will first need to learn how we handle the concept of light sources in a 3D engine.