opengl读取obj兔子并贴图_OpenGL学习笔记(八)-纹理

最新推荐文章于 2024-08-16 17:41:42 发布
最新推荐文章于 2024-08-16 17:41:42 发布
阅读量1.2k 收藏 6
点赞数
文章标签： opengl读取obj兔子并贴图

1a02f72137fca58d69ff02397ae6aee5.png

1.认识纹理

纹理其实就是一张图片，在绘制图形时敷着在其表面。是电脑立体图像中，用于表面效果的点阵图(位图)。

2.原始图像数据

图像存储空间 = 图像的高度 * 图像的宽度 * 每个像素的字节数

3.认识一些纹理函数

3.1.像素存储⽅式

//改变像素存储⽅式
void glPixelStorei(GLenum pname,GLint param);

//恢复像素存储⽅式
void glPixelStoref(GLenum pname,GLfloat param);
//举例：
//参数1：GL_UNPACK_ALIGNMENT 指定OpenGL 如何从数据缓存区中解包图像数据
//参数2：表示参数GL_UNPACK_ALIGNMENT 设置的值

//指内存中每个像素⾏起点的排列请求，允许设置为1（byte排列）、2（排列为偶数byte的⾏）、4（字word排列）、8（⾏从双字节边界开始）
glPixelStorei(GL_UNPACK_ALIGNMENT,1);

3.2.从颜⾊缓存区内容作为像素图直接读取

void glReadPixels(GLint x,
		GLint y,
		GLSizei width,
		GLSizei height,
		GLenum format,
		GLenum type,
		const void * pixels);
//参数1：x,矩形左下⻆的窗⼝坐标
//参数2：y,矩形左下⻆的窗⼝坐标
//参数3：width,矩形的宽，以像素为单位
//参数4：height,矩形的⾼，以像素为单位
//参数5：format, OpenGL 的像素格式，参考下表1
//参数6：type,解释参数pixels指向的数据，告诉OpenGL 使⽤缓存区中的什么数据类型来存储颜⾊分量，像素数据的数据类型，参考 表2
//参数7：pixels, 指向图形数据的指针

glReadBuffer(mode); —> 指定读取的缓存
glWriteBuffer(mode); —> 指定写⼊的缓存

8cc5979821fe3748d3cba9c795acd073.png
表1OpenGL的像素格式(上面函数format参数的取值)

8a534c5f4da9dbcc318248e035fb86b9.png
表2 像素数据的数据类型(上面函数type的取值)

3.3.载⼊纹理

void glTexImage1D(GLenum target,
		GLint level,
		GLint internalformat,
		GLsizei width,
		GLint border,
		GLenum format,
		GLenum type,
		void *data);
重要
void glTexImage2D(GLenum target,
		GLint level,
		GLint internalformat,
		GLsizei width,
		GLsizei height,
		GLint border,
		GLenum format,
		GLenum type,
		void * data);

void glTexImage3D(GLenum target,
		GLint level,
		GLint internalformat,
		GLSizei width,
		GLsizei height,
		GLsizei depth,
		GLint border,
		GLenum format,
		GLenum type,
		void *data);
  • target: GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D。
  • Level: 指定所加载的mip贴图层次。⼀般我们都把这个参数设置为0。
  • internalformat: 每个纹理单元中存储多少颜⾊成分。
  • width、height、depth参数:指加载纹理的宽度、⾼度、深度。注意：这些值必须是2的整数次⽅。（这是因为OpenGL旧版本上的遗留下的⼀个要求。当然现在已经可以⽀持不是2的整数次⽅。但是开发者们还是习惯使⽤以2的整数次⽅去设置这些参数。）
  • border参数:允许为纹理贴图指定⼀个边界宽度。
  • format、type、data参数：与我们上面讲的glReadPixels函数参数相同，取值也按照两个表格来取。

3.4.更新纹理

void glCopyTexSubImage1D(GLenum target,
		GLint level,
		GLint xoffset,
		GLint x,
		GLint y,
		GLsizei width);

void glCopyTexSubImage2D(GLenum target,
		GLint level,
		GLint xoffset,
		GLint yOffset,
		GLint x,GLint y,
		GLsizei width,
		GLsizei height);

void glCopyTexSubImage3D(GLenum target,
		GLint level,
		GLint xoffset,
		GLint yOffset,
		GLint zOffset,
		GLint x,
		GLint y,
		GLsizei width,
		GLsizei height);

3.4.插入替换纹理

void glCopyTexSubImage1D(GLenum target,
		GLint level,
		GLint xoffset,
		GLint x,
		GLint y,
		GLsizei width);

