OpenGL纹理映射演示程序代码

#include <stdafx.h>

#define WindowWidth  400 
#define WindowHeight 400 
#define WindowTitle  "OpenGL 纹理测试" 
 
#include <gl/glut.h> 
#include <stdio.h> 
#include <stdlib.h> 
 
/* 函数 grab 
 * 抓取窗口中的像素 
 * 假设窗口宽度为 WindowWidth，高度为 WindowHeight 
 */ 
#define BMP_Header_Length 54 
void grab(void) 
{ 
    FILE*    pDummyFile, *pWritingFile; 
    GLubyte* pPixelData, BMP_Header[BMP_Header_Length]; 
    GLint    i, j, PixelDataLength; 
 
    // 计算像素数据的实际长度 
    i = WindowWidth * 3;   // 得到每一行的像素数据长度 
    while( i % 4 != 0 )      // 补充数据，直到 i 是4的倍数 
        ++i;               // 本来还有更快的算法， 
                           // 但这里仅追求直观，对速度没有太高要求 
    PixelDataLength = i * WindowHeight; 
 
 
    // 分配内存和打开文件 
    pPixelData = (GLubyte*)malloc(PixelDataLength); 
    if( pPixelData == 0 ) 
        exit(0); 
 
    pDummyFile = fopen("Bliss.bmp", "rb"); 
    if( pDummyFile == 0 ) 
        exit(0); 
 
    pWritingFile = fopen("grab.bmp", "wb"); 
    if( pWritingFile == 0 ) 
        exit(0); 
 
    // 读取像素 
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 
    glReadPixels(0, 0, WindowWidth, WindowHeight, 
        GL_BGR_EXT, GL_UNSIGNED_BYTE, pPixelData); 
 
    // 把 dummy.bmp 的文件头复制为新文件的文件头 
    fread(BMP_Header, sizeof(BMP_Header), 1, pDummyFile); 
    fwrite(BMP_Header, sizeof(BMP_Header), 1, pWritingFile); 
    fseek(pWritingFile, 0x0012, SEEK_SET); 
    i = WindowWidth; 
    j = WindowHeight; 
    fwrite(&i, sizeof(i), 1, pWritingFile); 
    fwrite(&j, sizeof(j), 1, pWritingFile); 
 
    // 写入像素数据 
    fseek(pWritingFile, 0, SEEK_END); 
    fwrite(pPixelData, PixelDataLength, 1, pWritingFile); 
 
    // 释放内存和关闭文件 
    fclose(pDummyFile); 
    fclose(pWritingFile); 
    free(pPixelData); 
} 
// 第二段代码是我们的重点。它包括两个函数。其中 power_of_two 比较简单，虽然实现手段有点奇特，
// 但也并非无法理解（即使真的无法理解，读者也可以给出自己的解决方案，用一些循环以及多使用一些位
// 操作也没关系。反正，这里不是重点啦）。另一个 load_texture 函数却是重头戏：打开 BMP 文件、读取其
// 中的高度和宽度信息、计算像素数据所占的字节数、为像素数据分配空间、读取像素数据、对像素图象进
// 行缩放（如果必要的话）、分配新的纹理编号、填写纹理参数、载入纹理，所有的功能都在同一个函数里
// 面完成了。为了叙述方便，我把所有的解释都放在了注释里。 
 
/* 函数 power_of_two 
 * 检查一个整数是否为 2 的整数次方，如果是，返回 1，否则返回 0 
 * 实际上只要查看其二进制位中有多少个，如果正好有 1 个，返回 1，否则返回 0 
 * 在“查看其二进制位中有多少个”时使用了一个小技巧 
 * 使用 n &= (n-1)可以使得 n 中的减少一个（具体原理大家可以自己思考） 
 */ 
int power_of_two(int n) 
{ 
    if( n <= 0 ) 
        return 0; 
    return (n & (n-1)) == 0; 
} 
 
