【OpenGL】【3D】一个OpenGL示例程序

lophyxp

• 先上源代码
  
  
  1. #include <stdio.h>
     
  2. #include <stdlib.h>
     
  3. #include <stdbool.h>
     
  4. #include "GL/glew.h"
     
  5. #include "GL/glut.h"
     
  6. 
     
  7. #ifdef WIN32
     
  8.        #define filename "d:\\tex03.bmp"
     
  9. #elif LINUX
     
  10.        #define filename "/home/lophyxp/tex03.bmp"
      
  11. #endif
      
  12. 
      
  13. static GLint imagewidth;
      
  14. static GLint imageheight;
      
  15. static GLint pixellength;
      
  16. static GLubyte* pixeldata;
      
  17. 
      
  18. 
      
  19. void readBMP() {
      
  20.         //打开文件
      
  21.         FILE* pfile = fopen(filename, "rb");
      
  22.         if (pfile == 0) {
      
  23.                 printf("%s is not a BMP file.\n", filename);
      
  24.                 exit(0);
      
  25.         }
      
  26. 
      
  27.         //读取图像大小
      
  28.         fseek(pfile, 0x0012, SEEK_SET);
      
  29.         fread(&imagewidth, sizeof(imagewidth), 1, pfile);
      
  30.         fread(&imageheight, sizeof(imageheight), 1, pfile);
      
  31. 
      
  32.         //计算像素数据长度，处理对齐
      
  33.         pixellength = imagewidth * 3;
      
  34.         while (pixellength % 4 != 0)pixellength++;
      
  35.         pixellength *= imageheight;
      
  36. 
      
  37.         //读取像素数据
      
  38.         pixeldata = (GLubyte*)malloc(pixellength);
      
  39.         if (pixeldata == 0) exit(0);
      
  40. 
      
  41.         fseek(pfile, 54, SEEK_SET);
      
  42.         fread(pixeldata, pixellength, 1, pfile);
      
  43. 
      
  44.         //关闭文件
      
  45.         fclose(pfile);
      
  46. }
      
  47. 
      
  48. typedef struct materialStruct {
      
  49.         GLfloat ambient[4];
      
  50.         GLfloat diffuse[4];
      
  51.         GLfloat specular[4];
      
  52.         GLfloat shininess;
      
  53. }materialStruct;
      
  54. 
      
  55. materialStruct brassMaterials = {
      
  56.         { 0.33, 0.22, 0.03, 1.0 },
      
  57.         { 0.78, 0.57, 0.11, 1.0 },
      
  58.         { 0.99, 0.91, 0.81, 1.0 },
      
  59.         27.8
      
  60. };
      
  61. 
      
  62. materialStruct redPlasticMaterials = {
      
  63.         { 0.3, 0.0, 0.0, 1.0 },
      
  64.         { 0.6, 0.0, 0.0, 1.0 },
      
  65.         { 0.8, 0.6, 0.6, 1.0 },
      
  66.         32.0
      
  67. };
      
  68. 
      
  69. materialStruct whiteShinyMaterials = {
      
  70.         { 1.0, 1.0, 1.0, 1.0 },
      
  71.         { 1.0, 1.0, 1.0, 1.0 },
      
  72.         { 1.0, 1.0, 1.0, 1.0 },
      
  73.         100.0
      
  74. };
      
  75. 
      
  76. void materials(materialStruct *materials) {
      
  77.         glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, materials->ambient);
      
  78.         glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, materials->diffuse);
      
  79.         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, materials->specular);
      
  80.         glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, materials->shininess);
      
  81. }
      
  82. 
      
  83. typedef struct lightingStruct {
      
  84.         GLfloat ambient[4];
      
  85.         GLfloat diffuse[4];
      
  86.         GLfloat specular[4];
      
  87. }lightingStruct;
      
  88. 
      
  89. lightingStruct whiteLighting = {
      
  90.         { 0.0, 0.0, 0.0, 1.0 },
      
  91.         { 1.0, 1.0, 1.0, 1.0 },
      
  92.         { 1.0, 1.0, 1.0, 1.0 }
      
  93. };
      
  94. 
      
  95. lightingStruct coloredLighting = {
      
  96.         { 0.2, 0.0, 0.0, 1.0 },
      
  97.         { 0.0, 1.0, 0.0, 1.0 },
      
  98.         { 0.0, 0.0, 1.0, 1.0 }
      
  99. };
      
  100. 
       
  101. void lighting(lightingStruct *lighting) {
       
  102.         glLightfv(GL_LIGHT0, GL_AMBIENT, lighting->ambient);
       
  103.         glLightfv(GL_LIGHT0, GL_DIFFUSE, lighting->diffuse);
       
  104.         glLightfv(GL_LIGHT0, GL_SPECULAR, lighting->specular);
       
  105. }
       
  106. 
       
  107. void init() {
       
  108.         glViewport(0, 0, 500, 500);
       
  109.         glMatrixMode(GL_PROJECTION);
       
  110.         glLoadIdentity();
       
  111.         glOrtho(-2.0, 2.0, -2.0,
       
  112.                 2.0, -10.0, 10.0);
       
  113. 
       
  114.         // Texture_2d ================================
       
  115.         glEnable(GL_DEPTH_TEST);
       
  116.         glEnable(GL_TEXTURE_2D);
       
  117.         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, imagewidth, imageheight, 0, GL_BGR, GL_UNSIGNED_BYTE, pixeldata);
       
  118.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
       
  119.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
       
  120.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
       
  121.         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
       
  122.         //glDisable(GL_TEXTURE_2D);
       
  123. 
       
  124.         // Blend ======================================
       
  125.         glEnable(GL_BLEND);
       
  126.         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
       
  127.         //glBlendFunc(GL_SRC_ALPHA, GL_ONE);
       
  128. 
       
  129.         // Lighting ================================
       
  130.         //GLfloat light_pos[] = { 1.0,2.0,3.0,1.0 };
       
  131.         glEnable(GL_LIGHTING);
       
  132.         glEnable(GL_LIGHT0);
       
  133.         /*glMatrixMode(GL_MODELVIEW);
       
  134.         glLoadIdentity();
       
  135.         glLightfv(GL_LIGHT0, GL_POSITION, light_pos);*/
       
  136.         lighting(&whiteLighting);
       
  137.         materials(&brassMaterials);
       
  138. 
       
  139.         glShadeModel(GL_SMOOTH);
       
  140. 
       
  141.         // Fog ===================================
       
  142.         GLuint filter = 2;
       
  143.         GLuint fogMode[] = { GL_EXP, GL_EXP2, GL_LINE };
       
  144.         GLuint fogfilter = 0;
       
  145.         GLfloat fogColor[4] = { 0.5f, 0.5f, 0.5f, 1.0f };
       
  146. 
       
  147.         glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
       
  148.         glFogi(GL_FOG_MODE, fogMode[fogfilter]);
       
  149.         glFogfv(GL_FOG_COLOR, fogColor);
       
  150.         glFogf(GL_FOG_DENSITY, 0.35f);
       
  151.         glHint(GL_FOG_HINT, GL_DONT_CARE);
       
  152.         glFogf(GL_FOG_START, 1.0f);
       
  153.         glFogf(GL_FOG_END, 5.0f);
       
  154.         glEnable(GL_FOG);
       
  155. }
       
  156. 
       
  157. GLfloat vertics[][3]={
       
  158.         {-1.0, -1.0, 1.0},        {-1.0,1.0,1.0},                //0, 1
       
  159.         {1.0,1.0,1.0},                {1.0,-1.0,1.0},                //2, 3
       
  160.         {-1.0,-1.0,-1.0},        {-1.0,1.0,-1.0},        //4, 5
       
  161.         {1.0,1.0,-1.0},                {1.0,-1.0,-1.0}                //6, 7
       
  162. };
       
  163. GLfloat colors[][4] = {
       
  164.         {1.0,0.0,0.0,0.5},{0.0,1.0,1.0,0.5},
       
  165.         {1.0,1.0,0.0,0.5},{0.0,1.0,0.0,0.5},
       
  166.         {0.0,0.0,1.0,0.5},{1.0,0.0,1.0,0.5},
       
  167.         {0.0,0.0,0.0,0.5},{1.0,1.0,1.0,0.5}
       
  168. };
       
  169. GLfloat normals[][3] = {
       
  170.         {-1.0, 0.0, 0.0}, {1.0, 0.0, 0.0},
       
  171.         {0.0, -1.0, 0.0}, {0.0, 1.0, 0.0},
       
  172.         {0.0, 0.0, -1.0}, {0.0, 0.0, 1.0}
       
  173. };
       
  174. 
       
  175. void polygon(int a, int b, int c, int d) {
       
  176.         glBegin(GL_POLYGON);
       
  177.                 glColor3fv(colors[a]);
       
  178.                 glTexCoord2f(0.0, 0.0);
       
  179.                 glVertex3fv(vertics[a]);
       
  180.                 glColor3fv(colors[b]);
       
  181.                 glTexCoord2f(0.0, 1.0);
       
  182.                 glVertex3fv(vertics[b]);
       
  183.                 glColor3fv(colors[c]);
       
  184.                 glTexCoord2f(1.0, 1.0);
       
  185.                 glVertex3fv(vertics[c]);
       
  186.                 glColor3fv(colors[d]);
       
  187.                 glTexCoord2f(1.0, 0.0);
       
  188.                 glVertex3fv(vertics[d]);
       
  189.         glEnd();
       
  190. }
       
  191. 
       
  192. void cube() {
       
  193.         glNormal3fv(normals[5]);        //z
       
  194.         polygon(0, 3, 2, 1);
       
  195.         glNormal3fv(normals[1]);        //x
       
  196.         polygon(2, 3, 7, 6);
       
  197.         glNormal3fv(normals[2]);        //-y
       
  198.         polygon(3, 0, 4, 7);
       
  199.         glNormal3fv(normals[3]);        //y
       
  200.         polygon(1, 2, 6, 5);
       
  201.         glNormal3fv(normals[4]);        //-z
       
  202.         polygon(4, 5, 6, 7);
       
  203.         glNormal3fv(normals[0]);        //-x
       
  204.         polygon(5, 4, 0, 1);
       
  205. }
       
  206. 
       
  207. GLUquadricObj* Quadric;
       
  208. 
       
  209. void quadric() {
       
  210.         Quadric = gluNewQuadric();
       
  211.         gluQuadricDrawStyle(Quadric, GLU_FILL);
       
  212.         gluQuadricNormals(Quadric, GLU_SMOOTH);
       
  213.         gluQuadricTexture(Quadric, GL_TRUE);
       
  214.         gluSphere(Quadric, 1.5, 120, 120);
       
  215.         //gluCylinder(Quadric, 0.5, 0.5, 2.0, 120, 120);
       
  216.         //gluDisk(Quadric, 0.5, 1.0, 120, 120);
       
  217.         //gluPartialDisk(Quadric, 0.5, 1.0, 120, 120, 90.0, 180.0);
       
  218. 
       
  219.         gluDeleteQuadric(Quadric);
       
  220. }
       
  221. 
       
  222. static GLfloat theta[] = { 0.0, 0.0, 0.0 };
       
  223. static GLint axis = 1;        //0:x, 1:y, 2:z
       
  224. static GLfloat position0[] = { 10.0,20.0,30.0,1.0 };
       
  225. 
       
  226. void display(void)
       
  227. {
       
  228.         glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
       
  229.         glMatrixMode(GL_MODELVIEW);
       
  230.         glLoadIdentity();
       
  231.         //gluLookAt(1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
       
  232.         glPushMatrix();
       
  233.         glRotatef(theta[0], 1.0, 0.0, 0.0);
       
  234.         glRotatef(theta[1], 0.0, 1.0, 0.0);
       
  235.         glRotatef(theta[2], 0.0, 0.0, 1.0);
       
  236. 
       
  237.         glLightfv(GL_LIGHT0, GL_POSITION, position0);
       
  238. 
       
  239.         
       
  240.         //cube();
       
  241.         //glutSolidTeapot(1.0);
       
  242.         glRotatef(-90.0, 1.0, 0.0, 0.0);  //quardic round axis-z to round axis-y
       
  243.         quadric();
       
  244.         glPopMatrix();
       
  245. 
       
  246.         //glDrawPixels(imagewidth, imageheight, GL_BGR_EXT, GL_UNSIGNED_BYTE, pixeldata);
       
  247. 
       
  248.         glFlush();
       
  249.         glutSwapBuffers();
       
  250. }
       
  251. 
       
  252. void myMouse(int btn, int state, int x, int y) {
       
  253.         if (btn == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
       
  254.                 axis = 0;
       
  255.         if (btn == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN)
       
  256.                 axis = 1;
       
  257.         if (btn == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
       
  258.                 axis = 2;
       
  259. }
       
  260. 
       
  261. void myIdle() {
       
  262.         theta[axis] += 0.1;
       
  263.         if (theta[axis] > 360.0) theta[axis] -= 360.0;
       
  264.         
       
  265.         glutPostRedisplay();
       
  266. }
       
  267. 
       
  268. void myKeyboard(unsigned char k, int x, int y) {
       
  269.         static bool gp = true;
       
  270.         switch (k) {
       
  271.         case '1':
       
  272.                 glutIdleFunc(NULL);
       
  273.                 break;
       
  274.         case '2':
       
  275.                 glutIdleFunc(&myIdle);
       
  276.                 break;
       
  277.         case '3':
       
  278.                 glEnable(GL_TEXTURE_2D);
       
  279.                 break;
       
  280.         case '4':
       
  281.                 glDisable(GL_TEXTURE_2D);
       
  282.                 break;
       
  283.         case 'w':
       
  284.                 materials(&redPlasticMaterials);
       
  285.                 break;
       
  286.         case 'e':
       
  287.                 materials(&brassMaterials);
       
  288.                 break;
       
  289.         case 'r':
       
  290.                 materials(&whiteShinyMaterials);
       
  291.                 break;
       
  292.         case 's':
       
  293.                 lighting(&whiteLighting);
       
  294.                 break;
       
  295.         case 'd':
       
  296.                 lighting(&coloredLighting);
       
  297.                 break;
       
  298.         case 'f':
       
  299.                 if (gp == true) {
       
  300.                         glDisable(GL_FOG);
       
  301.                         gp = false;
       
  302.                 }
       
  303.                 else {
       
  304.                         glEnable(GL_FOG);
       
  305.                         gp = true;
       
  306.                 }
       
  307.                 break;
       
  308.         case 'q':
       
  309.                 exit(0);
       
  310.                 break;
       
  311.         }
       
  312. }
       
  313. 
       
  314. void myReshape(int w, int h) {
       
  315.         glViewport(0, 0, w, h);
       
  316.         glMatrixMode(GL_PROJECTION);
       
  317.         glLoadIdentity();
       
  318.         if(w<=h)
       
  319.                 glOrtho(-2.0, 2.0, -2.0*(GLfloat)h / (GLfloat)w,
       
  320.                         2.0*(GLfloat)h / (GLfloat)w, -10.0, 10.0);
       
  321.         else
       
  322.                 glOrtho(-2.0*(GLfloat)w / (GLfloat)h,
       
  323.                         2.0*(GLfloat)w / (GLfloat)h, -2.0, 2.0,  -10.0, 10.0);
       
  324.         glMatrixMode(GL_MODELVIEW);
       
  325. }
       
  326. 
       
  327. int main(int argc, char* argv[]) {
       
  328.         readBMP();
       
  329.         glutInit(&argc, argv);
       
  330.         glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
       
  331.         glutInitWindowPosition(10, 10);
       
  332.         glutInitWindowSize(500, 500);
       
  333.         glutCreateWindow(filename);
       
  334.         init();
       
  335.         glutDisplayFunc(&display);
       
  336.         glutReshapeFunc(&myReshape);
       
  337.         glutIdleFunc(&myIdle);
       
  338.         glutMouseFunc(&myMouse);
       
  339.         glutKeyboardFunc(&myKeyboard);
       
  340.         glutMainLoop();
       
  341.         //-------------------------------------
       
  342.         free(pixeldata);
       
  343.         return 0;
       
  344. }
       

  复制代码
  
  
• 下载纹理文件
  
  Windows下，解压缩后得到tex.bmp文件，放到D盘根目录下；Linux下，解压缩以后放到/home/lophyxp/目录下。
• Windows下编译
  下载oglEarth.rar五个文件，解压缩到
  我的文档\Visual Studio 2015\Projects目录下，打开Visual Studio 2015，打开项目，选择oglEarth\oglEarth.sln，点“本地Windows调试器”前面的绿色箭头。
• Linux下编译
  下载，执行
  1. tar xzvf oglEarth.tar.gz
     
  2. make main
     
  3. ./main

  复制代码
  
  
• 运行效果