opengl 关于纹理贴图

最新推荐文章于 2023-02-26 16:15:42 发布
最新推荐文章于 2023-02-26 16:15:42 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： Opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010388497/article/details/41597207
版权

网上的大部分是根据输入图像的，但是我要弄得是根据程序生成纹理贴图


好了，开始


第一个是关于根据程序生成的纹理贴图的棋盘


#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>

/*	Create checkerboard texture	*/
#define	checkImageWidth 64
#define	checkImageHeight 64
static GLubyte checkImage[checkImageHeight][checkImageWidth][4];

#ifdef GL_VERSION_1_1
static GLuint texName;
#endif
//绘制棋盘
void makeCheckImage(void)
{
   int i, j, c;
    
   for (i = 0; i < checkImageHeight; i++) {
      for (j = 0; j < checkImageWidth; j++) {
         c = ((((i&0x8)==0)^((j&0x8))==0))*255;
         checkImage[i][j][0] = (GLubyte) c;
         checkImage[i][j][1] = (GLubyte) c;
         checkImage[i][j][2] = (GLubyte) c;
         checkImage[i][j][3] = (GLubyte) 255;
      }
   }
}
//纹理贴图的初始化
void init(void)
{    
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel(GL_FLAT);
   glEnable(GL_DEPTH_TEST);   //开启深度测试
    
   makeCheckImage();   //绘制棋盘
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);  //描述位图数据在计算机内存中的存储方式

#ifdef GL_VERSION_1_1
   glGenTextures(1, &texName);    //命名纹理对象名
   glBindTexture(GL_TEXTURE_2D, texName);  //创建纹理对象
#endif

   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
#ifdef GL_VERSION_1_1
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, checkImageHeight, 
                0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);//生成指定的纹理
#else
   glTexImage2D(GL_TEXTURE_2D, 0, 4, checkImageWidth, checkImageHeight, 
                0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);
#endif
}

void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glEnable(GL_TEXTURE_2D);   //开启2d纹理
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);//设置像素界别
#ifdef GL_VERSION_1_1
   glBindTexture(GL_TEXTURE_2D, texName);
#endif

   glBegin(GL_QUADS);
   //显示的分配的纹理坐标
   glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0);
   glTexCoord2f(0.0, 1.0); glVertex3f(-2.0, 1.0, 0.0);
   glTexCoord2f(1.0, 1.0); glVertex3f(0.0, 1.0, 0.0);
   glTexCoord2f(1.0, 0.0); glVertex3f(0.0, -1.0, 0.0);

  /* glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0);
   glTexCoord2f(0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
   glTexCoord2f(1.0, 1.0); glVertex3f(2.41421, 1.0, -1.41421);
   glTexCoord2f(1.0, 0.0); glVertex3f(2.41421, -1.0, -1.41421);*/
   glEnd();
   glFlush();
   glDisable(GL_TEXTURE_2D);  //关闭2d纹理
}

void reshape(int w, int h)
{
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 30.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glTranslatef(0.0, 0.0, -3.6);
}

void keyboard (unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
      default:
         break;
   }
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize(250, 250);
   glutInitWindowPosition(100, 100);
   glutCreateWindow(argv[0]);
   init();
   glutDisplayFunc(display);
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0; 
}


第2个是在主纹理中创建一个子纹理