void glCopyTexSubImage2D(GLenum target,
		GLint level,
		GLint xoffset,
		GLint yOffset,
		GLint x,
		GLint y,
		GLsizei width,
		GLsizei height);

void glCopyTexSubImage3D(GLenum target,
		GLint level,
		GLint xoffset,
		GLint yOffset,
		GLint zOffset,
		GLint x, 
		GLint y,
		GLsizei width,
		GLsizei height);

3.5.使⽤颜⾊缓存区加载数据,形成新的纹理使⽤

void glCopyTexImage1D(GLenum target,
		GLint level,
		GLenum internalformt,
		GLint x,
		GLint y,
		GLsizei width,
		GLint border);

void glCopyTexImage2D(GLenum target,
		GLint level,
		GLenum internalformt,
		GLint x,
		GLint y,
		GLsizei width,
		GLsizei height,
		GLint border);

在一张图片中，如果指定了(x,y)在颜色缓冲区中开始读取纹理数据的位置。在缓冲区中，是源数据通过glReadBuffer来这是的。注意:不存在glCopyTextImage3D，是因为无法从2D颜色缓冲区中获取体积。

4. 纹理对象

4.1.纹理对象

重要
//使⽤函数分配纹理对象
//指定纹理对象的数量 和 指针（指针指向⼀个⽆符号整形数组，由纹理对象标识符填充）。
void glGenTextures(GLsizei n, GLuint *textTures);

重要
//绑定纹理状态
//参数target:GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
//参数texture:需要绑定的纹理对象
void glBindTexture(GLenum target, GLunit texture);

//删除绑定纹理对象
//纹理对象 以及 纹理对象指针（指针指向⼀个⽆符号整形数组，由纹理对象标识符填充）。
void glDeleteTextures(GLsizei n, GLuint *textures);

//测试纹理对象是否有效
//如果texture是⼀个已经分配空间的纹理对象，那么这个函数会返回GL_TRUE,否则会返回GL_FALSE。
GLboolean glIsTexture(GLuint texture);

4.2.设置纹理参数

glTexParameterf(GLenum target,GLenum pname,GLFloat param);

glTexParameteri(GLenum target,GLenum pname,GLint param);

glTexParameterfv(GLenum target,GLenum pname,GLFloat *param);

glTexParameteriv(GLenum target,GLenum pname,GLint *param);

参数1:target, 指定这些参数将要应⽤在那个纹理模式上，⽐如GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D。
参数2:pname, 指定需要设置那个纹理参数
参数3:param, 设定特定的纹理参数的值

4.3.设置过滤方式

两种过滤方式：邻近过滤(GLNEAREST)，线性过滤(GL_LINEAR);

邻近过滤: 光标在哪里就返回那附近的颜色。

967ae7aaf90dd87f4aa06a978347f287.png
邻近过滤(GLNEAREST)

线性过滤：返回光标附近颜色的混合值。

052f1762b9de15939e106c38aef82b39.png
线性过滤(GL_LINEAR)

a777d2265edd915b25d5fa33af9e7f9e.png

纹理过滤方式的区别：左边是的图使用的是邻近过滤，可以看到有锯齿。右边的图采用的是线性过滤，看起来不那么突兀，比较的柔和和模糊。

4.4.纹理参数设置函数

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);// 纹理放⼤时,使⽤线性过滤

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

4.5.设置环绕方式

0cdb0e74a77bffeccac21127a94f8309.png
不同环绕方式

当纹理坐标超出默认范围时，每个选项就会呈现不同的效果输出：

c611036fe30a1f88d06bfd946e8ed76f.png
不同的效果输出 
// 设置环绕方式
glTextParameteri(GL_TEXTURE_2D,
		GL_TEXTURE_WRAR_S, // GL_TEXTURE_WRAR_S:X坐标，上面表格中的四种
		GL_CLAMP_TO_EDGE);
glTextParameteri(GL_TEXTURE_2D,
		GL_TEXTURE_WRAR_T, // GL_TEXTURE_WRAR_T: Y坐标，上面表格中的四种
		GL_CLAMP_TO_EDGE);
  • 参数1：GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
  • 参数2：GL_TEXTURE_WRAP_S、GL_TEXTURE_T、GL_TEXTURE_R,针对s,t,r坐标
  • 参数3：GL_REPEAT、GL_CLAMP、GL_CLAMP_TO_EDGE、GL_CLAMP_TO_BORDER
    • GL_REPEAT:OpenGL 在纹理坐标超过1.0的⽅向上对纹理进⾏重复；
    • GL_CLAMP:所需的纹理单元取⾃纹理边界或TEXTURE_BORDER_COLOR.
    • GL_CLAMP_TO_EDGE环绕模式强制对范围之外的纹理坐标沿着合法的纹理单元的最后⼀⾏或者最后⼀列来进⾏采样。
    • GL_CLAMP_TO_BORDER:在纹理坐标在0.0到1.0范围之外的只使⽤边界纹理单元。边界纹理单元是作为围绕基本图像的额外的⾏和列，并与基本纹理图像⼀起加载的。

