Textures in OpenGL

CS 381 Lecture, Dr. Lawlor

Here's how I do textures in OpenGL:

Make up some texture data in C++. A texture is just a big 1D array of bytes, with groups of 4 bytes representing the RGBA color of each pixel, and pixels listed in x-first, then y-first order. For example, here's a 2x2 texture with red, green, blue, and white pixels:
```
	enum {w=2}; enum{h=2};
	unsigned char colors[4*w*h]={
		/*R    G    B    A  */
		0xff,0x00,0x00,0xff,  0x00,0xff,0x00,0xff,
		0x00,0x00,0xff,0xff,  0xff,0xff,0xff,0x7f,
	};
```
Copy the texture data from C++ onto the graphics card. I've written a handy class to do this, "oglTexture". The constructor takes a pointer to your pixel data (from step 1), and the width and height of the texture in pixels. WARNING: most graphics cards can only handle power-of-two sized textures!
bob
```
	oglTexture *t=new oglTexture(pixelData,w,h);
```
Every frame, before drawing geometry that's going to use that texture, "bind" the texture as the current texture, like
```
	t->bind();	
```
Optionally, set the wrap and filtering modes. See below for your options.
Declare the texture as a "sampler2D" object in GLSL. This is a uniform, coming in from C++. Textures always work in the fragment shader, but with the latest hardware also work in the vertex shader.
```
	uniform sampler2D myTex;
```
In C++, copy the texture unit number (more on those later) into GLSL, with glUniform1iARB or oglProgramObject->set. The default texture unit is unit 0:
```
	program->set("myTex",0);
```
Back in GLSL, call "texture2D(myTex,texCoords)" with a vec2 of 'texture coordinates' to look up the texture value. Texture coordinates ARE NOT PIXEL COORDINATES--they always go from 0.0 at the left and top of the image to 1.0 at the right and bottom of the image. Depending on your wrap modes (in step 4), texture coordinates can go far outside these values. Texture coordinates can be interpolated from the vertex shader (the typical, old-school approach), or computed directly in the fragment shader. The looked-up texture value can be used for anything, from an ordinary color to a vector perturbation.
```
	gl_FragColor = texture2D(myTex,texCoords);
```

Definitely check out the example program linked from the front page to see how it all fits together.

Texture Coordinate Wrapping

You can change what happens outside normal texture coordinate bounds, on both the S (x axis) and T (y axis) texture coordinate axes.

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
Works like fract(texCoords). Texture coordinates wrap back around to 0.0 when they exceed 1.0, which causes the texture to repeat. This is the most common wrap mode.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
Works like clamp(texCoords,0.0,1.0). Texture coordinates outside the normal range are flattened to 0.0-1.0.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
Works like clamp(texCoords,0.0+0.5/pixelSize,1.0-0.5/pixelSize), where "pixelSize" is the corresponding dimension of the texture in *texture* pixels. This has the effect of extending out the edge pixels. With GL_NEAREST filtering, it's identical to GL_CLAMP, but it's different for GL_LINEAR.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
Works like clamp(texCoords,0.0-0.5/pixelSize,1.0+0.5/pixelSize). The edge pixels linearly blend down to the "border color" (usually a transparent black), which then extends outward. This is probably what GL_CLAMP should have been.

Texture Filtering

You can also change how colors interpolate between pixels in the texture map when blowing up the texture map onscreen ("magnification" mode):

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_NEAREST);
Return the color of the nearest pixel. Results in ugly boxy shapes, but it's really fast, and never blurry.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);
Take a bilinear blend of neighboring pixels to create output values. Gives nice smooth output, but may be strange around the edges without GL_CLAMP_TO_BORDER or GL_REPEAT.

The same options exist when shrinking a texture map down onscreen ("minification" mode), along with extra "mipmap" options:

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);
Linearly interpolate pixels in the mipmaps, and then linearly interpolate between mipmaps. The smoothest version by far, and the recommended one to avoid aliasing.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);
Linearly interpolate pixels in the mipmaps, but only use the closest mipmap level. Slightly faster than linear-linear on older hardware.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_NEAREST);
Use nearest-neighbor pixels in the mipmaps, and only use the closest mipmap level. The ugliest approach, but good for checking for mipmap problems.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_NEAREST_MIPMAP_LINEAR);
Use nearest-neighbor pixels in the mipmaps, but blend between mipmap levels. Rarely useful.

You definitely have to just try these things out. Fire up the example 'texture' code, crank up the scale factor to put a zillion copies of the texture onscreen, and tilt and rotate.