OpenGL球体纹理填充

上篇文章我们介绍过 纹理的使用，以及常用函数。今天我们来使用纹理填充球体，以及镜面效果的绘制。

首先我们来看一下绘制的效果图：

该镜面效果实际上是在球体的对立面重复绘制了一次，然后跟地面进行了 混合，所以我们对该效果划分划分为三层。地面为中间层，地面上面的所有球体为一层，地面下面的所有球体为一层。

• SetupRC初始化数据

1、初始化操作

    glClearColor(0.3f, 0.3f, 0.2f, 1.0f); 
    shaderManager.InitializeStockShaders();
    glEnable(GL_DEPTH_TEST);//深度测试
    glEnable(GL_CULL_FACE);//背面剔除

2、生成小球
2.0、生成小球

gltMakeSphere(smallSphereBatch, 0.1f, 26, 13);

参数1：smallSphereBatch三角形批次类对象
参数2：fRadius 球体半径
参数3：iSlices，从球体底部堆叠到顶部的三角形带的数量；其实球体是一圈一圈三角形带组成
参数4：iStacks，围绕球体一圈排列的三角形对数
绘制球体都是围绕Z轴，这样+z就是球体的顶点，-z就是球体的底部。

2.1、生成随机小球球顶点坐标数据

for (int i = 0; i < NUM_SPHERES; i++) {
        //y轴不变，X,Z产生随机值
        GLfloat x = ((GLfloat)((rand() % 400) - 200 ) * 0.1f);
        GLfloat z = ((GLfloat)((rand() % 400) - 200 ) * 0.1f);
        //在y方向，将球体设置为0.0的位置，这使得它们看起来是飘浮在眼睛的高度
        //对spheres数组中的每一个顶点，设置顶点数据
        spheres[i].SetOrigin(x, 0.0f, z);
}

3、生成地面、纹理坐标填充

    GLfloat texSize = 10.0f;
    floorBatch.Begin(GL_TRIANGLE_FAN, 4, 1);
    floorBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    floorBatch.Vertex3f(-20.f, -0.41f, 20.0f);
    
    floorBatch.MultiTexCoord2f(0, texSize, 0.0f);
    floorBatch.Vertex3f(20.0f, -0.41f, 20.f);
    
    floorBatch.MultiTexCoord2f(0, texSize, texSize);
    floorBatch.Vertex3f(20.0f, -0.41f, -20.0f);
    
    floorBatch.MultiTexCoord2f(0, 0.0f, texSize);
    floorBatch.Vertex3f(-20.0f, -0.41f, -20.0f);
    floorBatch.End();

4、生成大球

gltMakeSphere(bigSphereBatch, 0.4f, 40, 80);

建议：一个对称性较好的球体的片段数量是堆叠数量的2倍，就是iStacks = 2 * iSlices;

5、设置纹理对象
5.0 生成纹理对象

// 3：数量    uiTextures：无符号整形数组的指针（由纹理对象标识符填充）
glGenTextures(3, uiTextures);

5.1 绑定纹理对像，将TGA文件加载为2D纹理

glBindTexture(GL_TEXTURE_2D, uiTextures[0]);
LoadTGATexture("marble.tga", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, GL_REPEAT);

glBindTexture(GL_TEXTURE_2D, uiTextures[1]);
LoadTGATexture("marslike.tga", GL_LINEAR_MIPMAP_LINEAR,
                   GL_LINEAR, GL_CLAMP_TO_EDGE);

glBindTexture(GL_TEXTURE_2D, uiTextures[2]);
LoadTGATexture("moonlike.tga", GL_LINEAR_MIPMAP_LINEAR,
                   GL_LINEAR, GL_CLAMP_TO_EDGE);

看下LoadTGATexture (::::)函数
参数1szFileName：纹理文件名称
参数2minFilter&参数3magFilter：需要缩小&放大的过滤器
参数4wrapMode：纹理坐标环绕模式

bool LoadTGATexture(const char *szFileName, GLenum minFilter, GLenum magFilter, GLenum wrapMode) {
    GLbyte *pBits;
    int nWidth, nHeight, nComponents;
    GLenum eFormat;
    
    //1.读取纹理数据
    pBits = gltReadTGABits(szFileName, &nWidth, &nHeight, &nComponents, &eFormat);
    if(pBits == NULL)
        return false;
    
    //2、设置纹理参数
    //参数1：纹理维度
    //参数2：为S/T坐标设置模式
    //参数3：wrapMode,环绕模式
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapMode);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapMode);
    
    //参数1：纹理维度
    //参数2：线性过滤
    //参数3：wrapMode,环绕模式
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
    
    //3.载入纹理
    //参数1：纹理维度
    //参数2：mip贴图层次
    //参数3：纹理单元存储的颜色成分（从读取像素图是获得）-将内部参数nComponents改为了通用压缩纹理格式GL_COMPRESSED_RGB
    //参数4：加载纹理宽
    //参数5：加载纹理高
    //参数6：加载纹理的深度
    //参数7：像素数据的数据类型（GL_UNSIGNED_BYTE，每个颜色分量都是一个8位无符号整数）
    //参数8：指向纹理图像数据的指针
    glTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB, nWidth, nHeight, 0,
                 eFormat, GL_UNSIGNED_BYTE, pBits);
    
    //使用完毕释放pBits
    free(pBits);

    //4.加载Mip,纹理生成所有的Mip层
    //参数：GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
    glGenerateMipmap(GL_TEXTURE_2D);
    
    return true;
}

到此初始化数据已经准备完毕。下面来看一下如何绘制渲染。

• RenderScene绘制