5.纹理坐标

纹理坐标的范围是(0, 1)之间，更多指的是映射关系。

1351c45467812a365111e9fb7ec95c88.png
纹理坐标的范围

在笛卡尔坐标系中，我们使用x, y, z来表示一个顶点坐标。例如顶点A(1，2，3)。

但是在纹理坐标系中，使用s，t，r来表示坐标，它们是对应关系，s对应x，t对应y，r对应z。

在纹理坐标系中，默认左下角为(0，0)，右上角为(1，1)。

78d81a95fcef55c99715f708813ba580.png
正方形的纹理映射方式1

b5152af04f7b17225a02151270da9d4b.png
正方形的纹理映射方式2

6.Mip贴图

//设置mip贴图基层
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0);
//设置mip贴图最⼤层
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_BASE_LEVEL,0);

1571db45f9245a51d4d35ca6356a5749.png
经过Mip贴图的纹理过滤

7.案例

7.1.金字塔案例

71ccace185400e76f88b25d6621cbb9c.png

7.2.绘制三角形

//绘制金字塔
void MakePyramid(GLBatch& pyramidBatch) {
    /*1、通过pyramidBatch组建三角形批次
      参数1：类型
      参数2：顶点数
      参数3：这个批次中将会应用1个纹理
      注意：如果不写这个参数，默认为0。
     */
    pyramidBatch.Begin(GL_TRIANGLES, 18, 1);
    
    /***前情导入
     
     2)设置纹理坐标
     void MultiTexCoord2f(GLuint texture, GLclampf s, GLclampf t);
     参数1：texture，纹理层次，对于使用存储着色器来进行渲染，设置为0
     参数2：s：对应顶点坐标中的x坐标
     参数3：t:对应顶点坐标中的y
     (s,t,r,q对应顶点坐标的x,y,z,w)
     
     pyramidBatch.MultiTexCoord2f(0,s,t);
     
     3)void Vertex3f(GLfloat x, GLfloat y, GLfloat z);
      void Vertex3fv(M3DVector3f vVertex);
     向三角形批次类添加顶点数据(x,y,z);
      pyramidBatch.Vertex3f(-1.0f, -1.0f, -1.0f);
    
     */
    
    //塔顶
    M3DVector3f vApex = { 0.0f, 1.0f, 0.0f };
    M3DVector3f vFrontLeft = { -1.0f, -1.0f, 1.0f };
    M3DVector3f vFrontRight = { 1.0f, -1.0f, 1.0f };
    M3DVector3f vBackLeft = { -1.0f,  -1.0f, -1.0f };
    M3DVector3f vBackRight = { 1.0f,  -1.0f, -1.0f };
    
    //金字塔底部
    //底部的四边形 = 三角形X + 三角形Y
    //三角形X = (vBackLeft,vBackRight,vFrontRight)
    //vBackLeft
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackLeft);
    
    //vBackRight
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackRight);
    
    //vFrontRight
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
    pyramidBatch.Vertex3fv(vFrontRight);
    
    
    //三角形Y =(vFrontLeft,vBackLeft,vFrontRight)
    //vFrontLeft
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
    pyramidBatch.Vertex3fv(vFrontLeft);
    
    //vBackLeft
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackLeft);
    
    //vFrontRight
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
    pyramidBatch.Vertex3fv(vFrontRight);

    
    // 金字塔前面
    //三角形：（Apex，vFrontLeft，vFrontRight）
    pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
    pyramidBatch.Vertex3fv(vApex);

    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vFrontLeft);

    pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
    pyramidBatch.Vertex3fv(vFrontRight);
    
    //金字塔左边
    //三角形：（vApex, vBackLeft, vFrontLeft）
    pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
    pyramidBatch.Vertex3fv(vApex);
    
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackLeft);
    
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vFrontLeft);
    
    //金字塔右边
    //三角形：（vApex, vFrontRight, vBackRight）
    pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
    pyramidBatch.Vertex3fv(vApex);
    
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
    pyramidBatch.Vertex3fv(vFrontRight);

    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackRight);
    
    //金字塔后边
    //三角形：（vApex, vBackRight, vBackLeft）
    pyramidBatch.MultiTexCoord2f(0, 0.5f, 1.0f);
    pyramidBatch.Vertex3fv(vApex);
    
    pyramidBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackRight);
    
    pyramidBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
    pyramidBatch.Vertex3fv(vBackLeft);
    
    //结束批次设置
    pyramidBatch.End();
}

