OpenGL3D迷宫场景设计

最新推荐文章于 2023-05-06 13:32:18 发布
原创 最新推荐文章于 2023-05-06 13:32:18 发布 · 2.1k 阅读 · 19 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍使用OpenGL构建3D迷宫游戏的过程，包括光照、纹理映射、显示列表等技术的应用，并详细讲解场景漫游及粒子系统的设计与实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

最近学习用opengl库来构建一个3D场景，以及实现场景漫游、粒子系统等效果，最终算是是做了一个3D走迷宫游戏吧。感觉最近学了好多东西，所以有必要整理整理。

一 实现效果


二 实现过程详解

   1、3d场景构建

1)光照与材质

通过设置光照与材质，使得场景的显示效果更真实。opengl加光源的方法：

[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. GLfloat light_position[] = {0.0, 80.0, 0.0};  
  2.     GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 1.0};  
  3.     glLightfv(GL_LIGHT0, GL_POSITION, light_position);  
  4.     glLightfv(GL_LIGHT0, GL_AMBIENT_AND_DIFFUSE, light_diffuse);  
  5.     glEnable(GL_LIGHTING);  
  6.     glEnable(GL_LIGHT0);  
加一个光源至少要上面这些代码，通过glLightfv()函数给光源设置位置以及颜色，可以加环境光G_AMBIENT、漫射光GL_DIFFUSE或镜面光GLSPECULAR，可以同时加8个光源，上面的光源时GL_LIGHT0，其他的就是GL_LIGHT1、2等。

场景中一旦加了光源，物体就会根据自己的材质对RGB光成分反射程度而显示不同的颜色。OpenGL给一个物体设置材质的方法

[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. GLfloat diffuse[] = {1.0, 0.9, 0.9};  
  2.     glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, diffuse);  
设置材质参数后接下来画的物体就具备了这种材质。通常使用参数GL_AMBIENT_AND_DIFFUSE给环境光和漫射光设置相同的反射程度。

2）纹理映射与多重纹理映射

给模型加纹理是为了在表面形成复杂图案，因为设置材质只是控制表面的显示颜色，实际上物体的表面信息要更复杂些。opengl提供了给物体贴纹理图的方法，实际上有多种方法，但我用的是 glaux库。

[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. struct IMAGE  
  2. {  
  3.     GLuint sizeX;  
  4.     GLuint sizeY;  
  5.     signed char* data;  
  6. };  
  7. IMAGE *Image[3];  
  8. GLuint Texture[3];  
  9. bool loadTexture()//设置各种纹理，从bmp图像读取  
  10. {  
  11.     FILE* myFile;  
  12.     if(!(myFile = fopen("wall.bmp", "r")))  
  13.     return false;  
  14.     Image[0] = (IMAGE*)auxDIBImageLoad("wall.bmp");  
  15.     glGenTextures(3, &Texture[0]);  
  16.     glBindTexture(GL_TEXTURE_2D, Texture[0]);  
  17.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);  
  18.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);  
  19.     glTexImage2D(GL_TEXTURE_2D, 0, 3, Image[0]->sizeX, Image[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, Image[0]->data);  
  20.     if(!(myFile = fopen("floor.bmp", "r")))  
  21.         return false;  
  22.     Image[1] = (IMAGE*)auxDIBImageLoad("floor.bmp");  
  23.     glBindTexture(GL_TEXTURE_2D, Texture[1]);  
  24.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);  
  25.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);  
  26.     glTexImage2D(GL_TEXTURE_2D, 0, 3, Image[1]->sizeX, Image[1]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, Image[1]->data);  
  27.     if(!(myFile = fopen("water.bmp", "r")))  
  28.         return false;  
  29.     Image[2] = (IMAGE*)auxDIBImageLoad("water.bmp");  
  30.     glBindTexture(GL_TEXTURE_2D, Texture[2]);  
  31.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);  
  32.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);  
  33.     glTexImage2D(GL_TEXTURE_2D, 0, 3, Image[2]->sizeX, Image[2]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, Image[2]->data);  
  34.       
  35.     //释放内存  
  36.     if(Image[0])  
  37.     {  
  38.         if(Image[0]->data)  
  39.             free(Image[0]->data);  
  40.             free(Image[0]);  
  41.     }  
  42.     if(Image[1])  
  43.     {  
  44.         if(Image[1]->data)  
  45.             free(Image[1]->data);  
  46.         free(Image[1]);  
  47.     }  
  48.     if(Image[2])  
  49.     {  
  50.         if(Image[2]->data)  
  51.             free(Image[2]->data);  
  52.         free(Image[2]);  
  53.     }  
  54.     return true;  
  55. }  