/* 函数 load_texture 
 * 读取一个 BMP 文件作为纹理 
 * 如果失败，返回 0，如果成功，返回纹理编号 
 */ 
GLuint load_texture(const char* file_name) 
{ 
    GLint width, height, total_bytes; 
    GLubyte* pixels = 0; 
    GLint last_texture_ID;
	GLuint texture_ID = 0; 
 
    // 打开文件，如果失败，返回 
    FILE* pFile = fopen(file_name, "rb"); 
    if( pFile == 0 ) 
        return 0; 
 
    // 读取文件中图象的宽度和高度 
    fseek(pFile, 0x0012, SEEK_SET); 
    fread(&width, 4, 1, pFile); 
    fread(&height, 4, 1, pFile); 
    fseek(pFile, BMP_Header_Length, SEEK_SET); 
 
    // 计算每行像素所占字节数，并根据此数据计算总像素字节数 
    { 
        GLint line_bytes = width * 3; 
        while( line_bytes % 4 != 0 ) 
            ++line_bytes; 
        total_bytes = line_bytes * height; 
    } 
 
    // 根据总像素字节数分配内存 
    pixels = (GLubyte*)malloc(total_bytes); 
 
    if( pixels == 0 ) 
    { 
        fclose(pFile); 
        return 0; 
    } 
 
    // 读取像素数据 
    if( fread(pixels, total_bytes, 1, pFile) <= 0 ) 
    { 
        free(pixels); 
        fclose(pFile); 
        return 0; 
    } 
 
    // 在旧版本的 OpenGL 中 
    // 如果图象的宽度和高度不是的整数次方，则需要进行缩放 
    // 这里并没有检查 OpenGL 版本，出于对版本兼容性的考虑，按旧版本处理 
    // 另外，无论是旧版本还是新版本， 
    // 当图象的宽度和高度超过当前 OpenGL 实现所支持的最大值时，也要进行缩放 
    { 
        GLint max; 
        glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max); 
        if( !power_of_two(width) 
         || !power_of_two(height) 
         || width > max 
         || height > max ) 
        { 
            const GLint new_width = 256; 
            const GLint new_height = 256; // 规定缩放后新的大小为边长的正方形 
            GLint new_line_bytes, new_total_bytes; 
            GLubyte* new_pixels = 0; 
 
            // 计算每行需要的字节数和总字节数 
            new_line_bytes = new_width * 3; 
            while( new_line_bytes % 4 != 0 ) 
                ++new_line_bytes; 
            new_total_bytes = new_line_bytes * new_height; 
 
            // 分配内存 
            new_pixels = (GLubyte*)malloc(new_total_bytes); 
            if( new_pixels == 0 ) 
            { 
                free(pixels); 
                fclose(pFile); 
 
                return 0; 
            } 
 
            // 进行像素缩放 
            gluScaleImage(GL_RGB, 
                width, height, GL_UNSIGNED_BYTE, pixels, 
                new_width, new_height, GL_UNSIGNED_BYTE, new_pixels); 
 
            // 释放原来的像素数据，把 pixels 指向新的像素数据，并重新设置 width 和 height 
            free(pixels); 
            pixels = new_pixels; 
            width = new_width; 
            height = new_height; 
        } 
    } 
 
    // 分配一个新的纹理编号 
    glGenTextures(1, &texture_ID); 
    if( texture_ID == 0 ) 
    { 
        free(pixels); 
        fclose(pFile); 
        return 0; 
    } 
 
    // 绑定新的纹理，载入纹理并设置纹理参数 
    // 在绑定前，先获得原来绑定的纹理编号，以便在最后进行恢复 
    glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture_ID); 
    glBindTexture(GL_TEXTURE_2D, texture_ID); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, 
        GL_BGR_EXT, GL_UNSIGNED_BYTE, pixels); 
    glBindTexture(GL_TEXTURE_2D, last_texture_ID); 
 
    // 之前为 pixels 分配的内存可在使用 glTexImage2D 以后释放 
    // 因为此时像素数据已经被 OpenGL 另行保存了一份（可能被保存到专门的图形硬件中） 
    free(pixels); 
    return texture_ID; 
}
// 第三段代码是关于显示的部分，以及 main 函数。注意，我们只在 main 函数中读取了两幅纹理，并把
// 它们保存在各自的纹理对象中，以后就再也不载入纹理。每次绘制时使用 glBindTexture 在不同的纹理对象
//  
// 中切换。另外，我们使用了超过 1.0 的纹理坐标，由于 GL_TEXTURE_WRAP_S 和 GL_TEXTURE_WRAP_T
// 参数都被设置为 GL_REPEAT，所以得到的效果就是纹理像素的重复，有点向地板砖的花纹那样。读者可
// 以试着修改“墙”的纹理坐标，将 5.0 修改为 10.0，看看效果有什么变化。 
/* 两个纹理对象的编号 */ 
GLuint texGround; 
GLuint texWall; 
 