7.3.加载纹理

void SetupRC() {
    //1.清理颜色并初始化
    glClearColor(0.7, 0.7, 0.7, 1);
    shaderManager.InitializeStockShaders();
    
    //2.开启深度测试
    glEnable(GL_DEPTH_TEST);
    
    //3.分配纹理对象
    glGenTextures(1, &textureID);
    
    //4.绑定纹理 使用2D纹理
    glBindTexture(GL_TEXTURE_2D, textureID);
    
    //5.加载纹理
    //参数1：纹理文件名称
    //参数2&参数3：需要缩小&放大的过滤器
    //参数4：纹理坐标环绕模式
    LoadTAGTexture("brick.tga",
                   GL_LINEAR_MIPMAP_NEAREST,
                   GL_LINEAR,
                   GL_CLAMP_TO_EDGE);
    
    //6.创建金字塔
    MakePyramid(pyramidBatch);
    
    //7.向Z方向移动一点观察者
    cameraFrame.MoveForward(-10);
}

实现LoadTAGTexture函数

bool LoadTAGTexture(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.设置纹理参数
    //设置环绕模式 因为是2D所以只要s和t
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapMode);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapMode);
    
    //3.设置纹理的过滤方式
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
    
    //4.载入纹理
    /*
     //参数1：纹理维度
     //参数2：mip贴图层次
     //参数3：纹理单元存储的颜色成分（从读取像素图是获得）
     //参数4：加载纹理宽
     //参数5：加载纹理高
     //参数6：加载纹理的深度
     //参数7：像素数据的数据类型（GL_UNSIGNED_BYTE，每个颜色分量都是一个8位无符号整数）
     //参数8：指向纹理图像数据的指针
     */
    glTexImage2D(GL_TEXTURE_2D, 0,
                 nComponents, nWidth,
                 nHeight, 0, eFormat,
                 GL_UNSIGNED_BYTE,
                 pBits);
    free(pBits);
    
    // 客户端开发可以不用写
    //只有minFilter 等于以下四种模式，才可以生成Mip贴图
    //GL_NEAREST_MIPMAP_NEAREST具有非常好的性能，并且闪烁现象非常弱
    //GL_LINEAR_MIPMAP_NEAREST常常用于对游戏进行加速，它使用了高质量的线性过滤器
    //GL_LINEAR_MIPMAP_LINEAR 和GL_NEAREST_MIPMAP_LINEAR 过滤器在Mip层之间执行了一些额外的插值，以消除他们之间的过滤痕迹。
    //GL_LINEAR_MIPMAP_LINEAR 三线性Mip贴图。纹理过滤的黄金准则，具有最高的精度。
    if (minFilter == GL_LINEAR_MIPMAP_LINEAR ||
        minFilter == GL_LINEAR_MIPMAP_NEAREST ||
        minFilter == GL_NEAREST_MIPMAP_LINEAR ||
        minFilter == GL_NEAREST_MIPMAP_NEAREST) {
        //5.纹理生成所有的Mip层
        //参数：GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
        glGenerateMipmap(GL_TEXTURE_2D);
    }
    
    return true;
}

最终效果：

85a0bb168ec734cd562dc54a584d3229.gif
金字塔加上纹理图片

完整代码：

纹理-金字塔案例

8.隧道案例

实现隧道

在SetupRC里面画出隧道

