Book Image

OpenGL 4 Shading Language Cookbook - Third Edition

By : David Wolff
Book Image

OpenGL 4 Shading Language Cookbook - Third Edition

By: David Wolff

Overview of this book

OpenGL 4 Shading Language Cookbook, Third Edition provides easy-to-follow recipes that first walk you through the theory and background behind each technique, and then proceed to showcase and explain the GLSL and OpenGL code needed to implement them. The book begins by familiarizing you with beginner-level topics such as compiling and linking shader programs, saving and loading shader binaries (including SPIR-V), and using an OpenGL function loader library. We then proceed to cover basic lighting and shading effects. After that, you'll learn to use textures, produce shadows, and use geometry and tessellation shaders. Topics such as particle systems, screen-space ambient occlusion, deferred rendering, depth-based tessellation, and physically based rendering will help you tackle advanced topics. OpenGL 4 Shading Language Cookbook, Third Edition also covers advanced topics such as shadow techniques (including the two of the most common techniques: shadow maps and shadow volumes). You will learn how to use noise in shaders and how to use compute shaders. The book provides examples of modern shading techniques that can be used as a starting point for programmers to expand upon to produce modern, interactive, 3D computer-graphics applications.
Table of Contents (17 chapters)
Title Page
Packt Upsell


The OpenGL Shading Language (GLSL) is now a fundamental and critical part of programming with OpenGL. It provides us with unprecedented flexibility and power by making the formerly fixed-function graphics pipeline programmable. With GLSL, we can leverage the Graphics Processing Unit (GPU) to implement advanced and sophisticated rendering techniques and even do arbitrary computation. With GLSL 4.x, programmers can do more with the GPU than ever before thanks to shader stages such as tessellation shaders and compute shaders.

In this book, we cover the full spectrum of GLSL programming. Starting with the basics of shading with the vertex and fragment shaders, we take you from simple to advanced techniques. From textures, shadows, and image processing, to noise and particle systems, we cover practical examples to give you the tools you need to leverage GLSL in your projects. We also cover how to use geometry shaders, tessellation shaders, and the recent addition to GLSL: compute shaders. With these, you can make use of the GPU for a variety of tasks that go beyond just shading. With geometry and tessellation shaders, we can create additional geometry or modify geometry, and with compute shaders we can do arbitrary computation on the GPU.

For those new to GLSL, it's best to read this book in order, starting with Chapter 1, Getting Started with GLSL. The recipes will walk you through from basic through to advanced techniques. For someone who is more experienced with GLSL, you might find it better to pick out specific recipes and jump directly there. Most recipes are self-contained, but some may refer to other recipes. The introduction to each chapter provides important general information about the topic, so you might want to read through that as well.

GLSL 4.x makes programming with OpenGL even more rewarding and fun. I sincerely hope that you find this book to be useful and that you use these recipes as a starting point in your own projects. I hope that you find programming in OpenGL and GLSL as enjoyable as I do, and that these techniques inspire you to create beautiful graphics.



Who this book is for

The primary focus of this book is the OpenGL Shading Language (GLSL). Therefore, we don't spend any time discussing the basics of programming with OpenGL. In this book I assume that the reader has some experience with programming in OpenGL, and understands 3D rendering concepts such as model coordinates, view coordinates, clip coordinates, perspective transforms, and the other associated transformations. There's no assumption of any experience with shader programming, however, so if you're new to GLSL, this is a great place to start.

If you're an OpenGL programmer looking to learn about GLSL programming, then this book is for you. Even if you have some shader programming experience, you will very likely find the recipes in this book to be valuable. We cover a range of simple to advanced techniques, using some of the latest features of OpenGL (such as compute shaders and tessellation shaders). So experienced GLSL programmers, who are looking to learn how to use these new features, may also find this book to be useful.

In short, this book is for programmers who understand the basics of 3D graphics in OpenGL, and are interested in either learning GLSL, or taking advantage of some of the newest features in modern GLSL 4.x.

What this book covers

Chapter 1, Getting Started with GLSL, explains the steps needed to compile, link, and use GLSL shaders within an OpenGL program. It also covers how to save and load shader binaries, and how to use SPIR-V with OpenGL. It covers the use of the GLM library for mathematics support.

Chapter 2Working with GLSL Programs, introduces the basic of communication between the shader programs and the OpenGL program. It covers how to send data to shaders using attributes and uniform variables, how to enumerate variables, how to work with shader pipelines, and offers an example of a shader program class.

Chapter 3, The Basics of GLSL Shaders, introduces you to the basics of GLSL programming with per-vertex shading. In this chapter, you see examples of basic shading techniques such as the Phong model, two-sided shading, and flat shading. It also covers examples of basic GLSL concepts such as functions and subroutines.

Chapter 4, Lighting and Shading, continues with basic shading techniques, with a focus on the fragment shader. It introduces you to techniques such as the Blinn-Phong model, spotlights, per-fragment shading, toon shading, fog, and a physically based reflection model. 

Chapter 5, Using Textures, provides a variety recipes involving the use of textures in GLSL shaders. Textures can be used for a variety of purposes besides simply "pasting" an image onto a surface. In this chapter, we cover the basic application of one or more 2D textures, as well as a variety of other techniques including alpha maps, normal maps, parallax mapping, cube maps, projected textures, rendering to a texture, and diffuse image based lighting. We also cover sampler objects, a relatively new feature that decouples sampling parameters from the texture object itself.