//#include <GL/glut.h>
//#include <stdlib.h>
//#include <stdio.h>
//
///*	Create checkerboard texture	*/
//#define	checkImageWidth 64
//#define	checkImageHeight 64
//static GLubyte checkImage[checkImageHeight][checkImageWidth][4];
//
//#ifdef GL_VERSION_1_1
//static GLuint texName;
//#endif
绘制棋盘
//void makeCheckImage(void)
//{
//   int i, j, c;
//    
//   for (i = 0; i < checkImageHeight; i++) {
//      for (j = 0; j < checkImageWidth; j++) {
//         c = ((((i&0x8)==0)^((j&0x8))==0))*255;
//         checkImage[i][j][0] = (GLubyte) c;
//         checkImage[i][j][1] = (GLubyte) c;
//         checkImage[i][j][2] = (GLubyte) c;
//         checkImage[i][j][3] = (GLubyte) 255;
//      }
//   }
//}
纹理贴图的初始化
//void init(void)
//{    
//   glClearColor (0.0, 0.0, 0.0, 0.0);
//   glShadeModel(GL_FLAT);
//   glEnable(GL_DEPTH_TEST);   //开启深度测试
//    
//   makeCheckImage();   //绘制棋盘
//   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);  //描述位图数据在计算机内存中的存储方式
//
//#ifdef GL_VERSION_1_1
//   glGenTextures(1, &texName);    //命名纹理对象名
//   glBindTexture(GL_TEXTURE_2D, texName);  //创建纹理对象
//#endif
//
//   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
//   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
//   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
//#ifdef GL_VERSION_1_1
//   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, checkImageHeight, 
//                0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);//生成指定的纹理
//#else
//   glTexImage2D(GL_TEXTURE_2D, 0, 4, checkImageWidth, checkImageHeight, 
//                0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);
//#endif
//}
//
//void display(void)
//{
//   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//   glEnable(GL_TEXTURE_2D);   //开启2d纹理
//   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);//设置像素界别
//#ifdef GL_VERSION_1_1
//   glBindTexture(GL_TEXTURE_2D, texName);
//#endif
//
//   glBegin(GL_QUADS);
//   //显示的分配的纹理坐标
//   glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0);
//   glTexCoord2f(0.0, 1.0); glVertex3f(-2.0, 1.0, 0.0);
//   glTexCoord2f(1.0, 1.0); glVertex3f(0.0, 1.0, 0.0);
//   glTexCoord2f(1.0, 0.0); glVertex3f(0.0, -1.0, 0.0);
//
//  /* glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0);
//   glTexCoord2f(0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
//   glTexCoord2f(1.0, 1.0); glVertex3f(2.41421, 1.0, -1.41421);
//   glTexCoord2f(1.0, 0.0); glVertex3f(2.41421, -1.0, -1.41421);*/
//   glEnd();
//   glFlush();
//   glDisable(GL_TEXTURE_2D);  //关闭2d纹理
//}
//
//void reshape(int w, int h)
//{
//   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
//   glMatrixMode(GL_PROJECTION);
//   glLoadIdentity();
//   gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 30.0);
//   glMatrixMode(GL_MODELVIEW);
//   glLoadIdentity();
//   glTranslatef(0.0, 0.0, -3.6);
//}
//
//void keyboard (unsigned char key, int x, int y)
//{
//   switch (key) {
//      case 27:
//         exit(0);
//         break;
//      default:
//         break;
//   }
//}
//
//int main(int argc, char** argv)
//{
//   glutInit(&argc, argv);
//   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
//   glutInitWindowSize(250, 250);
//   glutInitWindowPosition(100, 100);
//   glutCreateWindow(argv[0]);
//   init();
//   glutDisplayFunc(display);
//   glutReshapeFunc(reshape);
//   glutKeyboardFunc(keyboard);
//   glutMainLoop();
//   return 0; 
//}

#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>

#ifdef GL_VERSION_1_1
/*  Create checkerboard textures  */
#define checkImageWidth 64
#define checkImageHeight 64
#define subImageWidth 16
#define subImageHeight 16
static GLubyte checkImage[checkImageHeight][checkImageWidth][4];
static GLubyte subImage[subImageHeight][subImageWidth][4];

static GLuint texName;
//绘制棋盘
void makeCheckImages(void)
{
   int i, j, c;
    
   for (i = 0; i < checkImageHeight; i++) {
      for (j = 0; j < checkImageWidth; j++) {
         c = ((((i&0x8)==0)^((j&0x8))==0))*255;
         checkImage[i][j][0] = (GLubyte) c;
         checkImage[i][j][1] = (GLubyte) c;
         checkImage[i][j][2] = (GLubyte) c;
         checkImage[i][j][3] = (GLubyte) 255;
      }
   }
   //绘制子纹理
   for (i = 0; i < subImageHeight; i++) {
      for (j = 0; j < subImageWidth; j++) {
         c = ((((i&0x4)==0)^((j&0x4))==0))*255;
         subImage[i][j][0] = (GLubyte) c;
         subImage[i][j][1] = (GLubyte) 0;
         subImage[i][j][2] = (GLubyte) 0;
         subImage[i][j][3] = (GLubyte) 255;
      }
   }
}
//纹理的初始化
void init(void)
{    
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel(GL_FLAT);
   glEnable(GL_DEPTH_TEST);

   makeCheckImages();
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

   glGenTextures(1, &texName);//命名纹理
   glBindTexture(GL_TEXTURE_2D, texName);  //创建纹理对象

   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);   //设置s方向的重复纹理
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);    //设置t方向的重复纹理
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);  //过滤（放大或者缩小）
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, checkImageHeight,   //定义一个2维纹理
                0, GL_RGBA, GL_UNSIGNED_BYTE, checkImage);
}