void SetupRC() {
    //1.黑色的背景
     glClearColor(0.0f, 0.0f, 0.0f,1.0f);
     
     //2.初始化shaderManager
     shaderManager.InitializeStockShaders();
     
     GLbyte *pBytes;
     GLint iWidth, iHeight, iComponents;
     GLenum eFormat;
     GLint iLoop;

     //3.生成纹理标记
     /** 分配纹理对象 glGenTextures
      参数1：纹理对象的数量
      参数2：纹理对象标识数组
      */
     glGenTextures(TEXTURE_COUNT, textures);
     
     //4. 循环设置纹理数组的纹理参数
     for(iLoop = 0; iLoop < TEXTURE_COUNT; iLoop++)
     {
         /**绑定纹理对象 glBindTexture
          参数1：纹理模式，GL_TEXTURE_1D,GL_TEXTURE_2D,GL_TEXTURE_3D
          参数2：需要绑定的纹理对象
          */
         glBindTexture(GL_TEXTURE_2D, textures[iLoop]);
         
         /**加载tga文件
          参数1：纹理文件名称
          参数2：文件宽度变量地址
          参数3：文件高度变量地址
          参数4：文件组件变量地址
          参数5：文件格式变量地址
          返回值：pBytes，指向图像数据的指针
          */
         
         pBytes = gltReadTGABits(szTextureFiles[iLoop],&iWidth, &iHeight,
                                 &iComponents, &eFormat);
         
         //加载纹理、设置过滤器和包装模式
         //GL_TEXTURE_MAG_FILTER（放大过滤器,GL_NEAREST(最邻近过滤)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
         //GL_TEXTURE_MIN_FILTER(缩小过滤器),GL_NEAREST(最邻近过滤)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
         //GL_TEXTURE_WRAP_S(s轴环绕),GL_CLAMP_TO_EDGE(环绕模式强制对范围之外的纹理坐标沿着合法的纹理单元的最后一行或一列进行采样)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         //GL_TEXTURE_WRAP_T(t轴环绕)，GL_CLAMP_TO_EDGE(环绕模式强制对范围之外的纹理坐标沿着合法的纹理单元的最后一行或一列进行采样)
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
         
         
         /**载入纹理 glTexImage2D
          参数1：纹理维度，GL_TEXTURE_2D
          参数2：mip贴图层次
          参数3：纹理单元存储的颜色成分（从读取像素图中获得）
          参数4：加载纹理宽度
          参数5：加载纹理的高度
          参数6：加载纹理的深度
          参数7：像素数据的数据类型,GL_UNSIGNED_BYTE无符号整型
          参数8：指向纹理图像数据的指针
          */
         glTexImage2D(GL_TEXTURE_2D, 0, iComponents, iWidth, iHeight, 0, eFormat, GL_UNSIGNED_BYTE, pBytes);
         
             /**为纹理对象生成一组完整的mipmap glGenerateMipmap
              参数1：纹理维度，GL_TEXTURE_1D,GL_TEXTURE_2D,GL_TEXTURE_2D
              */
             glGenerateMipmap(GL_TEXTURE_2D);
         
             //释放原始纹理数据，不在需要纹理原始数据了
             free(pBytes);
     }
     
     //5. 设置几何图形顶点/纹理坐标(上.下.左.右)
     GLfloat z;
     
     /*
      GLTools库中的容器类，GBatch，
      void GLBatch::Begin(GLenum primitive,GLuint nVerts,GLuint nTextureUnits = 0);
      参数1：图元枚举值
      参数2：顶点数
      参数3：1组或者2组纹理坐标
      */
     
     floorBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
     //参考PPT图6-10
     //Z表示深度，隧道的深度
     for(z = 60.0f; z >= 0.0f; z -=10.0f)
     {
         floorBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
         floorBatch.Vertex3f(-10.0f, -10.0f, z);
         
         floorBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
         floorBatch.Vertex3f(10.0f, -10.0f, z);
         
         floorBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
         floorBatch.Vertex3f(-10.0f, -10.0f, z - 10.0f);
         
         floorBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
         floorBatch.Vertex3f(10.0f, -10.0f, z - 10.0f);
     }
     floorBatch.End();
    
    //参考PPT图6-11
     ceilingBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
     for(z = 60.0f; z >= 0.0f; z -=10.0f)
     {
         ceilingBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
         ceilingBatch.Vertex3f(-10.0f, 10.0f, z - 10.0f);
         
         ceilingBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
         ceilingBatch.Vertex3f(10.0f, 10.0f, z - 10.0f);
         
         ceilingBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
         ceilingBatch.Vertex3f(-10.0f, 10.0f, z);
         
         ceilingBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
         ceilingBatch.Vertex3f(10.0f, 10.0f, z);
     }
     ceilingBatch.End();
     
     //参考PPT图6-12
     leftWallBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
     for(z = 60.0f; z >= 0.0f; z -=10.0f)
     {
         leftWallBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
         leftWallBatch.Vertex3f(-10.0f, -10.0f, z);
         
         leftWallBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
         leftWallBatch.Vertex3f(-10.0f, 10.0f, z);
         
         leftWallBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
         leftWallBatch.Vertex3f(-10.0f, -10.0f, z - 10.0f);
         
         leftWallBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
         leftWallBatch.Vertex3f(-10.0f, 10.0f, z - 10.0f);
     }
     leftWallBatch.End();
    
    //参考PPT图6-13
     rightWallBatch.Begin(GL_TRIANGLE_STRIP, 28, 1);
     for(z = 60.0f; z >= 0.0f; z -=10.0f)
     {
         rightWallBatch.MultiTexCoord2f(0, 0.0f, 0.0f);
         rightWallBatch.Vertex3f(10.0f, -10.0f, z);
         
         rightWallBatch.MultiTexCoord2f(0, 0.0f, 1.0f);
         rightWallBatch.Vertex3f(10.0f, 10.0f, z);
         
         rightWallBatch.MultiTexCoord2f(0, 1.0f, 0.0f);
         rightWallBatch.Vertex3f(10.0f, -10.0f, z - 10.0f);
         
         rightWallBatch.MultiTexCoord2f(0, 1.0f, 1.0f);
         rightWallBatch.Vertex3f(10.0f, 10.0f, z - 10.0f);
     }
     rightWallBatch.End();
}

