Henerial: переводы

→All OpenGL functions start with gl and follow a number of naming conventions such as encoding some of their parameter types as suffixes on the end of the function names. This allows a limited form of overloading even in languages that don’t directly support this. In this case, the suffix fv means that the function consumes a vector (v) of floating-point (f) values, where arrays (generally referenced by pointers in languages like C) and vectors are used interchangeably by OpenGL.

The glClearBufferfv() function tells OpenGL to clear the buffer specified by the first parameter (in this case GL_COLOR) to the value specified in its third parameter. The second parameter, drawBuffer, is used when there are multiple output buffers that could be cleared. Because we’re only using one here and drawBuffer is a zero-based index, we’ll just set it to zero in this example. Here, that color is stored in the array red, which contains four floating-point values — one each for red, green, blue, and alpha, in that order. The red, green, and blue terms should be self-explanatory. Alpha is a fourth component that is associated with a color and is often used to encode the opacity of a fragment. When used this way, setting alpha to zero will make the fragment completely transparent, and setting it to one will make it completely opaque. The alpha value can also be stored in the output image and used in some parts of OpenGL’s calculations, even though you can’t see it. You can see that we set both the red and alpha values to one and the others to zero. This specifies an opaque red color. The result of running this application is shown in Figure 2.1.

This initial application isn’t particularly interesting1 as all it does is fill the window with a solid red color. You will notice that our render() function takes a single parameter — currentTime. This contains the number of seconds since the application was started, and we can use it to create a simple animation. In this case, we can use it to change the color that we use to clear the window. Our modified render() function2 is shown in Listing 2.2.

1. This sample is especially uninteresting if you are reading this book in black and white!
2. If you’re copying this code into your own example, you’ll need to include <math.h> in order to get the declarations of sin() and cos().

→Click here to view code image
void glClearBufferfv(GLenum buffer,
GLint drawBuffer,
const GLfloat * value);

→The example shown in Listing 2.1 simply clears the whole screen to red. This introduces our first OpenGL function, glClearBufferfv(). The prototype of glClearBufferfv() is

→Figure 2.1: The output of our first OpenGL application

→Creating a Simple Application
To introduce the application framework that’ll be used in the remainder of this book, we’ll start with an extremely simple example application. The application framework is brought into your
application by including sb6.h in your source code. This is a C++ header file that defines a namespace called sb6 that includes the declaration of an application class, sb6::application, from which we can derive our examples. The framework also includes a number of utility functions and a simple math library called vmath to help you with some of the number crunching involved in OpenGL.

To create an application, we simply include sb6.h, derive a class v sb6::application, and (in exactly one of our source files) include an instance of the DECLARE_MAIN macro. This defines the main entry point of our application, which creates an instance of our class (the type of which is passed as a parameter to the macro) and calls its run() method, which implements the application’s main loop.

In turn, this performs some initialization by calling the startup() method and then calls the render() method in a loop. In the default implementation, both methods are virtual functions with empty bodies. We override the render() method in our derived class and write our drawing code inside it. The application framework takes care of creating a window, handling input, and displaying the rendered results to the user. The complete source code for our first example is given in Listing 2.1, and its output is shown in Figure 2.1.

→Chapter 2. Our First OpenGL Program
What You’ll Learn in This Chapter
• How to create and compile shader code
• How to draw with OpenGL
• How to use the book’s application framework to initialize your programs and clean up afteryourself

In this chapter, we introduce the simple application framework that is used for almost all of the samples in this book. This shows you how to create the main window with the book’s application framework and how to render simple graphics into it. You’ll also see what a very simple GLSL shader looks like, how to compile it, and how to use it to render simple points. The chapter concludes with your very first OpenGL triangle.