Learn OpenGL: Part 2

I recently finished the next section of “Learn OpenGL” on advanced OpenGL topics. This section was all about further exploring topics introduced in the first section. A lot of really interesting features were introduced in this section. Once again, I am going to try and keep my explanations short and to the point. A lot of these topics are really complex, and I could easily have entire blog post devoted to a single concept. However, the point of this post is to document my learning.

Depth Buffer

With depth testing you are able to send Z-depth information to the fragment shader. This is really useful for affect the look of objects at varying distances.

In the gif above, the image on the left shows raw Z-buffer information. Fragments far away from the camera are rendered with a value 1.0 and fragments close to the camera are rendered 0.0. We can affect these values by changing the near and far points. On the right, the fragment color is multiplied by the z-depth so that fragments further away are rendered darker. This demonstrates one of the many uses of the depth buffer. You could also use the depth buffer to render fog or smoke.

Below you can see a sample of a fragment shader using depth testing.

#version 330 core
in vec2 TexCoord;

struct Material{
    sampler2D texture_diffuse1;
    sampler2D texture_specular1; 
};
uniform Material material;

out vec4 FragColor; 

float near = 0.1; 
float far = 100.0;

float LinearizeDepth(float depth)
{
    float z = depth * 2.0 - 1.0; // back to NDC
    return (2.0 * near * far) / (far + near - z * (far- near));
}

void main()
{
    float zDepth = LinearizeDepth(gl_FragCoord.z) / far;  // far for demo
    FragColor = texture(material.texture_diffuse1, TexCoord) * (1.0 - (zDepth * 6.0));
    //FragColor = vec4(zDepth);
}

Stencil Testing

This was a concept that I really struggled to get, and still don’t fully understand. Basically, you can set a buffer that determines which part of the scene are rendered. In the example above, stencil testing is used to render an outline. This is accomplished by rendering the cube twice once with a blue shader and once with a rock shader. Then by using stencil testing anywhere that that the first rock textured cube is render the second blue cube is not.

Blending

Blending is a technique for rendering transparency. Unlike a raytraced render, that can actually simulate light moving through a transparent object, OpenGL uses depth information to determine which object is in front then blends the fragment color of the two objects based on predetermined transparency value. OpenGL also has a built in function that handle transparency, but it is fairly limited in its functionality.

Framebuffer

The frame buffer let you render a scene as a texture that can then be applied to another piece of geometry. They are really useful for rendering reflections in mirrors. One can place a camera pointing in the direction of the mirror and then apply that image to a plane to create the mirror effect. The frame buffer also allow you to apply postprocessing effects to a scene, such as camera effects like lens dirt. In expanding on the idea of postprocessing, this chapter also introduces the concept of kernels, which allow you to affect a pixel value based on surrounding pixel values. Above is an example of a postprocessing effect that uses a kernel to create a blur effect by averaging the surrounding pixel values together.

Environment Maps

Basically, an environment map is an infinitely far away plane with an image applied to it. They are great for making a game world feel bigger than it is. They are also really useful for faking reflections. Since actual reflections are really expensive to compute, one can apply an environment map to an object shader then use it as one use any other type of texture map data. In the image above, you can see how an environment map is used to mimic light refraction through a solid glass object, and reflections in a metallic object.

Geometry Shader

This chapter introduced the geometry shader which is in-between the vertex shader and the fragment shader. It is responsible for processing primitive shapes. Once vertex data is processed in the vertex shader it is passed to the geometry shader that processes the triangular planes formed by the vertices. One common use for it is rendering vertex normals and hair strands. A fun bonus exercise the author has you use the geometry shader to “explode” models by transforming each individual triangle.

Instancing

Finally, this section discusses instancing geometry. Basically, instead of load vertex data every time an object is drawn you load the vertex data once than draw an instances of that single vertex data set. It is a really efficient way to render lots of geometry. In the scene above, I was able to render 150,000 asteroids with instancing were I was only able to render 15,000 without.

Conclusion

This section had a lot of really hard concepts in it that I wasn’t entirely comfortable with, such as the geometry shader. The next section is going to be on advanced lighting concepts, which has been the topic I am most interested in. Honestly though, I am going to put down this book and topic for a while. Its getting into more advanced topics that are pass my ability level. Graphics programming is a really difficult topic, and it would be foolish to think that I could truly understand the entirety of the topic, while I am still learning more fundamental programming concepts. On a positive note, I am really proud of myself for learning the basics of graphics, and my basic C++ skills have definitely improved along the way. I hope to continue exploring the topic as I learn more math and become a stronger programmer.