在RenderScene实现

//召唤场景
void RenderScene(void) {
    //1.用当前清除色，清除窗口
    glClear(GL_COLOR_BUFFER_BIT);
    
    //2.模型视图压栈
    modelViewMatrix.PushMatrix();
    //Z轴平移viewZ 距离
    modelViewMatrix.Translate(0.0f, 0.0f, viewZ);
    
    //3.纹理替换矩阵着色器
    /*
     参数1：GLT_SHADER_TEXTURE_REPLACE（着色器标签）
     参数2：模型视图投影矩阵
     参数3：纹理层
     */
    shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE, transformPipeline.GetModelViewProjectionMatrix(), 0);
    
    //4.绑定纹理
    /*
     参数1：纹理模式，GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
     参数2：需要绑定的纹理
     */
    glBindTexture(GL_TEXTURE_2D, textures[TEXTURE_FLOOR]);
    floorBatch.Draw();
    
    glBindTexture(GL_TEXTURE_2D, textures[TEXTURE_CEILING]);
    ceilingBatch.Draw();
    
    glBindTexture(GL_TEXTURE_2D, textures[TEXTURE_BRICK]);
    leftWallBatch.Draw();
    rightWallBatch.Draw();
    
    //5.pop
    modelViewMatrix.PopMatrix();
    
    //6.缓存区交换
    glutSwapBuffers();
}

完整效果:

隧道效果​github.com

完整代码:

纹理-隧道案例

大球小球案例

现在我们把上一节中的综合案例的大球和小球都加上纹理。上一篇文章的地址：

GhostClock：OpenGL学习笔记(七)-综合案例​zhuanlan.zhihu.com
184eb70bb28e36c9d68c214d3feb7b31.png

在SetupRC里面实现

void SetupRC() {
    //1.设置清屏颜色到颜色缓存区
     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     
     //2.初始化着色器管理器
     shaderManager.InitializeStockShaders();
     
     //3.开启深度测试/背面剔除
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_CULL_FACE);

     //4.设置大球球
     gltMakeSphere(torusBatch, 0.4f, 40, 80);
     
     //5.设置小球(公转自转)
     gltMakeSphere(sphereBatch, 0.1f, 26, 13);
     
     //6.设置地板顶点数据&地板纹理
     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();
     
     //7.随机小球球顶点坐标数据
     for (int i = 0; i < NUM_MIN_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);
     }
     
     
     //8.命名纹理对象
     glGenTextures(3, uiTextures);
     
     //9.将TGA文件加载为2D纹理。
     //参数1：纹理文件名称
     //参数2&参数3：需要缩小&放大的过滤器
     //参数4：纹理坐标环绕模式
     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函数

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);
    
    //只有minFilter 等于以下四种模式，才可以生成Mip贴图
    //GL_NEAREST_MIPMAP_NEAREST具有非常好的性能，并且闪烁现象非常弱
    //GL_LINEAR_MIPMAP_NEAREST常常用于对游戏进行加速，它使用了高质量的线性过滤器
    //GL_LINEAR_MIPMAP_LINEAR 和GL_NEAREST_MIPMAP_LINEAR 过滤器在Mip层之间执行了一些额外的插值，以消除他们之间的过滤痕迹。
    //GL_LINEAR_MIPMAP_LINEAR 三线性Mip贴图。纹理过滤的黄金准则，具有最高的精度。
    if(minFilter == GL_LINEAR_MIPMAP_LINEAR ||
       minFilter == GL_LINEAR_MIPMAP_NEAREST ||
       minFilter == GL_NEAREST_MIPMAP_LINEAR ||
       minFilter == GL_NEAREST_MIPMAP_NEAREST)
    //4.加载Mip,纹理生成所有的Mip层
    //参数：GL_TEXTURE_1D、GL_TEXTURE_2D、GL_TEXTURE_3D
    glGenerateMipmap(GL_TEXTURE_2D);
    
    
    return true;
}