void display(void) 
{ 
    // 清除屏幕 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
 
    // 设置视角 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 
    gluPerspective(75, 1, 1, 21); 
    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity(); 
    gluLookAt(1, 5, 5, 0, 0, 0, 0, 0, 1); 
 
    // 使用“地”纹理绘制土地 
    glBindTexture(GL_TEXTURE_2D, texGround); 
    glBegin(GL_QUADS); 
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-8.0f, -8.0f, 0.0f); 
        glTexCoord2f(0.0f, 5.0f); glVertex3f(-8.0f, 8.0f, 0.0f); 
        glTexCoord2f(5.0f, 5.0f); glVertex3f(8.0f, 8.0f, 0.0f); 
        glTexCoord2f(5.0f, 0.0f); glVertex3f(8.0f, -8.0f, 0.0f); 
    glEnd(); 
    // 使用“墙”纹理绘制栅栏 
    glBindTexture(GL_TEXTURE_2D, texWall); 
    glBegin(GL_QUADS); 
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-6.0f, -3.0f, 0.0f); 
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-6.0f, -3.0f, 1.5f); 
        glTexCoord2f(5.0f, 1.0f); glVertex3f(6.0f, -3.0f, 1.5f); 
        glTexCoord2f(5.0f, 0.0f); glVertex3f(6.0f, -3.0f, 0.0f); 
    glEnd(); 
 
    // 旋转后再绘制一个 
    glRotatef(-90, 0, 0, 1); 
    glBegin(GL_QUADS); 
        glTexCoord2f(0.0f, 0.0f); glVertex3f(-6.0f, -3.0f, 0.0f); 
        glTexCoord2f(0.0f, 1.0f); glVertex3f(-6.0f, -3.0f, 1.5f); 
        glTexCoord2f(5.0f, 1.0f); glVertex3f(6.0f, -3.0f, 1.5f); 
        glTexCoord2f(5.0f, 0.0f); glVertex3f(6.0f, -3.0f, 0.0f); 
    glEnd(); 
 
    // 交换缓冲区，并保存像素数据到文件 
    glutSwapBuffers(); 
    grab(); 
} 
 
int main(int argc, char* argv[]) 
{
    // GLUT 初始化 
    glutInit(&argc, argv); 
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA); 
    glutInitWindowPosition(100, 100); 
    glutInitWindowSize(WindowWidth, WindowHeight); 
    glutCreateWindow(WindowTitle); 
    glutDisplayFunc(&display); 
 
    // 在这里做一些初始化 
    glEnable(GL_DEPTH_TEST); 
    glEnable(GL_TEXTURE_2D); 
    texGround = load_texture("Bliss1.bmp"); 
    texWall = load_texture("Bliss2.bmp"); 
 
    // 开始显示 
    glutMainLoop(); 
 
    return 0; 
}