This tutorial demonstrates how to use texture filters and will let you see the differences of each filter. I will also be introducing lighting into this tutorial.

We first have to create our "bitmap.h" header file with the functions we use to load our bitmaps, this is changed from the last tutorial to fit the needs of this one.

The first thing to do is to link all of our OpenGL libraries and include our needed headers for the functions we will call.


Next we define our first function with the same three arguments as the last tutorial (The texture array, file location, and place in array). This functon is going to load a linear filtered texture into our program. I will talk more about linear texturing in a little bit.


First, we want to make sure a file name was given, if it wasnt we return a false value to let the program know it failed, if a filename was given then we load our file into a new variable which we will use to manipulate the data into a readable format by our program.

If there was no data loaded (usually in case of a false filename) then we exit the program

Now that we are done with all of our error checking we generate our texture and place it into our texture array; however, we are not done yet.

Next we have to bind our texture to texture targets. Texture targets are just polygons that use the glVertex command.


now for our filtering. We want to set our filtering in this function to use Linear filtering. Linear filtering will resize the image to the size needed throughout runtime, this uses the most CPU, but generates the best effect. We set linear filtering twice because the second argument in the function defines when we want to use the filter, "GL_TEXTURE_MIN_FILTER" is telling the program to use the set filter when the texture is near "...MAG_FILTER" tells the program to use the set filter when the texture is far.


now we finally finish the creation of our texture. The first argument tells the function we are using a 2D image, the second is the detail of the image (usually set to 0), the third is how many components are in use (red, green, blue), the fourth and fifth tell the application to find the size of the image itself (you can substitute for the actual size if you want, but it reduces compatibility with other images), the sixth argument is the size of the border, then we tell the application the type of image we are using (red, green, blue), then we let it know the data is in unsigned bytes, then we tell it where to get the data.


then we need to clear our variable to preven memory leaks


now we need to define our new function that will load images with the nearest filter.


First, we want to make sure a file name was given, if it wasnt we return a false value to let the program know it failed, if a filename was given then we load our file into a new variable which we will use to manipulate the data into a readable format by our program.

If there was no data loaded (usually in case of a false filename) then we exit the program

Now that we are done with all of our error checking we generate our texture and place it into our texture array; however, we are not done yet.

Next we have to bind our texture to texture targets. Texture targets are just polygons that use the glVertex command.


now for our filtering. We want to set our filtering in this function to use nearest filtering. the nearest filtering setting uses the least amount of CPU, but begins to become pixelized when brought closer to the screen.


now we finally finish the creation of our texture. The first argument tells the function we are using a 2D image, the second is the detail of the image (usually set to 0), the third is how many components are in use (red, green, blue), the fourth and fifth tell the application to find the size of the image itself (you can substitute for the actual size if you want, but it reduces compatibility with other images), the sixth argument is the size of the border, then we tell the application the type of image we are using (red, green, blue), then we let it know the data is in unsigned bytes, then we tell it where to get the data.


then we need to clear our variable to preven memory leaks


We now define our function that will load mipmap images, it has the same arguments as the previous two functions.

First, we want to make sure a file name was given, if it wasnt we return a false value to let the program know it failed, if a filename was given then we load our file into a new variable which we will use to manipulate the data into a readable format by our program.

If there was no data loaded (usually in case of a false filename) then we exit the program

Now that we are done with all of our error checking we generate our texture and place it into our texture array; however, we are not done yet.

Next we have to bind our texture to texture targets. Texture targets are just polygons that use the glVertex command.


our filter for textures far from the camera will still be linear; however, when they are closer to the camera we will use mipmapping. Mipmapping loads the image then resizes it into lots of different sizes and during runtime decides which texture to use. This is the most efficient filter for the quality. Mipmapping also eliminates the need for the width and height of the image to be a power of two.



and next we have to create our texture, the next function is much like glTexImage2d except that it creates the different textures needed for the mipmapping, it has all of the same arguments except for the detail argument which is ommited.


then we need to clear our variable to preven memory leaks



The next section of code is the main body of the program.

we start by loading our header files, we need to load our bitmap.h file to so we can use the functions defined in it


next we create an array to hold 3 textures, 1 for each filter. We then create a rotation variable and speed variable to keep track of the cube's spin and speed, lastly we initialize a variable to keep track of which filter we are using.


now we create our init function that will initialize our opengl settings, it will also include the lighting settings.



we need to create three arrays. Each array will hold a different value for our light. The first array will define the ambient color, this is the color the object will look, we have to use this setting instead of glcolor3f(), but to define the colors for all light values it is the same. The second array will define the diffuse color, this is the color of the bright areas of the object or the color of the light. The last array is the position of the light, this is the same as glVertex3f, but it has an added variable in it which should just be set to 1.


next we have to put our settings into effect. We have to initialize our settings with the glLightfv() function. The first parameter is which light the setting will effect (there are 8 lights), the second argument is the setting to affect and the last is your variable holding the setting. There are five different settings, but we will only go over three in this tutorial.


next we have to enable two things, lighting and light1. Enable light1 enables the light we have just set up and enabling lighting enables all lighting.


next we setup our clear color and our screen size.


now we load our textures using the functions we created in our "bitmap.h" file. We load our texture with the linear filter, nearest filter, and mipmap filter into our texture array in that order. The we finally enable depth testing and finish with our init function.


now we start writing our display function which will draw all our objects to the screen. As always we will start by clearing the screen.



next we enable texturing and then bind the texture we want based on the filter selected.


Now we create a matrix for our transformation, we will rotate the cube based on the amount of the rotation variable, with this you can watch the light changing on the faces of the cube.

Next we create our cube. The only difference in creating our cube this time is the glNormal3f() function. This function defines a ray that points outward at a 90 degree angle from the middle of the polygon you are defining it for. glNormal3f() tells the program how to light the polygon depending on its angle to the light, you can use it point by point or you can use one glnormal3f() call per face. For this tutorial we will call it once per face.


now we close our matrix, disable texturing (in good habit to prevent odd effects in future applications), tell the program to draw everything to the screen, tell the program to start drawing again, and finally we add our rotation speed variable to our rotation variable.


next we define our keyboard function which will use keyboard commands to tell the program what to do.

we start our switch statements to tell the program what to do according to the key presses.

when we press 'L' or 'R' then it will adjust the speed of the spinning cube. pressing 1-3 will change the filter we use on the cube

we now finally finish our program with our main function that has been unchanged.



There are 7 different lights you can use at once GL_LIGHT1, GL_LIGHT2... You can enable all of them at once.

There are a few more settings for lighting, but we will get into that later on in the tutorials. I hope this tutorial was helpful, and if you have any questions feel free to leave a reply.

This post has been edited by t3jem: Jan 24 2007, 01:25 AM

I very like your help on Programming in Glut
Programming In Glut (lesson 6)

Replying to t3jem

I read all your 6 lessons in glut.

And I want to know is next leesson 7? I can't find it.



Your explatations are ideal, I thing you are the best teacher.





PS. Sorry about my bad English. I am Latvian, that is in Europe.



-Davispuh