在RenderScene函数里面

//召唤场景
void RenderScene(void) {
    //1.地板颜色值
      static GLfloat vFloorColor[] = { 1.0f, 1.0f, 0.0f, 0.75f};
      
      //2.基于时间动画
      static CStopWatch    rotTimer;
      float yRot = rotTimer.GetElapsedSeconds() * 60.0f;
      
      //3.清除颜色缓存区和深度缓冲区
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      
      //4.压入栈(栈顶)
      modelViewMatrix.PushMatrix();
      
      //5.设置观察者矩阵
      M3DMatrix44f mCamera;
      cameraFrame.GetCameraMatrix(mCamera);
      modelViewMatrix.MultMatrix(mCamera);
      
      //6.压栈(镜面)
      modelViewMatrix.PushMatrix();
      
      //7.---添加反光效果---
      //翻转Y轴
      modelViewMatrix.Scale(1.0f, -1.0f, 1.0f);
      //镜面世界围绕Y轴平移一定间距
      modelViewMatrix.Translate(0.0f, 0.8f, 0.0f);
      
      //8.指定顺时针为正面
      glFrontFace(GL_CW);
    
      //9.绘制地面以外其他部分(镜面)
      drawOther(yRot);
     
      //10.恢复为逆时针为正面
      glFrontFace(GL_CCW);
      
      //11.绘制镜面，恢复矩阵
      modelViewMatrix.PopMatrix();
      
      //12.开启混合功能(绘制地板)
      glEnable(GL_BLEND);
      //13. 指定glBlendFunc 颜色混合方程式
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
      
      //14.绑定地面纹理
      glBindTexture(GL_TEXTURE_2D, uiTextures[0]);
      
      /*15.
       纹理调整着色器(将一个基本色乘以一个取自纹理的单元nTextureUnit的纹理)
       参数1：GLT_SHADER_TEXTURE_MODULATE
       参数2：模型视图投影矩阵
       参数3：颜色
       参数4：纹理单元（第0层的纹理单元）
       
       */
      shaderManager.UseStockShader(GLT_SHADER_TEXTURE_MODULATE,
                                   transformPipeline.GetModelViewProjectionMatrix(),
                                   vFloorColor,
                                   0);
      //shaderManager.UseStockShader(GLT_SHADER_TEXTURE_REPLACE,transformPipeline.GetModelViewProjectionMatrix(),0);
      
      //开始绘制
      floorBatch.Draw();
      //取消混合
      glDisable(GL_BLEND);
      
      //16.绘制地面以外其他部分
      drawOther(yRot);
      
      //17.绘制完，恢复矩阵
      modelViewMatrix.PopMatrix();
      
      //18.交换缓存区
      glutSwapBuffers();
      
      //19.提交重新渲染
      glutPostRedisplay();
}

并实现drawOther函数

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

最终效果:

93f8bf3837c52cecf0c923cc03dad672.gif
纹理-大球小球案例

完整代码:

纹理-大球小球案例

weixin_39925813
关注
八、OpenTK中的纹理操作(万字详细教程)
仰望星空的博客
08-21 705
  在图形渲染中，纹理可以从图像文件加载。通常使用图像处理库来读取图像文件的像素数据，并将其上传到 GPU 作为纹理。在 C# 中，可以使用一些第三方库（如 System.Drawing.Common 或 SixLabors.ImageSharp）来读取图像文件。首先，读取图像文件并获取其像素数据。然后，创建一个纹理对象，并使用 GL.TexImage2D 函数将像素数据上传到 GPU。同时，需要设置纹理的参数，如过滤模式和环绕模式。   以下是一个从 PNG 图像文件加载纹理的 C# 示例代码： （二）生
