Book Image

OpenGL 4 Shading Language Cookbook - Second Edition

By : David Wolff
Book Image

OpenGL 4 Shading Language Cookbook - Second Edition

By: David Wolff

Overview of this book

OpenGL Shading Language (GLSL) is a programming language used for customizing parts of the OpenGL graphics pipeline that were formerly fixed-function, and are executed directly on the GPU. It provides programmers with unprecedented flexibility for implementing effects and optimizations utilizing the power of modern GPUs. With Version 4, the language has been further refined to provide programmers with greater power and flexibility, with new stages such as tessellation and compute. OpenGL 4 Shading Language Cookbook provides easy-to-follow examples that first walk you through the theory and background behind each technique, and then go on to provide and explain the GLSL and OpenGL code needed to implement it. Beginner level through to advanced techniques are presented including topics such as texturing, screen-space techniques, lighting, shading, tessellation shaders, geometry shaders, compute shaders, and shadows. OpenGL Shading Language 4 Cookbook is a practical guide that takes you from the fundamentals of programming with modern GLSL and OpenGL, through to advanced techniques. The recipes build upon each other and take you quickly from novice to advanced level code. You'll see essential lighting and shading techniques; examples that demonstrate how to make use of textures for a wide variety of effects and as part of other techniques; examples of screen-space techniques including HDR rendering, bloom, and blur; shadowing techniques; tessellation, geometry, and compute shaders; how to use noise effectively; and animation with particle systems. OpenGL Shading Language 4 Cookbook 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)
OpenGL 4 Shading Language Cookbook Second Edition
Credits
About the Author
About the Reviewers
www.PacktPub.com
Preface
Index

Preface

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 new 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 very 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. 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.

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 send data to shaders using attributes and uniform variables, and the use of the GLM library for mathematics support. Every modern OpenGL program today requires a function loader. In this chapter, we also cover the use of GLLoadGen, a relatively new and easy-to-use OpenGL loader generator.

Chapter 2, 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 ADS (ambient, diffuse, and specular) shading algorithm, two-sided shading, and flat shading. It also covers examples of basic GLSL concepts such as functions and subroutines.

Chapter 3, Lighting, Shading, and Optimization, presents more advanced shading techniques, with a focus on the fragment shader. It introduces you to techniques such as spotlights, per-fragment shading, toon shading, fog, and others. We also discuss several simple optimizations to make your shaders run faster.

Chapter 4, Using Textures, provides a general introduction to using 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, cube maps, projected textures, and rendering to a texture. We also cover sampler objects, a relatively new feature that decouples sampling parameters from the texture object itself.

Chapter 5, 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 antialiasing, and order-independent transparency.

Chapter 6, Using Geometry and Tessellation Shaders, covers techniques that demonstrate how to use these new and 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 7, 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 antialiasing shadow maps, as well as how to use the geometry shader to help produce shadow volumes.

Chapter 8, 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 9, 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 10, 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.

What you need for 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.3. 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: http://www.realtech-vr.com/glview/. If you're running Windows or Linux, drivers are readily available for most modern hardware. However, if you're using MacOS X, unfortunately, you may need to wait. As of this writing, the latest version of MacOS X (10.9 Mavericks) only supports OpenGL 4.1.

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 http://mingw.org/) is a good option.

  • The GLFW library Version 3.0 or later, available from http://www.glfw.org/. This library provides OpenGL context creation, window support, and support for user input events.

  • The GLM library Version 0.9.4 or later, available from http://glm.g-truc.net/. This provides mathematics support with classes for matrices, vectors, common transformations, noise functions, and much more.

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 basic 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 newest features of OpenGL (such as compute shaders and tessellation shaders). So even 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.

Conventions

In this book, you will find a number of styles of text that distinguish between different kinds of information. Here are some examples of these styles, and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: "The number of work groups are determined by the parameters to glDispatchCompute."

A block of code is set as follows:

void main()
{
    Color = VertexColor;
    gl_Position = RotationMatrix * vec4(VertexPosition,1.0);
}

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

void main()
{
    Color = VertexColor;
    gl_Position = RotationMatrix * vec4(VertexPosition,1.0);
}

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

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

New terms and important words are shown in bold.

Note

Warnings or important notes appear in a box like this.

Tip

Tips and tricks appear like this.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or may have disliked. Reader feedback is important for us to develop titles that you really get the most out of.

To send us general feedback, simply send an e-mail to , and mention the book title via the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide on www.packtpub.com/authors.

Customer support

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.

Downloading the example code

You can download the example code files for all Packt books you have purchased from your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

Full source code for all of the recipes in this text is available on GitHub at: https://github.com/daw42/glslcookbook.

Downloading the color images of this book

We also provide you a PDF file that has color images of the screenshots/diagrams used in this book. The color images will help you better understand the changes in the output. You can download this file from: http://www.packtpub.com/sites/default/files/downloads/7020OS_Colorimages.pdf

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books—maybe a mistake in the text or the code—we would be grateful if you would report this to us. By doing so, you can save other readers from frustration and help us improve subsequent versions of this book. If you find any errata, please report them by visiting http://www.packtpub.com/submit-errata, selecting your book, clicking on the errata submission form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded on our website, or added to any list of existing errata, under the Errata section of that title. Any existing errata can be viewed by selecting your title from http://www.packtpub.com/support.

Piracy

Piracy of copyright material on the Internet is an ongoing problem across all media. At Packt, we take the protection of our copyright and licenses very seriously. If you come across any illegal copies of our works, in any form, on the Internet, please provide us with the location address or website name immediately so that we can pursue a remedy.

Please contact us at with a link to the suspected pirated material.

We appreciate your help in protecting our authors, and our ability to bring you valuable content.

Questions

You can contact us at if you are having a problem with any aspect of the book, and we will do our best to address it.