void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glEnable(GL_TEXTURE_2D);  //开启
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);   //设置当前的纹理函数
   glBindTexture(GL_TEXTURE_2D, texName);  //创建纹理对象
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0);  //纹理对象和屏幕坐标进行匹配
   glTexCoord2f(0.0, 1.0); glVertex3f(-2.0, 1.0, 0.0);
   glTexCoord2f(1.0, 1.0); glVertex3f(0.0, 1.0, 0.0);
   glTexCoord2f(1.0, 0.0); glVertex3f(0.0, -1.0, 0.0);

   glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0);
   glTexCoord2f(0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
   glTexCoord2f(1.0, 1.0); glVertex3f(2.41421, 1.0, -1.41421);
   glTexCoord2f(1.0, 0.0); glVertex3f(2.41421, -1.0, -1.41421);
   glEnd();
   glFlush();
   glDisable(GL_TEXTURE_2D);
}

void reshape(int w, int h)
{
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 30.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glTranslatef(0.0, 0.0, -3.6);
}

void keyboard (unsigned char key, int x, int y)
{
   switch (key) {
      case 's':
      case 'S':
         glBindTexture(GL_TEXTURE_2D, texName);    //创建纹理对象
         glTexSubImage2D(GL_TEXTURE_2D, 0, 12, 44, subImageWidth,
                         subImageHeight, GL_RGBA,
                         GL_UNSIGNED_BYTE, subImage);   //定义一个子纹理
         glutPostRedisplay();
         break;
      case 'r':
      case 'R':
         glBindTexture(GL_TEXTURE_2D, texName);
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth,
                      checkImageHeight, 0, GL_RGBA,
                      GL_UNSIGNED_BYTE, checkImage);  //恢复到主纹理
         glutPostRedisplay();
         break;
      case 27:
         exit(0);
         break;
      default:
         break;
   }
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize(250, 250);
   glutInitWindowPosition(100, 100);
   glutCreateWindow(argv[0]);
   init();
   glutDisplayFunc(display);
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0; 
}
#else
int main(int argc, char** argv)
{
    fprintf (stderr, "This program demonstrates a feature which is not in OpenGL Version 1.0.\n");
    fprintf (stderr, "If your implementation of OpenGL Version 1.0 has the right extensions,\n");
    fprintf (stderr, "you may be able to modify this program to make it run.\n");
    return 0;
}
#endif


第三个纹理代码是：利用minmap


#include <gl/glut.h>
#include <stdlib.h>

GLubyte mipmapImage32[32][32][4];
GLubyte mipmapImage16[16][16][4];
GLubyte mipmapImage8[8][8][4];
GLubyte mipmapImage4[4][4][4];
GLubyte mipmapImage2[2][2][4];
GLubyte mipmapImage1[1][1][4];

#ifdef GL_VERSION_1_1
static GLuint texName;
#endif

void makeImages(void)
{
   int i, j;
    
   for (i = 0; i < 32; i++) {
      for (j = 0; j < 32; j++) {
         mipmapImage32[i][j][0] = 255;
         mipmapImage32[i][j][1] = 255;
         mipmapImage32[i][j][2] = 0;
         mipmapImage32[i][j][3] = 255;
      }
   }
   for (i = 0; i < 16; i++) {
      for (j = 0; j < 16; j++) {
         mipmapImage16[i][j][0] = 255;
         mipmapImage16[i][j][1] = 0;
         mipmapImage16[i][j][2] = 255;
         mipmapImage16[i][j][3] = 255;
      }
   }
   for (i = 0; i < 8; i++) {
      for (j = 0; j < 8; j++) {
         mipmapImage8[i][j][0] = 255;
         mipmapImage8[i][j][1] = 0;
         mipmapImage8[i][j][2] = 0;
         mipmapImage8[i][j][3] = 255;
      }
   }
   for (i = 0; i < 4; i++) {
      for (j = 0; j < 4; j++) {
         mipmapImage4[i][j][0] = 0;
         mipmapImage4[i][j][1] = 255;
         mipmapImage4[i][j][2] = 0;
         mipmapImage4[i][j][3] = 255;
      }
   }
   for (i = 0; i < 2; i++) {
      for (j = 0; j < 2; j++) {
         mipmapImage2[i][j][0] = 0;
         mipmapImage2[i][j][1] = 0;
         mipmapImage2[i][j][2] = 255;
         mipmapImage2[i][j][3] = 255;
      }
   }
   mipmapImage1[0][0][0] = 255;
   mipmapImage1[0][0][1] = 255;
   mipmapImage1[0][0][2] = 255;
   mipmapImage1[0][0][3] = 255;
}