OpenGL + Qt 导入OBJ模型
chen_da_le的博客
11-30 3151
1，打开QT，创建QMainWindow工程2，打开工程的.pro文件，添加以下代码3，打开工程界面，创建新的类并继承QOpenGLWidget和QOpenGLFunctions_3_3_Core提供了显示集成到Qt应用程序中的OpenGL图形的功能，提供三个虚函数：1）paintGL()：渲染OpenGL场景。每当需要更新小部件时调用。2）resizeGL ()：设置OpenGL视区、投影等。
OpenGL一个室内三维渲染（OBJ文件导入和贴图）
02-12
视角可移动，旋转的房间简单三维场景，有灯光，有阴影，导入OBJ文件，有纹理贴图，对于初学者还是比较好的，简单易懂
opengl测试_opengl读取obj文件_openglobj_
09-30
opengl和c++实现显示列表存取obj文件并绘制
opengl读取obj文件
09-04
opengl读取obj文件，简单小程序~~希望对初学opengl的大家有所帮助~~
opengl加载并渲染obj模型文件（含纹理）
03-11
1. 环境win7 + qt5.3.1 WinGW 32bit 2. 使用glm 3. 使用孙启功的方法 4. 网上下载的obj模型文件 5. 我仅仅是用别人的方法和文件进行了简单的实践 6. 因为工作需要，搜索一番不容易找到有用的东西，所以在此留个备份
opengl读取OBJ模型文件
热门推荐
yz960611的博客
02-25 1万+
原文地址：  http://blog.sina.com.cn/s/blog_6db61ebf01017325.html 要顺利读取obj模型文件，先要了解obj文件的格式。OBJ文件格式是非常简单的，它以纯文本的形式存储了模型的顶点、法线和纹理坐标和材质使用信息。 OBJ文件的每行的格式如下：前缀 参数1 参数2 参数3 ... 其中，前缀标识了
兔子obj模型
04-25
兔子三维obj模型，可以直接导入OpenGL。
opengl 3d obj模型加载，贴图
12-13
添加附加依赖库，和模型图片资源，以及模型obj文件。使用opengl库3d呈现以及贴图。obj文件初步解析
OpenGl读取obj格式文件
06-02
可以通过OPENGL打开obj格式的文件，运行之后按“o”或者“O”选择相应的obj文件，按小键盘的“+”和“-”放大缩小图像
OpenGL学习笔记20-Model
wangxingxing321的博客
07-29 369
Model Model-Loading/Model 现在是时候着手使用Assimp并开始创建实际的加载和转换代码了。本章的目标是创建另一个类来代表一个完整的模型，也就是说，一个包含多个网格，可能有多个纹理的模型。一所房子，包括一个木制阳台，一个塔，也许还有一个游泳池，仍然可以作为一个单一的模型加载。我们将通过Assimp加载模型，并将其转换为我们在前一章中创建的多个网格对象。 闲话少说，我给你展示了模型类的类结构: class Model { public: Model
OpenGL读取obj文件，C++
10-31
C++写的一个简单的读取obj文件的程序
OPENGL 读取和显示OBJ文件
07-02
OPENGL读取和现实OBJ文件，C/C++,VC6里面编译成功,
opengl 读取与显示obj文件
12-23
使用trackball和glm，可以读取和显示obj文件，并进行旋转与缩放。运行环境：vs2010， 运行后用o或者O选择obj文件，+和-进行缩放
以obj格式组织的建筑物，利用opengl读取解析并实现可视化，可以实现纹理贴图
12-15
之前写过一个简单的可以读取obj建筑物的代码，自己一直被纹理这块困扰，最近几天研究了一下，终于搞出来了。
OpenGL读写obj文件
09-14
opengl入门程序，读写obj文件，并实现旋转等功能
OpenGL GLFW PMX模型 骨骼 学习笔记 m8w3
最新发布
awsl_tsl的博客
08-16 741
之前的文章中，实现了顶点，纹理和材质。接下来还剩骨骼，变形以及DisplayFrame。
OpenGL学习笔记（六）-模型加载
Catog的博客
04-15 815
参考网址：LearnOpenGL 中文版 哔哩哔哩教程 第三章 模型加载 3.1 Assimp 1、Assimp能够导入多种模型文件格式，将所有的模型数据加载至Assimp的通用数据结构中，我们就能够从Assimp的数据结构中提取我们所需的所有数据了。 2、Assimp会将整个模型加载进一个场景对象，场景对象中包含一系列的节点，每个节点包含了场景对象中所储存数据的索引，每个节点都可以有任意数量的子节点。（图中左半边） 场景的根节点含子节点，子节点中有一系列指向场景对象中mMeshes数组中储存的网格数据的
[迁移]opengl学习从头开始（笔记9 自定义模型数据的读取）
晓清风兮
01-31 246
声明：因网易博客将关闭，移到此 /** 这里使用到的是opengl 和 glut 进行编写学习的笔记，一个简单的出口 使用到的开发库有 linux (gl glu glut) windows(opengl32.lib glu32.lib glut32.lib) 实现:这里主要说的是如何读取简单的外部模型数据文件(这个文件可以是大家自己定制的一种格式) 这个...
opengl obj纹理贴图
12-10
使用OpenGL加载和渲染.obj文件中的纹理贴图需要以下步骤： 1. 导入.obj文件：可以使用第三方库，如Assimp，来读取和解析.obj文件。这将提供模型的顶点、法线、纹理坐标和面信息。 2. 加载纹理图像：使用OpenGL的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值