Chapter 6, Image Processing and Screen Space Techniques, explains common techniques for the post-processing of rendered images and some other screen-space techniques. Image post-processing is becoming a crucially important part of modern game engines and other rendering pipelines. This chapter discusses how to implement some of the more common post-processing techniques such as tone mapping, bloom, blur, gamma correction, and edge detection. We also cover some screen-space rendering techniques such as deferred shading, multisample anti-aliasing, screen-space ambient occlusion, and order-independent transparency.

Chapter 7, Using Geometry and Tessellation Shaders, covers techniques that demonstrate how to use these powerful shader stages. After reading this chapter, you should be comfortable with their basic functionality and understand how to use them. We cover techniques such as geometry-shader-generated point sprites, silhouette lines, depth-based tessellation, Bezier surfaces, and more.

Chapter 8, Shadows, introduces basic techniques for producing real-time shadows. This chapter includes recipes for the two most common shadow techniques: shadow maps and shadow volumes. We cover common techniques for anti-aliasing shadow maps, as well as how to use the geometry shader to help produce shadow volumes. 

Chapter 9, Using Noise in Shaders, covers the use of Perlin noise for creating various effects. The first recipe shows you how to create a wide variety of textures containing noise data using GLM (a powerful mathematics library). Then we move on to recipes that use noise textures for creating a number of effects such as wood grain, clouds, disintegration, paint, and static.

Chapter 10, Particle Systems and Animation, focuses on techniques for creating particle systems. We see how to create a particle system to simulate fire, smoke, and water. We also make use of the OpenGL feature called transform feedback, in order to gain additional efficiency by moving the particle updates onto the GPU.



Chapter 11, Using Compute Shaders, introduces you to several techniques that make use of one of the newest features in OpenGL, the compute shader. The compute shader provides us with the ability to do general computation on the GPU within OpenGL. In this chapter, we discuss how to use the compute shader for particle simulations, cloth simulation, edge detection, and the generation of a procedural fractal texture. After reading this chapter, the reader should have a good feel for how to use the compute shader for arbitrary computational tasks.

To get the most out of this book

The recipes in this book use some of the latest and greatest features in OpenGL 4.x. Therefore, in order to implement them, you'll need graphics hardware (graphics card or onboard GPU) and drivers that support at least OpenGL 4.6. However, many of the recipes will work with earlier versions. If you're unsure about what version of OpenGL your setup can support, there are a number of utilities available for determining this information. One option is GLview from Realtech VR, available at:

If you're running Windows or Linux, drivers are readily available for most modern hardware. However, if you're using macOS, unfortunately, you're stuck with OpenGL 4.1. Apple has officially deprecated OpenGL, so there won't be any official updates coming. However, a large number of these recipes will function under OpenGL 4.1 (sometimes with minor tweaks).

Once you've verified that you have the required OpenGL drivers, you'll also need the following: 

  • A C++ compiler. On Linux, the GNU Compiler Collection (gcc, g++, and so on) may already be available, and if not, it should be available through your distribution's package manager. On Windows, Microsoft Visual Studio will work fine, but if you don't have a copy, then the MinGW compiler (available from is a good option.
  • The GLFW library Version 3.0 or later, available from  This library provides OpenGL context creation, window support, and support for user input events.
  • The GLM library Version 0.9.6 or later, available from  This provides mathematics support with classes for matrices, vectors, common transformations, noise functions, and much more

Download the example code files

You can download the example code files for this book from your account at If you purchased this book elsewhere, you can visit and register to have the files emailed directly to you.

You can download the code files by following these steps:

  1. Log in or register at
  2. Select the SUPPORT tab.
  3. Click on Code Downloads & Errata.
  4. Enter the name of the book in the Search box and follow the onscreen instructions.

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

  • WinRAR/7-Zip for Windows
  • Zipeg/iZip/UnRarX for Mac
  • 7-Zip/PeaZip for Linux

The code bundle for the book is also hosted on GitHub at In case there's an update to the code, it will be updated on the existing GitHub repository.

We also have other code bundles from our rich catalog of books and videos available at Check them out!

Download the color images

We also provide a PDF file that has color images of the screenshots/diagrams used in this book. You can download it here:

Conventions used

There are a number of text conventions used throughout this book.

CodeInText: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. Here is an example: "The shader would then access these values via built-in variables such as gl_Vertex and gl_Normal."

A block of code is set as follows:

void main() 
  Color = VertexColor; 
  gl_Position = vec4(VertexPosition,1.0); 

Any command-line input or output is written as follows:

Active attributes:1    VertexColor (vec3)0    VertexPosition (vec3)

Bold: Indicates a new term, an important word, or words that you see onscreen. For example, words in menus or dialog boxes appear in the text like this. Here is an example: "Now that we have set up our buffer objects, we tie them together into a Vertex Array Object (VAO)."


Warnings or important notes appear like this.


Tips and tricks appear like this.

Get in touch

Feedback from our readers is always welcome.

General feedback: If you have questions about any aspect of this book, mention the book title in the subject of your message and email us at [email protected].

Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you would report this to us. Please visit, selecting your book, clicking on the Errata Submission Form link, and entering the details.

Piracy: If you come across any illegal copies of our works in any form on the Internet, we would be grateful if you would provide us with the location address or website name. Please contact us at [email protected] with a link to the material.

If you are interested in becoming an author: If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, please visit


Please leave a review. Once you have read and used this book, why not leave a review on the site that you purchased it from? Potential readers can then see and use your unbiased opinion to make purchase decisions, we at Packt can understand what you think about our products, and our authors can see your feedback on their book. Thank you!

For more information about Packt, please visit