上面的代码生成了三种纹理。语句glGenTextures（3， &Texture[0]）生成了三个纹理索引，存在了数组Texture中，以后每次要设置纹理信息或是想应用纹理，通过函数glBindTexture（GL_TEXTURE_2D， textureIndex）就可以取到对应的纹理，其中第二个参数就是纹理索引。

绑定纹理到物体表面：

[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. void drawPolygon(GLfloat a[3], GLfloat b[3], GLfloat c[3], GLfloat d[3])//根据四个点画一个面  
  2. {  
  3.     glEnable(GL_TEXTURE_2D);  
  4.     glBindTexture(GL_TEXTURE_2D, Texture[0]);  
  5.     glBegin(GL_POLYGON);  
  6.     glTexCoord2f(0.0f, 0.0f);  
  7.     glVertex3fv(a);  
  8.     glTexCoord2f(1.0f, 0.0f);  
  9.     glVertex3fv(b);  
  10.     glTexCoord2f(1.0f, 1.0f);  
  11.     glVertex3fv(c);  
  12.     glTexCoord2f(0.0f, 1.0f);  
  13.     glVertex3fv(d);  
  14.     glEnd();  
  15. }  

多重纹理就是在物体表面贴上多个纹理的方法，要使用多重纹理需要用到另一个库glext库。根据下面的代码就可以给物体表面贴上两种纹理：

[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB=NULL;  
  2. PFNGLACTIVETEXTUREARBPROC glActiveTextureARB=NULL;  
  3. bool canMultiTexture = true;  
  4. void multiTextureInit()//多重纹理的初始化  
  5. {  
  6.     glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)wglGetProcAddress("glActiveTextureARB");  
  7.     glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)wglGetProcAddress("glMultiTexCoord2fARB");  
  8.     if(glActiveTextureARB == NULL)  
  9.         canMultiTexture = false;  
  10. }  
  11. void multiTextureBegin()//多重纹理绑定  
  12. {  
  13.      glEnable(GL_TEXTURE_2D);  
  14.      glActiveTextureARB(GL_TEXTURE0_ARB);  
  15.      glBindTexture(GL_TEXTURE_2D, Texture[0]);//纹理1  
  16.      glActiveTextureARB(GL_TEXTURE1_ARB);  
  17.      glEnable(GL_TEXTURE_2D);  
  18.      glBindTexture(GL_TEXTURE_2D, Texture[1]);//纹理2  
  19. }  
值得注意的是，多重纹理对电脑设备有要求，主要是显示器要支持，所以一旦不支持，上面初始化的时候glActivetextureARB就会为null，这时候要做另外处理，不然后面使用这个为null的变量程序就会出错。

3）显示列表

显示列表是OpenGL提供的一种方便反复调用相同的显示函数的方法，比如你的程序中需要反复的描绘一个物体，你就最好用显示列表来调用，这样做能够大大优化性能。

调用显示列表是通过glCallList（列表索引）函数调用的，显然没一个显示列表都有一个对应的索引，通过这个索引去调用显示列表中的显示操作。下面的代码生成了一个画五角星的显示列表：

