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

<\/p>\n

\n

\nThis is the last step of our journey: knowing the technical aspects of lighting sources and apply them to 2D objects to achieve a more realistic look.\n<\/p><\/blockquote>\n

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

The more advanced features of OpenGL are concerned, for the most part, the simulation of natural phenomena like light and materials. In this way, through the continuous development, an attempt to provide the library of characteristics such as to realize scenes increasingly close to reality.<\/p>\n

<\/span>Let\u2019s turn some light on<\/h2>\n

When drawing primitives or creating solid objects, up to this moment, we are able to associate them a given RGB color. In the real world, however, we simply do not see things according to their absolute color. People knows that color is nothing more than an interpretation by our visual organs of a particular range of radiation, ie, the light. Usually that arises from a well-defined source and the color of objects varies depending on the position with respect to it. OpenGL can approximate the conditions of the real world through the use of three types of illumination:<\/p>\n

    \n
  1. The \u2018ambient light<\/strong>\u2018, which has a brightness that but don\u2019t comes from a specific direction, although having a source. When creating an \u2018ambient light\u2019 all the polygons of a scene are illuminated in the same manner.<\/li>\n
  2. The \u2018scattered light<\/strong>\u2018. It represents that kind of light that is reflected in a uniform manner. In this way a surface becomes brighter when the rays emitted by the source strikes it perpendicularly.<\/li>\n
  3. The \u2018specular light<\/strong>\u2018. It is similar to the previous unless the fact that, in this case, the rays from the source are reflected back to a particular direction. This effect generates, usually a bright spot on the reflecting surface as can the sunlight on the bodywork of a car.<\/li>\n<\/ol>\n

    The light, however, represents only a component of the equation. Indeed, we know that color and brightness of an object are also dependent on the material that constitutes it, and how this it reacts to light radiation.<\/p>\n

    Using the illumination we will not discuss any more about the color of a polygon in terms of RGB levels, but regarding the manner in which it reflects or absorbs certain wavelengths. We could create a blue ball or a metallic-looking cube or more similar to plastic one, simply by setting the properties of their constituent materials. Let\u2019s see how join it all together. To enable the use of light is sufficient the OpenGL call<\/p>\n

    glEnable(GL_LIGHTING)<\/code><\/pre>\n
    which enables the color calculation of each vertex according to the material and the type and position of the light source. Obviously, in the absence of the latter the scene would remain dark. First you need to set the three types of lighting via the function<\/p>\n
    void glLightfv(GLenum light, GLenum pname, const GLfloat * param)<\/code><\/pre>\n
    The first parameter of the function identifies the light source to which apply the settings. OpenGL provides a maximum of 8 light sources: from GL_LIGHT0 to GL_LIGHT7. The second parameter asks you to specify one of three types of light, ie<\/p>\n
      \n
    1. GL_AMBIENT<\/strong> to set the values \u200b\u200bof ambient light<\/li>\n
    2. GL_DIFFUSE<\/strong> to set the values \u200b\u200bof the diffused light<\/li>\n
    3. GL_SPECULAR<\/strong> to set the values \u200b\u200bof the specular highlight<\/li>\n
    4. GL_POSITION<\/strong> to set the position of the light<\/li>\n<\/ol>\n
      Finally, the function, takes an array of 4 float which contains the settings of the source where the first three variables represent the intensity of the components between 0.0f and 1.0f. The value 1.0f to the fourth causes the light rays from spreading in all directions, while if it will be 0.0f as coming from an infinite distance. In the latter way the rays are processed as they are parallel to each other. In order to use the source must be set to activate it by calling<\/p>\n
      glEnable(GL_LIGHT0)<\/code><\/pre>\n
      Now it is necessary to make sure that the polygons has a material for reacting to the lighting. We enable the management of materials by<\/p>\n
      glEnable(GL_COLOR_MATERIAL)<\/code><\/pre>\n
      then we inform OpenGL about the properties of the polygons\u2019s faces with the function<\/p>\n
      void glColorMaterial(GLenum face, GLenum mode)<\/code><\/pre>\n
      The first parameter indicates to which face we want to apply that setting. The possible values \u200b\u200bare GL_FRONT, GL_BACK for front and back faces, while GL_FRONT_AND_BACK does it on both. The second parameter takes the values \u200b\u200bGL_EMISSION, GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_AMBIENT_AND_DIFFUSE. It say that the material must react accordingly to the color settings of the indicated light type. After that we just have to make the material with the mirror function between<\/p>\n
      void glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)<\/code><\/pre>\n
      we make the call in this form<\/p>\n
      GLfloat reflectivity[] = {1.0f, 1.0f, 1.0f, 1.0f};\r\n...\r\nglMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, reflectivity);<\/code><\/pre>\n
      and set its level of reflectivity with<\/p>\n
      glMateriali(GL_FRONT, GL_SHINIESS, 128)<\/code><\/pre>\n
      The more the last parameter value is high \u2013 it can take up to 128 \u2013 the more mirror effect appears \u201cfocused\u201d, ie, the point generated is more defined and focused. Let\u2019s see a practical example, following listing shows a possible initialization GL_LIGHT0 light source and the material is a generic program.<\/p>\n
      \/\/ Array for the lights settings\r\nGLfloat ambientLight[] = {0.1f, 0.1f, 0.1f, 1.0f};\r\nGLfloat diffuseLight[] = {0.45f, 0.2f, 0.4f, 1.0f};\r\nGLfloat specularLight[] = {1.0f, 1.0f, 0.4f, 1.0f};\r\nGLfloat light0Position[] = {0.0f, 0.0f, 0.0f, 1.0f};\r\n\r\n\/\/ Array for reflectivity settings\r\nGLfloat reflectivity[] = {1.0f, 1.0f, 1.0f, 1.0f};\r\n\r\nvoid SetupRC()\r\n{\r\n    glClearColor(0.0f,0.0f,0.0f,1.0f);\r\n    glEnable(GL_DEPTH_TEST);\r\n    glShadeModel(GL_SMOOTH);\r\n\r\n    \/\/ Activates lighting \r\n    glEnable(GL_LIGHTING);\r\n\r\n    \/\/ Sets LIGHT0 components\r\n    glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);\r\n    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);\r\n    glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight);\r\n    glLightfv(GL_LIGHT0, GL_POSITION, light0Position);\r\n\r\n    \/\/ Activates LIGHT0\r\n    glEnable(GL_LIGHT0);\r\n\r\n    \/\/ Enables materials\r\n    glEnable(GL_COLOR_MATERIAL);\r\n\r\n    \/\/ Sets materials reactivity to the \r\n    \/\/ and scattered light\r\n    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);\r\n\r\n    \/\/ Sets the reflectivity values\r\n    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, reflectivity);\r\n\r\n    \/\/ Sets the reflectivity level\r\n    glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 32);\r\n}<\/code><\/pre>\n
      The sample programs Luci.exe<\/strong> describes in practice the application of rules learned so far, Figure 1<\/strong> is an image taken from the example. Now everything is ready and OpenGL is able to properly manage the light source, but we have not put any object in the scene. Even if we had done the result was not what was intended, and this is because it was not introduced an additional concept: the normals.<\/p>\n
      \n
      \"\"
      Figure 1 \u2013 Example of lighting on an object<\/figcaption><\/figure>\n<\/div>\n
      A normal is nothing but the vector perpendicular to the plane where a polygon is placed, so it is used to determine the angle of inclination between it and a light source. It is clear that if this angle is equal to zero the light is placed perpendicularly to the figure so the polygon will be better illuminated. Otherwise, when the angle increases, the quantity of reflected light decreases.<\/p>\n
      There are no specific functions for calculating the normal of a polygon and, without dwelling too much on the subject, I recommend you use the library \u2018gltools\u2019 that you will find on the FTP site. This provides the function<\/p>\n
      gltGetNormalVector(GLTVector VP1, GLTVector VP2, GLTVector VP3, GLTVector vNormal)<\/code><\/pre>\n
      The variable GLTVector is an array of three floats containing the coordinates of one vertex of the polygon. The parameter vNormal is the result of the calculation and should be passed to the function<\/p>\n
      glNormal3fv(const GLfloat * v)<\/code><\/pre>\n
      which accepts an array of float in place of the vector representing the normal. Look following listing for a clearer idea of \u200b\u200bhow to implement proper handling of normals.<\/p>\n
      \/\/ Create the walls by storing them in a list\r\nvoid drawWalls()\r\n{\r\n    GLint i, j;\r\n\r\n    \/\/ Creates a new list \r\n    glNewList(1, GL_COMPILE);\r\n\r\n    \/\/ Set the color for bottom wall\r\n    glColor3f(1.0f, 1.0f, 1.0f);\r\n\r\n    \/\/ Bottom wall\r\n    glBegin(GL_QUADS);\r\n\r\n    for (i = -HALF_WALL_SIZE; i < HALF_WALL_SIZE - STEP; i+=STEP)\r\n    {\r\n        for (j = -HALF_WALL_SIZE; j < HALF_WALL_SIZE - STEP; j += STEP)\r\n        {\r\n            \/\/ Creates a vector array containing\r\n            \/\/ the coordinates of wall's vertices\r\n            GLTVector3 points[4] = {{j, 0, i+STEP}, {j+STEP, 0, i+STEP}, {j+STEP, 0, i}, {j, 0, i}};\r\n\r\n            \/\/ Calculation of the normal of three points\r\n            gltGetNormalVector(points[0], points[1], points[2], vNormal);\r\n\r\n            \/\/ Sets the normal\r\n            glNormal3fv(vNormal);\r\n\r\n            \/\/ Sets vertex values\r\n            glVertex3fv(points[0]);\r\n            glVertex3fv(points[1]);\r\n            glVertex3fv(points[2]);\r\n            glVertex3fv(points[3]);\r\n        }\r\n    }\r\n\r\n    glEnd();\r\n\r\n    \/\/ Right lateral\r\n    glBegin(GL_QUADS);\r\n\r\n    for (i = 0; i < WALL_SIZE; i+=STEP)\r\n    {\r\n        for (j = -HALF_WALL_SIZE; j < HALF_WALL_SIZE - STEP; j += STEP)\r\n        {\r\n            \/\/ Creates a vector array containing\r\n            \/\/ the coordinates of wall's vertices\r\n            GLTVector3 points[4] = {{j, i, -HALF_WALL_SIZE}, {j+STEP, i, -HALF_WALL_SIZE}, {j+STEP, i+STEP, -HALF_WALL_SIZE}, {j, i+STEP, -HALF_WALL_SIZE}};\r\n\r\n            \/\/ Calculation of the normal of three points\r\n            gltGetNormalVector(points[0], points[1], points[2], vNormal);\r\n\r\n            \/\/ Sets the normal\r\n            glNormal3fv(vNormal);\r\n\r\n            \/\/ Sets vertex values\r\n            glVertex3fv(points[0]);\r\n            glVertex3fv(points[1]);\r\n            glVertex3fv(points[2]);\r\n            glVertex3fv(points[3]);\r\n        }\r\n    }\r\n\r\n    glEnd();\r\n\r\n    \/\/ Left lateral\r\n    glBegin(GL_QUADS);\r\n\r\n    for (i = 0; i < WALL_SIZE; i+=STEP)\r\n    {\r\n        for (j = -HALF_WALL_SIZE; j < HALF_WALL_SIZE - STEP; j += STEP)\r\n        {\r\n            \/\/ Creates a vector array containing\r\n            \/\/ the coordinates of wall's vertices\r\n            GLTVector3 points[4] = {{HALF_WALL_SIZE-STEP, i, j+STEP}, {HALF_WALL_SIZE-STEP, i+STEP, j+STEP}, {HALF_WALL_SIZE-STEP, i+STEP, j}, {HALF_WALL_SIZE-STEP, i, j}};\r\n\r\n            \/\/ Calculation of the normal of three points\r\n            gltGetNormalVector(points[0], points[1], points[2], vNormal);\r\n\r\n            \/\/ Sets the normal\r\n            glNormal3fv(vNormal);\r\n\r\n            \/\/ Sets vertex values\r\n            glVertex3fv(points[0]);\r\n            glVertex3fv(points[1]);\r\n            glVertex3fv(points[2]);\r\n            glVertex3fv(points[3]);\r\n        }\r\n    }\r\n\r\n    glEnd();\r\n\r\n    \/\/ Closes the list\r\n    glEndList();\r\n}<\/code><\/pre>\n
      You\u2019ll also notice the function<\/p>\n
      glNewList(1, GL_COMPILE)<\/code><\/pre>\n
      This instruction causes the OpenGL compiles all commands that meets for fast execution the next call<\/p>\n
      glEndList()<\/code><\/pre>\n
      Whenever you need to list just call the function<\/p>\n
      glCallList(1)<\/code><\/pre>\n
      <\/span>Textures<\/h2>\n
      Filling a polygon through a simple color often is not sufficient to meet our requirements. An important feature that each 3D graphics library provides is the possibility of using an image to fill the polygons. This technique is called \u2018texture mapping\u2019. We can create very convincing scenes providing to objects a near-real appearance. We have already seen, in the first article, an example of texture mapping.<\/p>\n
      The first thing we must do to use textures in a program is to load the images. To this end we will use the function<\/p>\n
      void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * data)<\/code><\/pre>\n
      That enormous amount of parameters have to provide all the information needed to correctly interpret the data pointed by \u2018data\u2019 array. Let\u2019s look at the meaning of each one<\/p>\n
        \n
      • target<\/strong> must be set to GL_TEXTURE_2D[(\/li)] and represents the type of texture, but we will not cover this topic.<\/li>\n
      • level<\/strong> when set to 0 specifies the level of mipmap. We will not cover this topic.<\/li>\n
      • internalformat<\/strong> specifies the format to use for organizing data in memory when they are loaded. It can be set to GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA. Usually, this parameter is set to GL_RGB and GL_RGBA.<\/li>\n
      • width<\/strong>, height<\/strong> represents the dimensions of the image. It is very important to know that the image can have the following measures following powers of 2 ie 4\u00d72, 64\u00d7128, 4096\u00d71024 and so on \u2026<\/li>\n
      • border<\/strong> serves to create a border for the image. Set it to 0.<\/li>\n
      • format<\/strong> indicates the the format of provided image data. There are many values \u200b\u200bthat this parameter can assume, but the most common are GL_RGB and GL_RGBA.<\/li>\n
      • type<\/strong> is the data type used for express image data. For images at 24 or 32-bit the correct setting is GL_UNSIGNED_BYTE<\/li>\n
      • data<\/strong> is the array containing the image<\/li>\n<\/ul>\n
        As was obvious to expect, OpenGL has no function to load image from files. We use the function contained in the file LoadTGA.c.<\/p>\n
        Before using a texture we must set other parameters. First we must define what happens when it is resized, ie, when the distance of the object to the observer changes:<\/p>\n
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);\r\nglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);<\/code><\/pre>\n
        In short we will ensure that OpenGL will use a filter that blurs the edges slightly on enlarged pixel, or when the objects go far away, avoiding the unsightly jagged. Even the texture management must be enabled<\/p>\n
        glEnable(GL_TEXTURE_2D)<\/code><\/pre>\n
        Once the image have been loaded we have to map it on the target polygon. This must be done during the vertices specification phase calling<\/p>\n
        glTexCoord2f(GLfloat s, GLfloat t)<\/code><\/pre>\n
        Each coordinate is associated with the following vertex and can vary between 0.0 and 1.0 regardless of the size of the image. The following code associates a generic image of a triangle<\/p>\n
        glBegin(GL_TRIANGLE);\r\n    glTexCoord2f(0.0f, 0.0f);\r\n    glVertex3f(0.0f, 0.0f, 0.0f);\r\n    glTexCoord2f(0.5f, 1.0f);\r\n    glVertex3f(5.0f, 10.0f, 0.0f);\r\n    glTexCoord2f(1.0f, 0.0f);\r\n    glVertex3f(10.0f, 0.0f, 0.0f);\r\nglEnd();<\/code><\/pre>\n
        In Figure 2<\/strong> you can see the output of the program Texture.exe. By now you should become familiar with our programs, so studying the code should not be so difficult an undertaking.<\/p>\n
        \n
        \"\"
        Figure 2 \u2013 On the scene there are two objects, the teapot and the horizontal plane, each associated with its own texture<\/figcaption><\/figure>\n<\/div>\n
        <\/span>The fog effect<\/h2>\n
        A very simple to use with OpenGL is fogging which is applied at the end of all operations related to the color. It determines how to mix the color, of the geometry present in the scene, with that choosen for the mist. It is also possible to vary the density values \u200b\u200band the equations that generate a different effect on distant of objects, from the point of observation. To use the effect, simply follow these steps<\/p>\n
        \/\/ Initialize an array of four GLfloat\r\n\/\/ containing the fog color\r\nGLfloat fogColor[] = {0.7f, 0.7f, 0.7f, 1.0f};\r\n\r\n\/\/ Enable the effect\r\nglEnable(GL_FOG);\r\n\r\n\/\/ Sets the fog color\r\nglFogfv(GL_FOG_COLOR, fogColor);\r\n\r\n\/\/ Sets the distance from the observer, the\r\n\/\/ start of the fog bank\r\nglFogf(GL_FOG_START, 5.0f);\r\n\r\n\/\/ Sets the distance where this ends\r\nglFogf(GL_FOG_END, 30.0f);\r\n\r\n\/\/ Indicates the equation of fog densification\r\nglFogi(GL_FOG_MODE, GL_LINEAR);\r\n\r\n\/\/ Sets the density of the fog\r\nglFogf(GL_FOG_DENSITY, 0.5f);<\/code><\/pre>\n
        This is it. The only observation that can be made in the last statement is that OpenGL allows you to change the method that fog thickening is calculated, as a function of the distance from the observer. Indeed, we can specify additional parameters in addition to GL_LINEAR as GL_EXP and GL_EXP2. Choosing such equations we get an exponential thickening effect more pronounced only at big distances.<\/p>\n
        <\/span>Blending<\/h2>\n
        We know by now that images are drawn in the color buffer by overlaping values. We may be interested to enable the blending<\/p>\n
        glEnable(GL_BLEND)<\/code><\/pre>\n
        so that the new figures in the process of being drawn inside the color buffer will be combined with the existing ones.
        \nThere are several ways to combine the color of two images and each one can generate a particular effect, such as, for example, the transparency.<\/p>\n
        To proceed, you must know the terminology commonly used. The existing color in the color buffer is called the target, while the one that is being written is the source. To determine how the two colors will be combined we have to use the following equation<\/p>\n
        Cf = (Cs * S) + (Cd * D)<\/code><\/pre>\n
        where: Cf is the final color, Cs is the source and CD the destination. S and D are the factors to scale source and destination colors. These factors are required by<\/p>\n
        glBlendFunc(GLenum S, GLenum D)<\/code><\/pre>\n
        Below the possible values \u200b\u200bfor these parameters<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
        Function<\/strong><\/td>\nRGB Blend Factor<\/strong><\/td>\nAlpha Blend Factor<\/strong><\/td>\n<\/tr>\n
        GL_ZERO<\/td>\n(0, 0, 0)<\/td>\n0<\/td>\n<\/tr>\n
        GL_ONE<\/td>\n(1, 1, 1)<\/td>\n1<\/td>\n<\/tr>\n
        GL_SRC_COLOR<\/td>\n(Rs, Gs, Bs)<\/td>\nAs<\/td>\n<\/tr>\n
        GL_ONE_MINUS_SRC_COLOR<\/td>\n(1, 1, 1) \u2013 (Rs, Gs, Bs)<\/td>\n1 \u2013 As<\/td>\n<\/tr>\n
        GL_DST_COLOR<\/td>\n(Rd, Gd, Bd)<\/td>\nAd<\/td>\n<\/tr>\n
        GL_ONE_MINUS_DST_COLOR<\/td>\n(1, 1, 1) \u2013 (Rd, Gd, Bd)<\/td>\n1 \u2013 Ad<\/td>\n<\/tr>\n
        GL_SRC_ALPHA<\/td>\n(As, As, As)<\/td>\nAs<\/td>\n<\/tr>\n
        GL_ONE_MINUS_SRC_ALPHA<\/td>\n(1, 1, 1) \u2013 (As, As, As)<\/td>\n1 \u2013 As<\/td>\n<\/tr>\n
        GL_DST_ALPHA<\/td>\n(Ad, Ad, Ad)<\/td>\nAd<\/td>\n<\/tr>\n
        GL_ONE_MINUS_DST_ALPHA<\/td>\n(1, 1, 1) \u2013 (Ad, Ad, Ad)<\/td>\n1 \u2013 Ad<\/td>\n<\/tr>\n
        GL_CONSTANT_COLOR<\/td>\n(Rc, Gc, Bc)<\/td>\nAc<\/td>\n<\/tr>\n
        GL_ONE_MINUS_CONSTANT_COLOR<\/td>\n(1, 1, 1) \u2013 (Rc, Gc, Bc)<\/td>\n1 \u2013 Ac<\/td>\n<\/tr>\n
        GL_CONSTANT_ALPHA<\/td>\n(Ac, Ac, Ac)<\/td>\nAc<\/td>\n<\/tr>\n
        GL_ONE_MINUS_CONSTANT_ALPHA<\/td>\n(1, 1, 1) \u2013 (Ac, Ac, Ac)<\/td>\n1 \u2013 Ac<\/td>\n<\/tr>\n
        GL_SRC_ALPHA_SATURATE<\/td>\n(f, f, f)<\/td>\n1<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
        We see now a classic example. This is the most common approach to generate a transparency effect<\/p>\n
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)<\/code><\/pre>\n
        Here\u2019s what happens if the buffer is red-colored {1.0f, 0.0f, 0.0f, 0.0f}, while the color to be drawn is blue with an alpha value set to 0.5f {0.0f, 0.0f, 1.0f, 0.5f}. We have that<\/p>\n
        Cd = {1.0f, 0.0f, 0.0f, 1.0f}\r\nCs = {0.0f, 0.0f, 1.0f, 0.5f}\r\nS = source level of alpha = 0.5f\r\nD = 1 - 0.5f = 0.5f<\/code><\/pre>\n
        The equation takes the form<\/p>\n
        Cf = (Cs * 0.5f) + (Cd * 0.5f) = {0.5, 0.0f, 0.0f, 0.0f} + {0.0f, 0.0f, 0.5f, 0.5f} = {0.5f, 0.0f, 0.5f, 0.5f}<\/code><\/pre>\n
        generating a dark purple.<\/p>\n
        <\/span>Conclusions<\/h2>\n
        I hope I was clear enough and comprehensive because facing a complex subject does not suffice an entire book. It is very important, therefore, that you refer to the official OpenGL specifications (which can be found inside the Demo package) to learn more about the functions and parameters that shall be accepted.<\/p>\n
        There are many features, in fact, I have not had a chance to show for obvious reasons. Perhaps I will return to discuss issues related to OpenGL programming, but it also depends on you. Write and participate with questions and suggestions. Let us know if our work is useful for you or, in some way, interesting.<\/p>\n
        <\/span>Bibliography<\/h2>\n
          \n
        1. Richard S.Wright jr. and Benjamin Lipchak, \u201cOpenGL SuperBible \u2013 Third Edition\u201d, SAMS, 2005, ISBN 0-672-32601-9<\/li>\n<\/ol>\n
          <\/span>Original article<\/h2>\n