void init(void)
{    
   glEnable(GL_DEPTH_TEST);
   glShadeModel(GL_FLAT);

   glTranslatef(0.0, 0.0, -3.6);
   makeImages();
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

#ifdef GL_VERSION_1_1
   glGenTextures(1, &texName);
   glBindTexture(GL_TEXTURE_2D, texName);
#endif
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
                   GL_NEAREST_MIPMAP_NEAREST);

   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, mipmapImage32);
   glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA, 16, 16, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, mipmapImage16);
   glTexImage2D(GL_TEXTURE_2D, 2, GL_RGBA, 8, 8, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, mipmapImage8);
   glTexImage2D(GL_TEXTURE_2D, 3, GL_RGBA, 4, 4, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, mipmapImage4);
   glTexImage2D(GL_TEXTURE_2D, 4, GL_RGBA, 2, 2, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, mipmapImage2);
   glTexImage2D(GL_TEXTURE_2D, 5, GL_RGBA, 1, 1, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, mipmapImage1);

   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
   glEnable(GL_TEXTURE_2D);
}

void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
#ifdef GL_VERSION_1_1
   glBindTexture(GL_TEXTURE_2D, texName);
#endif
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0);
   glTexCoord2f(0.0, 8.0); glVertex3f(-2.0, 1.0, 0.0);
   glTexCoord2f(8.0, 8.0); glVertex3f(2000.0, 1.0, -6000.0);
   glTexCoord2f(8.0, 0.0); glVertex3f(2000.0, -1.0, -6000.0);
   glEnd();
   glFlush();
}

void reshape(int w, int h)
{
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluPerspective(60.0, (GLfloat)w/(GLfloat)h, 1.0, 30000.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

void keyboard (unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
      default:
         break;
   }
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (500, 500);
   glutInitWindowPosition (50, 50);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display);
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutMainLoop();
   return 0;     
}



第四个代码是：绘制两个不同的纹理对象（棋盘）


#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>

#ifdef GL_VERSION_1_1
/*	Create checkerboard texture	*/
#define	checkImageWidth 64
#define	checkImageHeight 64
static GLubyte checkImage[checkImageHeight][checkImageWidth][4];
static GLubyte otherImage[checkImageHeight][checkImageWidth][4];

static GLuint texName[2];
//绘制两个棋盘
void makeCheckImages(void)
{
   int i, j, c;
    
   for (i = 0; i < checkImageHeight; i++) {
      for (j = 0; j < checkImageWidth; j++) {
         c = ((((i&0x8)==0)^((j&0x8))==0))*255;
         checkImage[i][j][0] = (GLubyte) c;
         checkImage[i][j][1] = (GLubyte) c;
         checkImage[i][j][2] = (GLubyte) c;
         checkImage[i][j][3] = (GLubyte) 255;

         c = ((((i&0x10)==0)^((j&0x10))==0))*255;
         otherImage[i][j][0] = (GLubyte) c;
         otherImage[i][j][1] = (GLubyte) 0;
         otherImage[i][j][2] = (GLubyte) 0;
         otherImage[i][j][3] = (GLubyte) 255;
      }
   }
}
//创建两个纹理对象
void init(void)
{    
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel(GL_FLAT);
   glEnable(GL_DEPTH_TEST);

   makeCheckImages();
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

   glGenTextures(2, texName);  //命名纹理
   //创建第1个纹理对象
   glBindTexture(GL_TEXTURE_2D, texName[0]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, 
                   GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, 
                   GL_NEAREST);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth,
                checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                checkImage);
   //创建第2个纹理对象
   glBindTexture(GL_TEXTURE_2D, texName[1]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, 
                checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 
                otherImage);
   glEnable(GL_TEXTURE_2D);
}
//绘制纹理贴图的棋盘
void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   //绘制第一个棋盘
   glBindTexture(GL_TEXTURE_2D, texName[0]);
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0); glVertex3f(-2.0, -1.0, 0.0);
   glTexCoord2f(0.0, 1.0); glVertex3f(-2.0, 1.0, 0.0);
   glTexCoord2f(1.0, 1.0); glVertex3f(0.0, 1.0, 0.0);
   glTexCoord2f(1.0, 0.0); glVertex3f(0.0, -1.0, 0.0);
   glEnd();
   //绘制第2个棋盘
   glBindTexture(GL_TEXTURE_2D, texName[1]);
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0);
   glTexCoord2f(0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
   glTexCoord2f(1.0, 1.0); glVertex3f(2.41421, 1.0, -1.41421);
   glTexCoord2f(1.0, 0.0); glVertex3f(2.41421, -1.0, -1.41421);
   glEnd();
   glFlush();
}