[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. GLuint display_list;//一个五角星的显示列表索引  
[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. GLuint createDL()//创建一个五角星显示列表  
  2.     {  
  3.         GLuint DL;  
  4.         DL = glGenLists(1);  
  5.         glNewList(DL,GL_COMPILE);   
  6.         drawFive();//画一个五角星  
  7.         glEndList();  
  8.         return DL;  
  9.     }  
当需要画一个五角星的时候调用glCallList(display_list);即可。

2 场景漫游
我实现的是模拟人在迷宫中走动寻找出口的情形，通过键盘的上下左右键控制视线的改变以及位置的移动。先理解一下gluLookAt函数，我的程序里参数是这样的gluLookAt(x, y, z, x + lx,y + ly,z + lz,0.0f,1.0f,0.0f) 总共有9个参数，前三个参数代表了照相机的位置，所以这里照相机的位置是（x，y，z），接下来三个参数是目标的中心位置，即（x+lx， y+ly，z+lz），后面三个参数一般设为0， 1， 0，表示的是照相机头部的方向，如果把照相机看错人眼，那照相机头部的方向也就是我们头的方向（所以一般向上）。因为要控制向前/后移动，所以需要知道此时视线的方向向量，实际上就是（lx， ly， lz），当改变视角是其实就是改变（lx， ly， lz）的值，所以当左右键事件发生时，进行以下计算：

[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. void orientMe(float ang)  //计算由于左右键盘操作而改变视点方向，使用左右方向键旋转照相机  
  2.  {            
  3.     lx = sin(ang);           
  4.     lz = -cos(ang);           
  5.     glLoadIdentity();           
  6.     gluLookAt(x, y, z, x + lx,y + ly,z + lz, 0.0f,1.0f,0.0f);  
  7. }  
可以注意到照相机位置还是不变的，因为只是改变了视线。当上下键事件发生时，改变的就是照相机的位置了。

[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. void moveMeFlat(int direction)  //计算视点由于上下键盘操作而移动的量，上下方向键使照相机沿视线前后移动  
  2. {     
  3.     int prev_x = x, prev_z = z;  
  4.     x = x + direction*(lx)*0.1;           
  5.     z = z + direction*(lz)*0.1;    
  6.     glLoadIdentity();        
  7.     if(isWall[(int)(x + 93)][(int)(z + 93)])  
  8.     {  
  9.         x = prev_x;  
  10.         z = prev_z;  
  11.     }  
  12.     gluLookAt(x, y, z, x + lx,y + ly,z + lz,0.0f,1.0f,0.0f);  
  13. }  
3 粒子系统的实现

粒子系统不是什么具体的东西，而是是一个很好的编程设计思想，通常用来模拟雨、雪、雾、烟花等效果。粒子系统的实现主要问题就是如何设计粒子的行为以及如何渲染粒子以达到真实的效果。我的程序里粒子系统是最后加的，跟走迷宫没什么练习，只是觉得粒子系统挺神奇的，就试着实现各种五角星漫天飞扬的效果。这时粒子的类，定义了一个粒子的所有行为：

[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. //次类是粒子类，实现粒子的一系列行为  
  2. #include<stdlib.h>  
  3. #include<GL\glut.h>  
  4. #include<time.h>  
  5. #define PI 3.1415  
  6. class particle  
  7. {  
  8. private:  
  9.     GLfloat x;//位置x坐标  
  10.     GLfloat y;//y坐标  
  11.     GLfloat z;//z坐标  
  12.     GLfloat v[3];//控制速度  
  13.     GLfloat rotate[3];//控制旋转方向  
  14.     GLfloat angle;//旋转的角度  
  15.     GLfloat color[3];//五角星显示的颜色  
  16.     GLuint display_list;//一个五角星的显示列表索引  
  17. public:  
  18.     GLuint createDL()//创建一个五角星显示列表  
  19.     {  
  20.         GLuint DL;  
  21.         DL = glGenLists(1);  
  22.         glNewList(DL,GL_COMPILE);   
  23.         drawFive();//画一个五角星  
  24.         glEndList();  
  25.         return DL;  
  26.     }  
  27.     void init()//随机初始化位置以及方向等信息  
  28.     {  
  29.         display_list = createDL();  
  30.         angle = 0;  
  31.         y = rand() % 40;  
  32.         x = rand() % 181 - 90;  
  33.         z = rand() % 181 - 90;  
  34.         v[0] = (float)(rand() % 8) / (float)10 - 0.4;  
  35.         v[1] = (float)(rand() % 8) / (float)10 - 0.4;  
  36.         v[2] = (float)(rand() % 8) / (float)10 - 0.4;  
  37.         rotate[0] = (float)(rand() % 7) / (float)7 + 5;  
  38.         rotate[1] = (float)(rand() % 7) / (float)7 + 5;  
  39.         rotate[2] = (float)(rand() % 7) / (float)7 + 5;  
  40.         color[0] = (float)(rand() % 5) / (float)5 + 0.2;  
  41.         color[1] = (float)(rand() % 5) / (float)5 + 0.2;  
  42.         color[2] = (float)(rand() % 5) / (float)5 + 0.2;  
  43.     }  
  44.     void drawFive()//画五角星  
  45.     {  
  46.         GLfloat out_length = sqrt(1.0 / (2 - 2 * cos(72 * PI / 180))),  
  47.         bx = out_length * cos(18 * PI / 180),  
  48.         by = out_length * sin(18 * PI / 180),  
  49.         cx = out_length * sin(36 * PI / 180),  
  50.         cy = -out_length * cos(36 * PI / 180);  
  51.         GLfloat fx = cx * (by - out_length) / (cy - out_length), fy = by,  
  52.         in_length = sqrt(fx * fx + fy * fy),  
  53.         gx = in_length * cos(18 * PI / 180),  
  54.         gy = -in_length * sin(18 * PI / 180);  
  55.         GLfloat point_a[2] = {0, out_length},  
  56.         point_b[2] = {bx, by},  
  57.         point_c[2] = {cx, cy},  
  58.         point_d[2] = {-cx, cy},  
  59.         point_e[2] = {-bx, by},  
  60.         point_f[2] = {fx, fy},  
  61.         point_g[2] = {gx, gy},  
  62.         point_h[2] = {0, -in_length},  
  63.         point_i[2] = {-gx, gy},  
  64.         point_j[2] = {-fx, fy};  
  65.         glBegin(GL_TRIANGLE_FAN);  
  66.         glVertex2f(0.0f, 0.0f);  
  67.         glVertex2f(point_a[0], point_a[1]);  
  68.         glVertex2f(point_f[0], point_f[1]);  
  69.         glVertex2f(point_b[0], point_b[1]);  
  70.         glVertex2f(point_g[0], point_g[1]);  
  71.         glVertex2f(point_c[0], point_c[1]);  
  72.         glVertex2f(point_h[0], point_h[1]);  
  73.         glVertex2f(point_d[0], point_d[1]);  
  74.         glVertex2f(point_i[0], point_i[1]);  
  75.         glVertex2f(point_e[0], point_e[1]);  
  76.         glVertex2f(point_j[0], point_j[1]);  
  77.         glVertex2f(point_a[0], point_a[1]);  
  78.         glEnd();  
  79.     }  
  80.     void draw()//在（x, y, z）显示五角星  
  81.     {  
  82.         GLfloat diffuse[] = {color[0], color[1], color[2]};  
  83.         glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, diffuse);  
  84.         glPushMatrix();  
  85.         glTranslatef(x, y, z);  
  86.         glRotatef(angle, rotate[0], rotate[1], rotate[2]);  
  87.         glCallList(display_list);  
  88.         glPopMatrix();  
  89.     }  
  90.     void move(float slowdown)//改变粒子位置及角度等信息  
  91.     {  
  92.         x += v[0] / slowdown;  
  93.         y += v[1] / slowdown;  
  94.         z += v[2] / slowdown;  
  95.         angle += 10 / slowdown;  
  96.         if(!(x >= -90 && x <= 90))  
  97.             die();  
  98.         else if(!(z >= -90 && z <= 90))  
  99.             die();  
  100.         else if(!(y >= 0 && y <= 50))  
  101.             die();  
  102.     }  
  103.     void die()//粒子死亡,消失，重新初始化  
  104.     {//可以加其他操作  
  105.         init();  
  106.     }  
  107. };  
另外也可以对比一下我实现下雨效果的粒子类：

[csharp]  view plain  copy
  在CODE上查看代码片 派生到我的代码片
  1. #include<stdlib.h>  
  2. #include<GL\glut.h>  
  3. #include<time.h>  
  4.   
  5. class rain  
  6. {  
  7. private:  
  8.     GLfloat position[3];//粒子的位置  
  9.     GLfloat v0;//粒子的初速度  
  10.     GLfloat g;//重力加速度  
  11.     GLfloat size;//雨滴的大小  
  12.     GLfloat sizeSet[4];  
  13.     GLfloat gSet[4];  
  14.     GLuint display_list;  
  15. public:  
  16.     rain()  
  17.     {  
  18.         sizeSet[0] = 0.40;  
  19.         sizeSet[1] = 0.45;  
  20.         sizeSet[2] = 0.50;  
  21.         sizeSet[3] = 0.55;  
  22.         gSet[0] = 0.5;  
  23.         gSet[1] = 0.52;  
  24.         gSet[2] = 0.54;  
  25.         gSet[3] = 0.56;  
  26.     }  
  27.     GLuint createDL()  
  28.     {  
  29.         GLuint DL;  
  30.         DL = glGenLists(1);  
  31.         glNewList(DL,GL_COMPILE);   
  32.         GLUquadricObj *qobj = gluNewQuadric();  
  33.         gluQuadricTexture(qobj,GL_TRUE);  
  34.          gluSphere(qobj, size, 20, 20);//画一个小球  
  35.         glEndList();  
  36.         return DL;  
  37.     }  
  38.     void init()//粒子初始化  
  39.     {  
  40.         display_list = createDL();  
  41.         position[0] = rand() % 181 - 90;  
  42.         position[1] = 50;  
  43.         position[2] = rand() % 181 - 90;  
  44.         int sizeIndex = rand() % 4;  
  45.         size = sizeSet[sizeIndex];  
  46.         g = gSet[sizeIndex];//随机加速度  
  47.         v0 = (float)(rand() % 6) / (float)20;//随机初始化初速度  
  48.     }  
  49.     void draw()  
  50.     {  
  51.         GLfloat diffuse[3] = {1.0, 1.0, 1.0};  
  52.         glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, diffuse);  
  53.         glPushMatrix();  
  54.         glTranslatef(position[0], position[1], position[2]);  
  55.         glCallList(display_list);  
  56.         glPopMatrix();  
  57.     }  
  58.     void move()  
  59.     {  
  60.         position[1] -= v0;  
  61.         v0 += g;  
  62.         if(position[1] <= 0)  
  63.             die();  
  64.     }  
  65.     void die()  
  66.     {  
  67.         init();  
  68.     }  
  69. };  
雨水粒子我设计得比较简单，初始化的时候分配它随机一个初速度、一个初位置、加速度、大小等，每次显示过后根据速度和加速度改变位置以实现“加速落下”的效果，还有渲染的时候需要用到雨水的纹理图。

设计好了粒子类之后，就可以再写一个类实现对粒子数的控制，以及对所有粒子进行初始化和显示。

 反复调用的实现

通过理解粒子系统，我知道它是反复地调用显示所有粒子的函数，因为每次粒子的位置都会改变，所以就形成了粒子的运动。那怎么反复调用显示函数呢？看一下glut库里的函数（当然如果用windows库的话也能实现反复调用，这里只是glut库的）：

glutDisplayFunc(renderScene);每次窗口重绘时指定调用函数

glutReshapeFunc(changeSize);     每次窗口大小改变时制定调用函数

一开始想通过这两个函数想反复调用renderScene函数，但是没办法，它们指定的函数只能在特定情况下被调用；

然后我就找到了glutIdleFunc(renderScene)函数，作用是设置全局的默认调用函数。当函数glutMainLoop（）进行了无限等待时间循环时，如果没有窗口事件发生，就默认调用glutIdelFunc指定的函数，这样就可以反复调用renderScene函数了。

五角星粒子系统效果：


雪粒子效果
OpenGL D迷宫场景设计编程
PixelEnigma的博客
10-06 211
通过使用OpenGL的图形渲染功能，我们将创建一个具有真实感的迷宫环境，并允许玩家在其中移动和探索。通过利用OpenGL的图形渲染功能，我们将创建一个逼真的迷宫环境，允许玩家在其中移动和探索。在迷宫类中，我们使用一个二维布尔数组来表示迷宫的结构。在迷宫类中，我们使用一个二维布尔数组来表示迷宫的结构。现在，我们将在OpenGL中绘制迷宫。接下来，我们将创建一个迷宫类来生成和管理迷宫的结构。首先，我们需要设置OpenGL环境并创建一个窗口来显示我们的迷宫场景。接下来，我们创建一个迷宫类来生成和管理迷宫的结构。
OpenGL实现三维迷宫游戏（一）
NobodyHere
05-04 6789
《计算机图形学》这门课的第二个实验，觉得还挺有意思的…实验要求设计一个OpenGL程序，创建一个三维迷宫，支持替身通过一定交互手段在迷宫中漫游，基本功能包括： - 迷宫应当至少包含10 * 10 个Cell，不能过于简单，下图给出一种示例。 - 读取给定的替身模型，加载到场景中。 - 键盘方向键控制替身转向与漫游。 - 有碰撞检测，替身不应当穿墙。 - 支持切换第一视角和第三视角
opengl 迷宫类3d场景程序大作业
09-05
一个可以变成迷宫的，也可以变成画廊的3D程序，用opengl库，c语言，用vc++可以打开
基于OpenGL的3D天空仿真
jocket1024的专栏
11-25 3175
From:http://www.c-cnc.com/dz/news/news.asp?id=18622在进行3D场景渲染时，天空是必不可少的因素。对于3D天空的模拟在视景仿真系统、计算机游戏、三维动画中有着广泛的应用。但是，目前对于天空的仿真还存在很多不足，一些模拟方法中存在实现复杂、计算耗时、图像分辨力不高，真实感不强且只能生成静态图像等问题。本文在研究了前人仿真天空算法的基础上，利用目
简单的OpenGL 3D场景
11-14
简单的OpenGL,3D场景，VC++6.0开发环境，方向键和Page up,Page Down键可以改变视点方向，同时按下Shitf 键可以实现加速。
基于openGL的3D教室场景
01-02
此Demo是基于openGL的3D教室场景绘制，在Demo中实现了基本教室家居的绘制，灯光，纹理贴图，材料等，实现了通过键盘控制，实现对教室的360°漫游功能。
opengl三维迷宫
04-09
图形学试验，三维迷宫
opengl3d迷宫漫游VS2010
06-17
"opengl3d迷宫漫游VS2010"项目是使用OpenGL在Microsoft Visual Studio 2010环境下构建的一个3D迷宫游戏。这个项目的目标是为初学者提供一个简单易懂的教程，展示如何用OpenGL创建具有交互性的3D环境。 在3D迷宫漫游...
OpenGL 3D迷宫游戏制作详解
标题为“OpenGL迷宫游戏”的文档，从描述中我们得知这是一个基于OpenGL技术的3D迷宫游戏。下面将会从几个方面详细探讨该主题中蕴含的知识点。 首先，OpenGL是图形硬件的软件接口，是一个功能强大的跨语言、跨平台的...
OpenGL-3D-scene:简单的 OpenGL 3D 场景 - 具有动画、地形、照明和用户交互的 3D 高尔夫球模型
06-03
高尔夫球场 3D OpenGL 场景 该项目最初是为图形编程类创建的。 高尔夫球 3D 对象是使用创建的。 跑步 make ./proj2
基于VS2010的OpenGL 3D场景
12-07
解压后可以直接运行 OpenGL 3D场景 直升机绕着盆地飞 VS2010
计算机图形学-基于OpenGL的3D迷宫漫游程序
11-08
基于OpenGL的3D迷宫漫游程序，包括模型加载、纹理映射、碰撞处理、摄像漫游等，带详细按键说明和文档
OpenGL实现3d场景漫游
04-18
OpenGL的一个小Demo，通过摄像机实现3D场景的漫游。鼠标控制包括滑动鼠标进行视角转动，使用滚轮进行缩放。键盘通过WSAD进行前后左右的移动。
OPENGL构建3D场景代码
12-01
用OPNEGL实现的简单三维场景，可用鼠标控制镜头的旋转，缩放，并加入了灯光，可用来测试学习基础的3D编程，基于GLUT工具库
NeHe OpenGL第十课：3D世界
Yarin's Blog™
12-31 466
第十课：3D世界         加载3D世界，并在其中漫游: 在这一课中，你将学会如何加载3D世界，并在3D世界中漫游。这一课使用第一课的代码，当然在课程说明中我只介绍改变了代码。 这一课是由Lionel Brits (βtelgeuse)所写的。在本课中我们只对增加的代码做解释。当然只添加课程中所写的代码，程序是不会运行的。如果您有兴趣知道下面的每一行代码是如何运行的话...
openGl设计--3D迷宫
04-11
在计算机图形学最后实验中用vc实现的基于opengl库的3d迷宫，设计三维建模，纹理映射，碰撞检测等
opengl三维场景
12-12
opengl的一个CS三维场景，很逼真，适合opengl游戏开发和opengl初学者学习的一个很好地代码
OPenGL笔记--创建一个3D场景
贝勒里恩的博客
05-06 2585
通过前面的学习，基本掌握了怎么绘制图形，使用纹理，接下来就来创建一个3D场景。基本原理一个复杂的场景肯定是由一些简单的图形，通过某种组合方式构建起来的，在OPenGL中也不例外；例如：在绘制立方体的时候，立方体也是由6个正方形围起来的；基本图形由于显卡在渲染三角形时效率较高，所以我们采用三角形来构建复杂的3D场景；数据结构当您想要使用一系列的数字来完美的表达3D环境时，随着环境复杂度的上升，这个工作的难度也会随之上升；
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值