基于WinCE的OpenGL ES教程

TyphoonLabs OpenGL ES tutorials

Tutorial 3: Texturing

This tutorial will cover one of the most important features of every 3D

API: texturing. Without it, our applications won’t look realistic, because we

would have to use smoothed colors for all things, and a lot of triangles. This is

not really a good solution, so this is why texturing was ‘invented’.

After a brief theoretical introduction about texture objects, texture

creation, and texture mapping, we are going to write a simple program that

We need a function that takes a path to a texture image and load it as an

OpenGL ES texture. We will load TGA textures, but only those ones that

has 24 bits and are uncompressed.

In the render.h file, this is new function:

bool LoadTexture(const char *fileName, GLuint *id); //function

to load 24-bit uncompressed TGA textures

Let’s talk about this new function for a while. This function will receive a texture

filename and a pointer to a texture identifier. This identifier will be initialized

from inside the function (if proceed). This function will return true if the texture

was successfully loaded, otherwise will return false.

byte headerLength = 0;

byte imageType = 0;

byte bits = 0;

int format= 0;

int lineWidth = 0;

fread(&headerLength, sizeof(byte), 1, f);

//skip next byte

fseek(f,1,SEEK_CUR);

//read in the imageType (RLE, RGB, etc...)

fread(&imageType, sizeof(byte), 1, f);

TyphoonLabs OpenGL ES tutorials

fread(&width, sizeof(WORD), 1, f);

fread(&height, sizeof(WORD), 1, f);

fread(&bits, sizeof(byte), 1, f);

//move the file pointer to the pixel data

fseek(f, headerLength + 1, SEEK_CUR);

//check if the image is not compressed.

if(imageType != 10)

{

//check if the image is a 24

if(bits == 24)

//we are going to load the pixel data line by line

for(int y = 0; y < height; y++)

{

//Read current line of pixels

GLubyte *line = &(pixels[lineWidth * y]);

fread(line, lineWidth, 1, f);

/*Because the TGA is BGR instead of RGB, we must swap the R

and G components (OGL ES does not have the

GL_BGR_EXT extension*/

for(int i=0;i<lineWidth ; i+=format)

}

else

{

fclose(f);

*id = 0;

return false;

}

}

fclose(f);

/*Creation of the OpenGL Texture:

GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR

and GL_LINEAR_MIPMAP_LINEAR.

Because OpenGL ES is written against OpenGL 1.5, it supports

automatic mipmap generation, using the next call:

glTexParameterx(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);

TyphoonLabs OpenGL ES tutorials

GL_MIRRORED_REPEAT are not supported)

Allowed formats are:

Internal & External Format Type Bytes per Pixel

GL_RGBA GL_UNSIGNED_BYTE 4

GL_RGB GL_UNSIGNED_BYTE 3

GL_RGBA GL_UNSIGNED_SHORT_4_4_4_4 2

GL_RGBA GL_UNSIGNED_SHORT_5_5_5_1 2

and the (new) fixed point version (that is what we will use) */

//Ask for a free texture name

glGenTextures(1, id);

/*first binding implies the texture object creation*/

glBindTexture(GL_TEXTURE_2D, *id);

/*Set texture properties: filtering and clamping modes*/

glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

}

With this we have the texture ready to be used. Let’s see how to.

Add this line at the end of the InitOGLES function:

In the top of the render.cpp file (under all other variable declarations), declare

this variable:

Gluint texture1 = 0;

bool result = LoadTexture("./resources/door128.tga",&texture1);

We call the texture handle “texture1” because, later, we will learn how to

use multitexture, and for that, we will need another texture (texture2)

This call to LoadTexture will search for the texture filename that we are

TyphoonLabs OpenGL ES tutorials

Textures are rectangular (and it’s dimensions must be power of two), but

usually we use triangles to draw, or even worse, complex meshes. Anyway,

rare times the mesh has the same dimensions that the texture has, so, how

could we ‘glue’ a set of texels (texture pixels) over an arbitrary mesh?. The

answer are the texture coordinates. We will parameterize our textures between

0 and 1. Let’s see an example:

This is our texture, with its dimensions at each vertex.

Now, this is our texture with its dimensions parameterized:

As you can see, we’ve converted the dimensions to a number between 0

and 1 (0 = origin in this axis, 1 = “end” in this axis. All intermediate numbers

represent the intermediate values, for example, if we map from 0 to 0.5 we will