{"id":255,"date":"2023-07-18T13:19:33","date_gmt":"2023-07-18T13:19:33","guid":{"rendered":"https:\/\/www.infodreams.it\/main\/?page_id=255"},"modified":"2023-07-18T13:30:11","modified_gmt":"2023-07-18T13:30:11","slug":"dev-132-using-opengl-part-2-of-4","status":"publish","type":"page","link":"https:\/\/www.infodreams.it\/main\/publications\/dev-magazine\/dev-132-using-opengl-part-2-of-4\/","title":{"rendered":"Dev 132 \u2013 Using OpenGL \u2013 part 2 of 4"},"content":{"rendered":"

<\/p>\n

\nDevoting some space to the GLUT library before we start to see how to use OpenGL will save us a lot of time later by not addressing issues related to a specific operating system.<\/p><\/blockquote>\n

\n

<\/span>Introduction<\/h2>\n

As already said, by its nature OpenGL is a sophisticated API for creating 3D graphics and has more than 300 commands that allow us to generate very complex and realistic scenes.<\/p>\n

It is normal to marvel agains the complete lack of functions for display management. There is not even a system to receive commands from the keyboard, to detect mouse activity and use the audio capabilities. The motivation for such a choice stems from the desire of the creators of the API to make it as platform independent as possible. In fact a single function for opening windows will lead to an implementation based on direct calls to the host operating system\u2019s API of, which is in conflict with the original idea.<\/p>\n

<\/span>Some preliminary specifications<\/h2>\n

The first rule that OpenGL developers have followed to maintain a high level of portability has been to create a standard nomenclature for functions and for the declaration of data types. For the first is used a system which allows to identify at a glance the library to which a function belongs, the command, the number of arguments it requires and the type of data used. In Figure 1<\/strong> there is shown an example of a function where is visible the suffix \u2018gl\u2019 which indicates that the function belongs to the OpenGL library, the name of Vertex command, the number of arguments equal to 3, and the final \u2018f\u2019 that indicates that float is the type to use for parameters.<\/p>\n

\n
\"\"
Figure 1 \u2013 An example of naming conventions of functions in OpenGL<\/figcaption><\/figure>\n<\/div>\n

It \u2018s important to keep in mind another factor when using the OpenGL functions, most C++ compilers consider the numerical values being of type double by default\u200b\u200b, so you need to add the symbol \u2018f\u2019 to each argument passed to a function that accepts float data type, as shown:<\/p>\n

glColor4f (0.0f, 1.0f, 0.0f);\r\nglVertex3f (0.0f, 10.0f, 0.0f);<\/code><\/pre>\n
When we write a program normally we use data types that are defined by the compiler, but that somehow are related to the underlying machine architecture. We can not, in fact, be sure that a given type of float or int C is treated the same on different platforms. This leads, of course, to problems about portability; so OpenGL has been provided with its own set of data types that can be used with confidence that they will be interpreted in the same manner everywhere.<\/p>\n
Following you can find a list of all defined types, their corresponding C and the internal representation all with the standard suffixes identical to those used for the functions naming:<\/p>\n\n\n\n\n\n\n\n\n\n\n\n
Data type<\/strong><\/td>\nInternal representation<\/strong><\/td>\nC type<\/strong><\/td>\nC literal suffix<\/strong><\/td>\n<\/tr>\n
GLbyte<\/td>\n8bit integer<\/td>\nsigned char<\/td>\nb<\/td>\n<\/tr>\n
GLshort<\/td>\n16bit integer<\/td>\nshort<\/td>\ns<\/td>\n<\/tr>\n
GLint,
\nGLsizei<\/td>\n		32bit integer<\/td>\nlong<\/td>\nl<\/td>\n<\/tr>\n
GLfloat,
\nGLclampf<\/td>\n		32bit floating point<\/td>\nfloat<\/td>\nf<\/td>\n<\/tr>\n
GLdouble,
\nGLclampd<\/td>\n		64bit floating point<\/td>\ndouble<\/td>\nd<\/td>\n<\/tr>\n
GLubyte,
\nGLboolean<\/td>\n		8bit unsigned integer<\/td>\nunsigned char<\/td>\nub<\/td>\n<\/tr>\n
GLushort<\/td>\n16bit unsigned integer<\/td>\nunsigned short<\/td>\nus<\/td>\n<\/tr>\n
GLuint,
\nGLenum,
\nGLbitfield<\/td>\n		32bit unsigned integer<\/td>\nunsigned long<\/td>\nui<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
As you can see also the data types uses a standard naming structure with the \u2018GL\u2019 prefix to distinguish them from the types defined by C. The significance of most of them is clear and known, but they have added a lot more and useful ones. First, the type GLbitfield is useful for those variables that must contain bit fields. GLenum is used for the enumerated variables, while GLclamp, with suffix \u2018f\u2019 or \u2018d\u2019 represents a single or double-precision floating-point type which values can vary only between 0.0 and 1.0. Such type is useful because many functions take values \u200b\u200bwhich vary within this range. For example, the function glColor3f wants as parameters the RGB values of a color but in this case the intensity of the single component is defined in the range 0.0 to 1.0 and not between 0 and 255 as we could expect.<\/p>\n
<\/span>The GLUT library<\/h2>\n
To facilitate the learning process of OpenGL and accelerate development was created an auxiliary library called AUX, but due to some problems of implementation and compatibility was soon replaced by GLUT, written by Silicon Graphics.[(br)][(br)]<\/p>\n
The GLUT acronym stands for \u2018OpenGL Utility Toolkit\u2019, not to be confused with GLU the \u2018OpenGL utility library\u2019. GLUT is a cross-platform library that contains many functions for creating windows, pop-up menu and allows the management of the keyboard, joystick and video in full screen mode. Even developers without programming experience of GUIs, in a particular operating system, are thus able to achieve complete functional and fully portable programs.<\/p>\n
As the old AUX, however, GLUT is unable to meet the development needs of commercial applications, but is excellent in teaching for testing ideas or creating presentation programs. For these reasons GLUT will be used throughout the course of this special. References to download GLUT can be found directly from the site www.opengl.org<\/a><\/p>\n
<\/span>Our first program with GLUT<\/h2>\n
After many introductory words we finall can begin to actually use these libraries so now we will study how to build a full executable that opens a blank window. This code can be used as a template for all programs you will made. Following the complete source code<\/p>\n
void SetupRC()\r\n{\r\n    glClearColor(0.0f,0.0f,0.0f,1.0f);\r\n}\r\n\r\nvoid ChangeSize(GLsizei w, GLsizei h)\r\n{\r\n    glViewport(0, 0, w, h);\r\n}\r\n\r\nvoid RenderScene()\r\n{\r\n    glClear(GL_COLOR_BUFFER_BIT);\r\n    glutSwapBuffers();\r\n}\r\n\r\nvoid main()\r\n{\r\n    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);\r\n    glutInitWindowSize(640, 480);\r\n    glutCreateWindow(\"My first GLUT program\");\r\n\r\n    SetupRC();\r\n\r\n    glutReshapeFunc(ChangeSize);\r\n    glutDisplayFunc(RenderScene);\r\n    glutMainLoop();\r\n}<\/code><\/pre>\n
Looking at the following code we analyze, then each function. We start from the main() where we find the following call<\/p>\n
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA);<\/code><\/pre>\n
containing a parameter consists of several flags. The first, GLUT_RGBA, tells GLUT to initialize a window that supports a 32Bit video mode \u2013 the suffix RGBA stands for Red, Green, Blue and Alpha, where alpha is the transparency channel. GLUT_DOUBLE tells to the library info about format of the two buffers used for the final images storage.<\/p>\n
Theese buffers are used to achieve the mechanism known as \u2018double-buffering\u2019 that allows you to use a memory location at which all drawing operations remains hidden behind the scenes. After the drawing process the image is swapped quickly with that still visible on the screen. In this manner is possible to avoid the annoying and well-known effect of flickering. This setting is the opposite of GLUT_SINGLE in which case each drawing command will cause an immediate update on the displayed window. To swap the buffers just mentioned we must launch the \u2018glutSwapBuffers()\u2019 that we will soon explain.<\/p>\n
Then we find the call<\/p>\n
glutInitWindowSize(640, 480)<\/code><\/pre>\n
which does nothing but make GLUT set a size of 640\u00d7480 pixels for the window to be created. Inside the official GLUT documentation are also mentioned functions to position and move the window on the screen or even switch to fullscreen mode.<\/p>\n
Finally arrived the time to create our display window and that can be obtained by calling<\/p>\n
glutCreateWindow(\"My first GLUT program\")<\/code><\/pre>\n
it also sets the text displayed as windows caption. The last line of code<\/p>\n
glutMainLoop()<\/code><\/pre>\n
causes GLUT to launch a cycle that \u201ckeeps alive\u201d the program until the close button of the window will be clicked.<\/p>\n
So far these instructions, by themselves, are sufficient to run a minimal program which does not perform any operation: it just displays a blank window. In our applications, presentations or games we essentially need that:<\/p>\n