上面已经说过了绘制大概分为三层，我们应该先绘制底层再绘制上层的内容。
RenderScene准备操作:

    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    
    static GLfloat vFloorColor[] = {0.8f, 0.5f, 0.6f, 0.75f};
    static CStopWatch   rotTimer;
    float yRot = rotTimer.GetElapsedSeconds() * 60.0f;
    
    modelViewMatrix.PushMatrix();
    M3DMatrix44f mCamera;
    cameraFrame.GetCameraMatrix(mCamera);
    modelViewMatrix.MultMatrix(mCamera);

1、绘制地面以下的所有球体

    //1.0 压栈
    modelViewMatrix.PushMatrix();
    //1.1 翻转Y轴、围绕Y轴平移一定间距
    modelViewMatrix.Scale(1.0f, -1.0f, 1.0f);
    modelViewMatrix.Translate(0.0f, 0.8f, 0.0f);
    //1.2 指定顺时针为正面
    glFrontFace(GL_CW);
    //1.3 绘制镜面的球
    drawSomething(yRot);
    //1.4 恢复为逆时针为正面
    glFrontFace(GL_CCW);
    //1.5 恢复矩阵
    modelViewMatrix.PopMatrix();

这里需要注意步骤1.2 glFrontFace(GL_CW);，因为我们绘制的球是从上面映射出来的，所以我们需要将 顺时针修改为正面 ，绘制完成后一定要记得修改回来。

我们详细看一下步骤 1.3 看如何绘制球体的。代码如下：

void drawSomething(GLfloat yRot) {
    //1.3.1 定义光源位置&漫反射颜色
    static GLfloat vWhite[] = { 1.0f, 1.0f, 1.0f, 1.0f };
    static GLfloat vLightPos[] = { 0.0f, 1.0f, 0.0f, 1.0f };
    
    //1.3.2 绘制悬浮小球球
    glBindTexture(GL_TEXTURE_2D, uiTextures[2]);
    for(int i = 0; i < NUM_SPHERES; i++) {
        modelViewMatrix.PushMatrix();
        modelViewMatrix.MultMatrix(spheres[I]);
        shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
                                     modelViewMatrix.GetMatrix(),
                                     transformPipeline.GetProjectionMatrix(),
                                     vLightPos,
                                     vWhite,
                                     0);
        smallSphereBatch.Draw();
        modelViewMatrix.PopMatrix();
    }
    
    //1.3.3 绘制大球球
    glBindTexture(GL_TEXTURE_2D, uiTextures[1]);
    modelViewMatrix.Translate(0.0f, 0.2f, -2.5f);
    modelViewMatrix.PushMatrix();
    modelViewMatrix.Rotate(yRot, 0.0f, 1.0f, 0.0f);
    shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
                                 modelViewMatrix.GetMatrix(),
                                 transformPipeline.GetProjectionMatrix(),
                                 vLightPos,
                                 vWhite,
                                 0);
    bigSphereBatch.Draw();
    modelViewMatrix.PopMatrix();
    
    //1.3.4 绘制公转小球球（公转自转)
    glBindTexture(GL_TEXTURE_2D, uiTextures[2]);
    modelViewMatrix.PushMatrix();
    modelViewMatrix.Rotate(yRot * -2.0f, 0.0f, 1.0f, 0.0f);
    modelViewMatrix.Translate(0.8f, 0.0f, 0.0f);
    shaderManager.UseStockShader(GLT_SHADER_TEXTURE_POINT_LIGHT_DIFF,
                                 modelViewMatrix.GetMatrix(),
                                 transformPipeline.GetProjectionMatrix(),
                                 vLightPos,
                                 vWhite,
                                 0);
    smallSphereBatch.Draw();
    modelViewMatrix.PopMatrix();
    
}

我们来解释下该函数中的 1.3.2 绘制悬浮小球

• 首先一定要记得绑定纹理。
• 使用我们初始化好的小球的顶点坐标，for循环绘制。
• 压栈，矩阵相乘。
• 使用的着色器类型 纹理光源着色器（GLT_SHADER_TEXTURE_POINT_LIGHT_DIEF）
• 出栈

再来看一下该函数中的 1.3.3 绘制大球，步骤基本一致。需要注意的是我们先执行了modelViewMatrix.Translate(0.0f, 0.2f, -5.5f);平移操作，然后才压栈。
之所以先平移，是因为我们 1.3.3 绘制大球 和 1.3.4 绘制公转小球（公转自转) 小球都需要平移。这样我们就可以省略一步，同时不影响后续的操作（因为地面一下的绘制完成后就会做一次出栈操作，步骤1.5）。

这时只有地面一下的球体，看下效果：

2、绘制地面

    //2.0 设置混合、指定glBlendFunc 颜色混合方程式
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    //2.1 绑定地面纹理
    glBindTexture(GL_TEXTURE_2D, uiTextures[0]);
    /*2.2 绘制
     纹理调整着色器(将一个基本色乘以一个取自纹理的单元nTextureUnit的纹理)
     参数1：GLT_SHADER_TEXTURE_MODULATE
     参数2：模型视图投影矩阵
     参数3：颜色
     参数4：纹理单元（第0层的纹理单元）
     
     */
    shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE,
                                 transformPipeline.GetModelViewProjectionMatrix(),
                                 vFloorColor,
                                 0);
    floorBatch.Draw();
    //2.3 取消混合
    glDisable(GL_BLEND);

这时已经有了地面，看效果：

3、绘制地面以上的球

    //3.0 地面以上的球
    drawSomething(yRot);

绘制球跟上面 1.3 用的是重复的代码。

4、恢复矩阵、交换缓存区、重新渲染

    // 绘制完，恢复矩阵
    modelViewMatrix.PopMatrix();
    //交换缓存区
    glutSwapBuffers();
    //提交重新渲染
    glutPostRedisplay();

绘制完毕，看完美效果：