void reshape(int w, int h)
{
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 30.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glTranslatef(0.0, 0.0, -3.6);
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
   }
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize(250, 250);
   glutInitWindowPosition(100, 100);
   glutCreateWindow(argv[0]);
   init();
   glutReshapeFunc(reshape);
   glutDisplayFunc(display);
   glutKeyboardFunc (keyboard);
   glutMainLoop();
   return 0; 
}
#else
int main(int argc, char** argv)
{
    fprintf (stderr, "This program demonstrates a feature which is not in OpenGL Version 1.0.\n");
    fprintf (stderr, "If your implementation of OpenGL Version 1.0 has the right extensions,\n");
    fprintf (stderr, "you may be able to modify this program to make it run.\n");
    return 0;
}
#endif


第5个代码是：




GeorgeWang1994
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
opengl 纹理贴图左右反了
踏踏实实的。。。
03-14 4765
更多精彩内容，请见：http://www.16boke.com 网上下了个源码，结果效果中纹理贴图左右反了，发现原因是glTexCoord2f将纹理映射到四边形时映射错了。 函数原型为 glTexCoord2f(GLfloat s, GLfloat t)，用于绘制图形时指定纹理的坐标。   s和t 代表坐标 s为 X轴坐标，t为Y轴坐标原型为 glTexCoord2f(GLfloat s, GLfloat t) 第一个
opengl之纹理绘图
loverfuping的专栏
12-13 756
1.glGentextures(1,&texture);生成一个texture id.    2.glBindTexture(GL_TEXTURE_2D,texture);表示使用哪一个texture id ，以下的操作都是针对这个texture id 来进行的。 这个函数一般会在两个地方使用，一个初始化纹理的时候，另一个是在使用纹理的时候。    3.glTexImage2D(GL_TEX
纹理贴图，opengl经典例子
01-15
纹理贴图，opengl经典例子，方便入门者学习
OpenGL总结8-纹理状态机
windxgz的博客
03-24 507
OpenGL中的各种设置都是采用状态机，也就是类似开关，如果一个状态打开后不进行关闭那么这个状态将会持续。 OpenGL在进行纹理贴图的时候经常要用到glEnable这个函数，每次开启纹理后最好都进行一次关闭，因为在后续的绘制过程中，如使用glColor进行颜色的绘制时，如果纹理的状态机开着，那么很有可能会影响你的纹理图像，还有如果文理绑定失败，贴图时可能会贴之前的纹理。所以最好在每次使用之后都进...
基于opengl的纹理绘制作业
weixin_55667729的博客
06-07 571
作业思路与实现
纹理 2D
fztfztfzt的专栏
03-23 530
只使用了2d的纹理，纹理贴图就是将一张图片贴到物体的表面 相关函数：glEnable(GL_TEXTURE_2D);//开启2D纹理 glBindTexture(GL_TEXTURE_2D, textures[0]);//绑定纹理，将绘制的纹理 glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE,
第十一课，纹理的使用入门
fengerfafa的专栏
01-21 2863
转自：http://www.programfan.com/club/post-244703.html我们在前一课中，学习了简单的像素操作，这意味着我们可以使用各种各样的BMP文件来丰富程序的显示效果，于是我们的OpenGL图形程序也不再像以前总是只显示几个多边形那样单调了。——但是这还不够。虽然我们可以将像素数据按照矩形进行缩小和放大，但是还不足以满足我们的要求。例如要将一幅世界地图绘制到一个
【OpenGL ES】纹理贴图
11-08
本教程将深入探讨如何在OpenGL ES环境中实现纹理贴图，特别是在Android平台上。 一、纹理贴图基础 纹理贴图是3D图形学中的一个重要概念，它允许我们在3D模型表面添加丰富的视觉细节。纹理就像真实物体表面的图案或...
opengl实现对地球纹理贴图
09-18
opengl实现纹理贴图，以地球为例子，但是实现得有点粗糙，地球上出现了一条裂缝 opengl实现纹理贴图，以地球为例子，但是实现得有点粗糙，地球上出现了一条裂缝
opengl纹理贴图源码
04-11
在OpenGL中，纹理贴图是给3D模型增添细节和真实感的关键技术。本教程将深入探讨如何使用VA（Vertex Array）模式实现纹理贴图。 纹理贴图是指将2D图像（纹理）映射到3D模型表面，通过这种方式增加模型的视觉信息。在...
MFC下实现OpenGL纹理贴图
12-28
总的来说，实现MFC下OpenGL纹理贴图的关键在于理解MFC与OpenGL的交互，加载和管理纹理，以及处理用户输入以控制三维对象。这个过程涉及到的知识点包括：MFC框架的基本使用，OpenGL上下文的创建和管理，纹理映射的...
OpenGL加载Obj模型和纹理贴图
05-27
基于Qt+OpenGL 实现的3D模型obj文件加载以及纹理贴图，未使用第三方库，根据obj文件的格式，逐行解析并读取，加载到顶点缓冲区中，适合学习OBJ模型加载的同学参考。
OpenGL（十五）——Qt OpenGL三种不同的纹理滤波方式、光照、物体的移动
ifeng12358的博客
07-26 3268
本篇分享 1、如何使用三种不同的纹理滤波方式。 2、如何使用键盘来移动场景中的对象， 3、如何在OpenGL场景中应用简单的光照。
OpenGL多重纹理使用与理解
iMatt的专栏
11-19 3026
1.glActiveTextureARB的Active不能理解为激活,使发生作用!!! 应理解为选择(Select)某纹理单元(Texture Unit),即表示后续的glEnable(GL_TEXTURE_2D);glBindTexture(GL_TEXTURE_2D, texture);作用于此所选的纹理单元.而glEnable(GL_TEXTURE_2D)才是真正激活纹理单元的调用.
OpenGL加载纹理深入详解。
大核桃、
05-22 6535
//OpenGL进行纹理映射的基本流程： 1，首先要开启纹理映射的功能。 glEnable(GL_TEXTURE_2D);  2，载入位图资源。 3，将位图资源转化成纹理。 4，释放位图资源。 5，使用纹理，绘图。 闲话不多说，直接上代码。   这里插一句，在OpenGL里面，申明一个纹理（位图转化成纹理）需要三个步骤： 1，首先我需要申明一个纹理对象的名称，调用glGenTextures函数，
OpenGL实例：纹理映射
05-06 1155
OpenGL实例：纹理映射 作者：凯鲁嘎吉 - 博客园http://www.cnblogs.com/kailugaji/ 更多请查看：计算机图形学 1. 介绍 用于指定一维、二维和三维纹理的函数分别为： Void glTexImage1D(GLenum target, Glint level, Glint components, GLsizei width, Gl...
多重纹理的学习和使用
Jaogoy的专栏
01-29 2301
1.glActiveTextureARB的Active不能理解为激活,使发生作用!!!应理解为选择(Select)某纹理单元(Texture Unit),即表示后续的glEnable(GL_TEXTURE_2D);glBindTexture(GL_TEXTURE_2D, texture);作用于此所选的纹理单元.而glEnable(GL_TEXTURE_2D)才是真正激活纹理单元的调用.glA
OpenGL：纹理贴图
zhang_shuaifeng的博客
02-26 2291
顶点的纹理坐标、纹理图像对象
ASP外观专利图像检索平台(源代码+论文).rar
最新发布
07-21
ASP外观专利图像检索平台(源代码+论文)
opengl球面纹理贴图
11-28
OpenGL球面纹理贴图是一种在球体上应用纹理的技术。在OpenGL中，为了使用球面纹理贴图，我们需要首先创建一个球体模型。这可以通过绘制一系列的三角形面片来实现，形成一个球体的表面。接下来，我们需要为球体模型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值