精华内容
下载资源
问答
  • Tuto-OpenGL-引擎 我正在关注OpenGL游戏引擎开发的教程
  • OpenGLOpenGL引擎开发视频教程

    千次阅读 2017-04-24 11:06:11
    OpenGL引擎开发 ☆CSDN 网址" / "☆51CTO网址" 课程1 图形学理论视频课程-实现OpenGL精简内核 http://edu.csdn.net/course/detail/3814 http://edu.51cto.com/course/course_id-8339.html   ...

    OpenGL引擎开发


    ☆CSDN 网址" / "☆51CTO网址"

    课程1 图形学理论视频课程-实现OpenGL精简内核

    http://edu.csdn.net/course/detail/3814

    http://edu.51cto.com/course/course_id-8339.html

     

    课程2 OpenGL实战编码设计视频课程

    http://edu.csdn.net/course/detail/3512
    http://edu.51cto.com/course/course_id-7893.html

     

    课程3 游戏开发实战之OpenGL ES 2.0基础精讲视频课程

    http://edu.csdn.net/course/detail/958
    http://edu.51cto.com/course/course_id-4368.html

     

    课程4 游戏开发实战之OpenGL ES2.0 中级篇视频课程

    http://edu.csdn.net/course/detail/1167
    http://edu.51cto.com/course/course_id-4369.html

     

    课程5 三维游戏引擎开发-渲染实战视频课程

    http://edu.csdn.net/course/detail/606
    http://edu.51cto.com/course/course_id-4370.html

     

    课程6 三维游戏引擎设计与实现-GUI设计与实现精讲视频课程

    http://edu.csdn.net/course/detail/1037
    http://edu.51cto.com/course/course_id-4371.html

     

    课程7 太空大战3D游戏实战视频课程

    http://edu.csdn.net/course/detail/763
    http://edu.51cto.com/course/course_id-4374.html

     

    课程8 血腥大地课程系列

    http://edu.csdn.net/course/detail/4398
    http://edu.51cto.com/course/course_id-8619.html


    课程9 粒子特效系统(规划中)
    课程10 地形设计器制作(规划中)
    课程10 界面设计器制作(规划中)

     

    课程11 场景编辑器制作(规划中)

    http://edu.csdn.net/course/detail/4597
    http://edu.51cto.com/course/course_id-8808.html


    地理信息系统

     

    课程1 图形学理论视频课程-实现OpenGL精简内核

    http://edu.csdn.net/course/detail/3814
    http://edu.51cto.com/course/course_id-8339.html

     

    课程2 OpenGL实战编码设计视频课程

    http://edu.csdn.net/course/detail/3512
    http://edu.51cto.com/course/course_id-7893.html

     

    课程3 游戏开发实战之OpenGL ES 2.0基础精讲视频课程

    http://edu.csdn.net/course/detail/958
    http://edu.51cto.com/course/course_id-4368.html

     

    课程4 OpenGL实现shapefile的绘制

    http://edu.csdn.net/course/detail/3422
    http://edu.51cto.com/course/course_id-7697.html

     

    课程5 OpenGL 实现Google地图瓦片的绘制,漫游

    http://edu.csdn.net/course/detail/3420
    http://edu.51cto.com/course/course_id-7795.html

     

    课程6 Google地图下载器制作视频课程

    http://edu.csdn.net/course/detail/3958
    http://edu.51cto.com/course/course_id-8357.html

     

    课程7 OpenGL实现地理要素标绘(规划中)

    课程8 OpenGL实现地理要素标绘优化(规划中)
    课程9 OpenGL实现2D-GIS系统(规划中)
    课程10 OpenGL实现3D-城市实现(规划中)

    视频特效

     

    课程1 图形学理论视频课程-实现OpenGL精简内核

    http://edu.csdn.net/course/detail/3814
    http://edu.51cto.com/course/course_id-8339.html

     

    课程2 OpenGL实战编码设计视频课程

    http://edu.csdn.net/course/detail/3512
    http://edu.51cto.com/course/course_id-7893.html

     

    课程3 游戏开发实战之OpenGL ES 2.0基础精讲视频课程

    http://edu.csdn.net/course/detail/958
    http://edu.51cto.com/course/course_id-4368.html


    OpenGL-实现视频播放(FFMpeg)视频课程
    http://edu.csdn.net/course/detail/3959
    http://edu.51cto.com/course/course_id-8361.html

     

    OpenGL-Shader 实现RGB到YUV420加速转换输... (10课时)

    http://edu.csdn.net/course/detail/4020
    http://edu.51cto.com/course/course_id-8383.html


    OpenGL-实现视频播放(FFMpeg)视频课程二期(规划中)
    OpenGL实现视频特效(规划中)

     

    实战系列

     

    课程1 血腥大地

    http://edu.csdn.net/course/detail/2055
    http://edu.51cto.com/course/course_id-8619.html

     

    课程2 血腥大地-资源破解与获取

    http://edu.csdn.net/course/detail/4398
    http://edu.51cto.com/course/course_id-8620.html

     

    课程3 血腥大地-第三季(怪物模型制作)

    http://edu.csdn.net/course/detail/4458
    http://edu.51cto.com/course/course_id-8689.html

     

    课程4 血腥大地-特效系统设计与实现(规划中)


    Taily老段的微信公众号,欢迎交流学习

    https://blog.csdn.net/taily_duan/article/details/81214815


     

    展开全文
  • 我的计划是带大家从零开始写一个简单的渲染引擎出来。当然,我不可能每行代码都放在文章中,每节内容我们围绕一个主题,我先讲解原理,再讲解OpenGL实现的关键代码,然而我会把代码给大家,大家自行查阅。一些基本的...

    前言

    我的计划是带大家从零开始写一个简单的渲染引擎出来。当然,我不可能每行代码都放在文章中,每节内容我们围绕一个主题,我先讲解原理,再讲解OpenGL实现的关键代码,然而我会把代码给大家,大家自行查阅。一些基本的OpenGL知识,大家可以看 LearnOpenGL 的教程,这个教程是以知识点的形式给大家讲的,我们在这里是将这些知识点串起来实现一些效果,让大家明白这些知识点在实战中是如何运用的。

    我们主要实现一些有意思的东西,比如:游戏中的地形、天空盒、粒子系统、骨骼动画,shader呢,以后可能单独开个专题,专门介绍shader实现的一些效果。

    好的,啰里啰唆说了这么多。OpenGL我也是在学习的过程中,讲解的过程中难免出现错误或者理解不到位的地方,还请大家指正。

    下面进入正题:

    开发环境搭建

    开发环境:

    • VS2015
    • GLFW
    • GLEW
    • glm

    GLFW、GLEW、glm 是什么东西,怎么编译,我就不说了啊。 LearnOpenGL 这个教程中讲得很清楚了。如果你的开发环境不是VS2015,你就需要自己编译,如果是的话,你直接用我后面给的源码即可,我都编译好了。

    编译过程中大家遇到问题的,可以给我留言,我尽量帮大家解决。

    1. 新建工程 Win32 控制台程序。
    1. 然后关闭VS,我们调整下目录结构

    大家按照自己的习惯来啊,我是习惯这么干。总之保证你的目录结构整洁就行,这个习惯很重要。

    1. 然后在VS中配置刚才设置的目录

    配置输出、临时目录

    配置头文件目录

    配置库文件目录

    配置库文件名称

    好了,这样环境就搭建好了。下面我们来显示主窗口。

    显示窗口

    我们的主窗口是对GLFW窗口的封装,现在很简单,以后会根据需求扩充这个窗口类。

    App类是程序的入口。从系统设计来讲,引擎部分只实现图形绘制相关的功能,上层应用就是在App中实现的。举个例子:使用Unity开发游戏,你不用关系怎么加载一个游戏角色,unity引擎会提供你这个功能,但是你需要自己写一些逻辑代码控制你这个角色,比如受伤之后会流血等等。我们做游戏时,大部分时间就是在处理游戏的逻辑。

    这里App就是用来编写一些逻辑来测试我们写的渲染引擎。

    然后就是经典的main函数,代码很简单,就是启动App类中的Run函数。

    运行,效果很一般,就一个黑窗口。

    ok,结束。很简单。

    下一节继续来完善这个框架。

    源码:

    下载:https://ww.lanzous.com/ic4j70h 密码:67vv

    欢迎大家关注我的公众号【OpenGL编程】。

    每天进步一点点,探索3D编程背后的技术细节,不再做只会“调包”的傻小白。以幽默风趣的行文风格,近乎白话文的专业知识讲解,分享3D编程的心得、教程、算法,带你走进3D编程的世界。

    展开全文
  • 在了解JPCT之前得了解什么是openglopengl是一个跨语言,跨平台的3D图形编程接口,OpenGL ES (OpenGL for ...而JPCT则是java的一款3D图形引擎,封装了opengl,jPCT-AE是jPCT在android平台上的移植版本。用opengl

    在了解JPCT之前得了解什么是opengl,opengl是一个跨语言,跨平台的3D图形编程接口,OpenGL ES (OpenGL for Embedded Systems) 是 OpenGL 三维图形 API 的子集,针对手机、PDA和游戏主机等嵌入式设备而设计。而JPCT则是java的一款3D图形引擎,封装了opengl,jPCT-AE是jPCT在android平台上的移植版本。

    用opengl的框架(或者叫做引擎)来进行android开发会比使用原本的opengl es方便许多,所以下文就参照JPCT-AE的一个官方Demo小例子进行修改,在手机上显示一个带贴图的3D模型。

    效果图

    这里写图片描述

    JPCT-AE引擎压缩包百度云链接: https://pan.baidu.com/s/1o8jyqJg 密码: ehpu,下载完解压后将lib目录下的jpct_ae.jar文件引入android studio即可。

    展开全文
  • 游戏引擎:使用OpenGL用c ++开发的游戏引擎
  • PhotonBox 一个便携式现代OpenGL游戏引擎,专注于PBR
  • 简单引擎正处于成为游戏引擎的最初阶段,或者仅仅是使用OpenGL制作游戏的框架。 简单引擎正处于成为游戏引擎的最初阶段,或者仅仅是使用OpenGL制作游戏的框架。 以下是OpenGL C引擎的功能:OpenGL 4.1:现代OpenGL,...
  • VC++开发的炮火游戏引擎,用以借鉴开发
  • 游戏引擎和用它制作的教育游戏 版本:Alpha 0.01 使用:OpenGL、SDL、CEGUI、Box2D、GLM、GLSL。 语言:英语、克罗地亚语 去做: 添加结果窗口并将结果保存到文本文件 在游戏中添加一些有关游戏的信息 TODO(将来...
  • 它具有以下功能:3D图形功能,类和包装ar 3DWorld是自2001年我在UC Berkeley参加CS184计算机图形学课程以来,我一直在开发基于跨平台的OpenGL 3D游戏引擎。它具有以下功能:OpenGL Shader生成器/周围的3D图形功能,...
  • 3D游戏引擎开发工具OpenGL

    千次阅读 2014-09-22 14:31:04
    OpenGL(全写Open Graphics Library)是个定义了一个跨编程语言、跨平台的编程接口的规格,它用于三维图象(二维的亦可)。OpenGL是个专业的图形程序接口,是一个功能强大,调用方便的底层图形库。
    OpenGL(全写Open Graphics Library)是个定义了一个跨 编程语言 、跨平台的 编程接口 的规格,它用于三维图象(二维的亦可)。OpenGL是个专业的图形 程序接口 ,是一个功能强大,调用方便的底层图形库。
     
    Silicon Graphics,Microsoft, HP,Intel达成协议联合开发下一代3D API——Fahrenheit。但不了了之,因为 微软 的打算是把OpenGL的技术用到D3D里并且以此之名驱除OpenGL的威胁。(估计DirectX 8 Graphics即是剩下 微软 独自开发的Fahrenheit,吸收了OpenGL的很多东西。)
    OpenGL豪气不减当年!
    OpenGL依然是唯一能与微软单独控制的D3D对立的API,尽管 Silicon Graphics 不再以任何微软不能接受的方式推行OpenGL。游戏开发这是独立的,并且很多关键人物在用OpenGL,因此,硬件厂商正努力提高对其支持。D3D仍不能支持高端 图像 和专业应用,而OpenGL主宰着这些土地。在开放原码社区,Mesa项目正提供独立于微软的OpenGL驱动。
     
    OpenGL开发游戏引擎
     
    方法一:

    首先获取位图句柄
    HBITMAP hBmp = (HBITMAP) ::LoadImage (AfxGetResourceHandle(),MAKEINTRESOURCE(IDB_BITMAP1), IMAGE_BITMAP, 0, 0,LR_CREATEDIBSECTION);
    然后根据位图句柄得到位图信息
    BITMAP BM;
    ::GetObject (hBmp, sizeof (BM), &BM);
    最后根据位图信息中的RGB值建立纹理
    gluBuild2DMipmaps( GL_TEXTURE_2D, 3, BM.bmWidth, BM.bmHeight,GL_BGR_EXT, GL_UNSIGNED_BYTE,BM.bmBits);
     
    方法二:

    首先用OpenGL辅助库获得位图信息
     AUX_RGBImageRec* TextureImage[1];
     TextureImage[0]=auxDIBImageLoad("1.bmp");
    然后建立纹理
     gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
     
    方法三:
    从底层做,需要了解bmp文件的结构,首先读取bmp文件结构,包括文件头、信息头和数据,数据用于后面定义纹理;

    long ImageWidth=256;
    long ImageHeight=256;
    GLubyte Image[256][256][3];
    void ReadHeader(FILE *fp , BITMAPFH * p_bitmapheader , BITMAPIH *p_bitmapinfo)
    {
    fseek(fp, 0, SEEK_SET);
    fread( &p_bitmapheader->bfType,sizeof(unsigned short), 1, fp );
    fseek(fp, 2, SEEK_SET);
    fread( &p_bitmapheader->bfSize,sizeof(unsigned long), 1, fp );
    fseek(fp, 6, SEEK_SET);
    fread( &p_bitmapheader->bfReserved1,sizeof(unsigned short), 1, fp );
    fseek(fp, 8, SEEK_SET);
    fread( &p_bitmapheader->bfReserved2,sizeof(unsigned short), 1, fp );
    fseek(fp, 10, SEEK_SET);
    fread( &p_bitmapheader->bfOffBits,sizeof(unsigned long), 1, fp );
    fseek(fp, 14, SEEK_SET);
    fread( &p_bitmapinfo->biSize, sizeof(unsigned long), 1, fp );
    fseek(fp, 18, SEEK_SET);
    fread( &p_bitmapinfo->biWidth, sizeof(unsigned long), 1, fp );

    fseek(fp, 22, SEEK_SET);
    fread( &p_bitmapinfo->biHeight, sizeof(unsigned long), 1, fp );

    fseek(fp, 26, SEEK_SET);
    fread( &p_bitmapinfo->biPlanes, sizeof(unsigned short), 1, fp );

    fseek(fp, 28, SEEK_SET);
    fread( &p_bitmapinfo->biBitCount, sizeof(unsigned short), 1, fp );

    fseek(fp, 30, SEEK_SET);
    fread( &p_bitmapinfo->biCompression, sizeof(unsigned long), 1, fp );

    fseek(fp, 34, SEEK_SET);
    fread( &p_bitmapinfo->biSizeImage, sizeof(unsigned long), 1, fp );

    fseek(fp, 38, SEEK_SET);
    fread( &p_bitmapinfo->biXPelsPerMeter, sizeof(unsigned long), 1, fp );

    fseek(fp, 42, SEEK_SET);
    fread( &p_bitmapinfo->biYPelsPerMeter, sizeof(unsigned long), 1, fp );

    fseek(fp, 46, SEEK_SET);
    fread( &p_bitmapinfo->biClrUsed, sizeof(unsigned long), 1, fp );
    fseek(fp, 50, SEEK_SET);
    fread( &p_bitmapinfo->biClrImportant, sizeof(unsigned long), 1, fp );

    }
    void ReadBitmapFile()
    {
    BITMAPFH bitmapheader;
    BITMAPIH bitmapinfo;
    FILE *fp;

    fp = fopen("6.bmp" , "r");
    if(!fp)
    {
    puts("Read file failed.");
    return;
    }

    ReadHeader(fp, &bitmapheader , &bitmapinfo);

    if(bitmapinfo.biBitCount != 24)
    {
    puts("UNSUPPORT") ;
    return;
    }
    ImageWidth = bitmapinfo.biWidth;
    ImageHeight = bitmapinfo.biHeight;

    int i=bitmapheader.bfOffBits;
    while(i<bitmapheader.bfSize)
    {
    for(int j=0;j<ImageWidth;j++)
    for(int k=0;k<ImageHeight;k++)
    {
    fseek(fp, i, SEEK_SET) ;
    fread(Image[j][k]+2, 1, 1, fp);
    fseek(fp, i+1, SEEK_SET) ;
    fread(Image[j][k]+1, 1, 1, fp);
    fseek(fp, i+2, SEEK_SET) ;
    fread(Image[j][k], 1, 1, fp);

    i=i+3;

    }

    fclose(fp) ;
    }
    90 glTexImage2D(GL_TEXTURE_2D,0,3,ImageWidth,ImageHeight,0,GL_RGB,GL_UNSIGNED_BYTE,&Image[0][0][0]);

    #include <gl\glext.h>
    这是因为后面的GL_BGR_EXT是定义在这个头文件里的,因为BMP格式是按Blue,Green,Red顺序储存图像数据的,这与OpenGL中正好相反。GL_BGR_EXT就是完成两者之间的转换的。

    下面就是不用AUX库来加载BMP图片作为纹理的函数:

     bool LoadTexture(LPTSTR szFileName, GLuint &texid)      // Creates Texture From A Bitmap File
     {
     HBITMAP hBMP;              // Handle Of The Bitmap
     BITMAP BMP;              // Bitmap Structure
     
     glGenTextures(1, &texid);           // Create The Texture
     hBMP=(HBITMAP)LoadImage(GetModuleHandle(NULL), szFileName, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE );
     
     if (!hBMP)               // Does The Bitmap Exist?
    return FALSE;             // If Not Return False

    GetObject(hBMP, sizeof(BMP), &BMP);         // Get The Object
    // hBMP:        Handle To Graphics Object
    // sizeof(BMP): Size Of Buffer For Object Information
    // &BMP:        Buffer For Object Information

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);        // Pixel Storage Mode (Word Alignment / 4 Bytes)

    // Typical Texture Generation Using Data From The Bitmap
    glBindTexture(GL_TEXTURE_2D, texid);         // Bind To The Texture ID
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Linear Min Filter
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Linear Mag Filter
    glTexImage2D(GL_TEXTURE_2D, 0, 3, BMP.bmWidth, BMP.bmHeight, 0, GL_BGR_EXT, GL_UNSIGNED_BYTE, BMP.bmBits);

    DeleteObject(hBMP);             // Delete The Object

    return TRUE;              // Loading Was Successful
    }

     

     

    OpenGL加载3d模型:
     
    OpenGL.cpp
     

    //
    #include "stdafx.h"
    #include "OpenGL.h"
    //
    GLfloat r;
    CString test;
    //
    OpenGL::OpenGL()
    { hFont  =CreateFont(-12,0,0,0,400,0,0,0,GB2312_CHARSET,0,0,0,FF_MODERN,"Arial");
     hFont0 =CreateFont(-48,0,0,0,800,0,0,0,GB2312_CHARSET,0,0,0,FF_MODERN,"黑体");
     m_Fram=0;//
     m_Time = timeGetTime();    //
     tim=0;                              //刷屏速度
     Font=new CGLFont() ;
    }
    OpenGL::~OpenGL()
    { CleanUp();
    }
    BOOL OpenGL::SetupPixelFormat(HDC hDC0)//检测安装OpenGL
    { int nPixelFormat;       // 象素点格式
     hDC=hDC0;
     PIXELFORMATDESCRIPTOR pfd = {
         sizeof(PIXELFORMATDESCRIPTOR),    // pfd结构的大小
         1,                                // 版本号
         PFD_DRAW_TO_WINDOW |              // 支持在窗口中绘图
         PFD_SUPPORT_OPENGL |              // 支持 OpenGL
         PFD_DOUBLEBUFFER,                 // 双缓存模式
         PFD_TYPE_RGBA,                    // RGBA 颜色模式
         16,                               // 24 位颜色深度
         0, 0, 0, 0, 0, 0,                 // 忽略颜色位
         0,                                // 没有非透明度缓存
         0,                                // 忽略移位位
         0,                                // 无累加缓存
         0, 0, 0, 0,                       // 忽略累加位
         16,                               // 32 位深度缓存    
         0,                                // 无模板缓存
         0,                                // 无辅助缓存
         PFD_MAIN_PLANE,                   // 主层
         0,                                // 保留
         0, 0, 0                           // 忽略层,可见性和损毁掩模
     };
     if (!(nPixelFormat = ChoosePixelFormat(hDC, &pfd)))
      { MessageBox(NULL,"没找到合适的显示模式","Error",MB_OK|MB_ICONEXCLAMATION);
           return FALSE;
      }
     SetPixelFormat(hDC,nPixelFormat,&pfd);//设置当前设备的像素点格式
     hRC = wglCreateContext(hDC);          //获取渲染描述句柄
     wglMakeCurrent(hDC, hRC);             //激活渲染描述句柄

     m_baiscobj=new baiscobj();
     m_baiscobj->light0();

     return TRUE;
    }
    void OpenGL::init(int Width, int Height)
    { glViewport(0,0,Width,Height);   // 设置OpenGL视口大小。 
     glMatrixMode(GL_PROJECTION);   // 设置当前矩阵为投影矩阵。
     glLoadIdentity();      // 重置当前指定的矩阵为单位矩阵
     gluPerspective       // 设置透视图
      ( 54.0f,       // 透视角设置为 45 度
        (GLfloat)Width/(GLfloat)Height, // 窗口的宽与高比
        0.1f,        // 视野透视深度:近点1.0f
        3000.0f       // 视野透视深度:始点0.1f远点1000.0f
      );
     // 这和照象机很类似,第一个参数设置镜头广角度,第二个参数是长宽比,后面是远近剪切。
     glMatrixMode(GL_MODELVIEW);    // 设置当前矩阵为模型视图矩阵
     glLoadIdentity();      // 重置当前指定的矩阵为单位矩阵
    // 
    //====================================================
    }
    void OpenGL::Render()//OpenGL图形处理
    { glClearColor(0.0f, 0.0f, 0.3f, 1.0f);    // 设置刷新背景色
     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);// 刷新背景
     glLoadIdentity();         // 重置当前的模型观察矩阵
    //
     m_baiscobj->DisplayScene(); 
     m_baiscobj->CreateSkyBox(3,6,3,6);
     m_baiscobj->DrawSand(); 
     srand(100);
     for(int i=0;i<300;i++)
     {float x= RAND_COORD((MAP_W-1)*MAP_SCALE);
      float z= RAND_COORD((MAP_W-1)*MAP_SCALE);
      float size=4.0f+rand()%4; 
      float h=-size/10; 
      int   cactus=rand()%4+11;
      m_baiscobj->ShowTree(x,z,size,h,cactus);
     }
     m_baiscobj->picter(MAP+10,0,-MAP); 
     m_baiscobj->Scene(0,MAP+30,13.6f,-MAP-20, 0,   0,0.35f);
     m_baiscobj->Scene(1,MAP+30,19.0f,-MAP,   100,   r,0.2f);
     m_baiscobj->Scene(2,MAP+30,20.0f,-MAP,   165,r+90,0.5f);
    //
     text();
     SwapBuffers(hDC);         // 切换缓冲区
    }
    void OpenGL::CleanUp()
    {  wglMakeCurrent(hDC, NULL);                       //清除OpenGL
      wglDeleteContext(hRC);                           //清除OpenGL

    }
    ///
    void OpenGL::text()
    { DWORD Dura =(timeGetTime()-m_Time)/1000;
     if(Dura>0) tim=m_Fram/Dura;
     m_Fram++;
     char str[128];
     sprintf(str, "刷屏: %2d 帧/秒 %s",tim,test);
     Font->settext(350,550,str,hFont,1,1,1.0f);
     Font->settext(419,258,"+",hFont,1,0,0);
    }

    OpenGL.h
     

    // OpenGL.h: interface for the OpenGL class.
    //
    //

    #if !defined(AFX_OPENGL_H__17B7289C_7956_41C5_89B9_621E3C435389__INCLUDED_)
    #define AFX_OPENGL_H__17B7289C_7956_41C5_89B9_621E3C435389__INCLUDED_

    #if _MSC_VER > 1000
    #pragma once
    #endif // _MSC_VER > 1000
    #include "baiscobj.h"
    #include "GLFont.h"
    class OpenGL 
    { public: OpenGL();
     virtual ~OpenGL();
     public:
     baiscobj* m_baiscobj;
     HDC  hDC;   // GDI设备描述表
     HGLRC hRC;      // 永久着色描述表
     BOOL SetupPixelFormat(HDC hDC);
     void init(int Width, int Height);
     void Render();
     void CleanUp();
    /
     CGLFont* Font;
     int  m_Time,m_Fram,tim;
     HFONT hFont,hFont0;
     void text();
    };

    #endif // !defined(AFX_OPENGL_H__17B7289C_7956_41C5_89B9_621E3C435389__INCLUDED_)

     

    GLFont.h

     

    // GLFont.h: interface for the CGLFont class.

    #if !defined(AFX_GLFONT_H__88F1F000_50F5_452A_B95E_60ED83712FA5__INCLUDED_)
    #define AFX_GLFONT_H__88F1F000_50F5_452A_B95E_60ED83712FA5__INCLUDED_

    #if _MSC_VER > 1000
    #pragma once
    #endif // _MSC_VER > 1000

    class CGLFont 
    {
    public:
     void entext(float x,float y, LPCTSTR str,HFONT hFont,float r,float g,float b);
     void c3dtext(LPCTSTR str,HFONT hFont,float z);
     void Printfc3d(CString strText,HFONT hFont,float z=0.05f);
     void Printftext(int x, int y, LPCTSTR lpszText,HFONT hFont);
     void settext(float x,float y,CString str,HFONT Font,float r,float g,float b);

     CGLFont();
     virtual ~CGLFont();
    protected:
     HFONT hFont;
    };

    #endif // !defined(AFX_GLFONT_H__88F1F000_50F5_452A_B95E_60ED83712FA5__INCLUDED_)

     

    GLFont.cpp
     

    #include "stdafx.h"

    #include "GLFont.h"

    #ifdef _DEBUG
    #undef THIS_FILE
    static char THIS_FILE[]=__FILE__;
    #define new DEBUG_NEW
    #endif

    //
    //unsigned int Base;
    //

    CGLFont::CGLFont()
    {
    }
    CGLFont::~CGLFont()
    {
    }
    void CGLFont::entext( float x,float y, LPCTSTR str, HFONT hFont,
           float r, float g, float b)
    {  HDC hdc = wglGetCurrentDC(); 
     SelectObject(hdc, hFont);
     unsigned int Base = glGenLists(96);
     wglUseFontBitmaps(hdc, 32, 96,Base);
     glDisable(GL_TEXTURE_2D);
     glDisable(GL_LIGHTING);
     glPushAttrib(GL_LIST_BIT); 
     glColor3f(r,g,b);
     glRasterPos2f(x/100, y/100);
      glListBase(Base - 32);
      glCallLists(strlen(str), GL_UNSIGNED_BYTE, str);
     glPopAttrib();
     glEnable(GL_LIGHTING);
     glEnable(GL_TEXTURE_2D);
     glDeleteLists(Base, 96);
    }

    //
    void CGLFont::c3dtext(LPCTSTR str,HFONT hFont,float z)
    { glDisable(GL_TEXTURE_2D);
     glDisable(GL_LIGHTING);
     Printfc3d("立体汉字",hFont,z);
     glEnable(GL_LIGHTING);  
     glEnable(GL_TEXTURE_2D);
    }
    void CGLFont::Printfc3d(CString strText,HFONT hFont,float z)
    { HDC hdc = wglGetCurrentDC();
     HFONT hOldFont=(HFONT)::SelectObject(hdc,hFont);
     UCHAR * pChar=(UCHAR*)strText.GetBuffer(strText.GetLength());
     int   nListNum; 
     DWORD dwChar; 
     GLYPHMETRICSFLOAT pgmf[1];
     glPushMatrix();  
     for(int i = 0; i < strText.GetLength(); i++)
     { if(IsDBCSLeadByte((BYTE)pChar[i]))
      { dwChar=(DWORD)((pChar[i]<<8)|pChar[i+1]);
        i++;
      }
       else dwChar = pChar[i];
       nListNum = glGenLists(1); 
       wglUseFontOutlines( hdc, 
            dwChar, 
            1,
            nListNum, 
            0.0f,
            z,
            WGL_FONT_POLYGONS,
            pgmf 
          );
       glCallList(nListNum); 
       glDeleteLists(nListNum, 1);  
     } 
     glPopMatrix();   
     strText.ReleaseBuffer();
     ::SelectObject(hdc,hOldFont);
    }

    void CGLFont:: settext (float x,float y,CString str,HFONT Font,float r,float g,float b)
     
    {   glLoadIdentity();
     glPushAttrib(GL_CURRENT_BIT);
     glDisable(GL_TEXTURE_2D);
     glDisable(GL_LIGHTING);
     glColor3f(r,g,b); 
       glTranslatef(-(420-x)/800,(260-y)/600,-1.0f);
       Printftext (0,0, str,Font);   
     glEnable(GL_LIGHTING);    
     glEnable(GL_TEXTURE_2D);
     glPopAttrib();
    }
    void CGLFont:: Printftext (int x, int y, LPCTSTR lpszText,HFONT hFont)
    { CBitmap bitmap;
      BITMAP bm;
      SIZE size;
      HDC MDC = ::CreateCompatibleDC(0);
      SelectObject(MDC,hFont); 
      ::GetTextExtentPoint32(MDC,lpszText,strlen(lpszText),&size);
      bitmap.CreateBitmap(size.cx, size.cy, 1, 1, NULL);
      HBITMAP oldBmp=(HBITMAP)SelectObject(MDC,bitmap);
      SetBkColor  (MDC, RGB(0,     0,   0));
      SetTextColor(MDC, RGB(255, 255, 255));
      TextOut(MDC, 0, 0, lpszText, strlen(lpszText));
      bitmap.GetBitmap(&bm);
      size.cx = (bm.bmWidth + 31) & (~31);
      int bufsize =size.cy * size.cx;
      struct {  BITMAPINFOHEADER bih;
       RGBQUAD col[2];
        }bic;
      BITMAPINFO *binf = (BITMAPINFO *)&bic;
      binf->bmiHeader.biSize     = sizeof(binf->bmiHeader);//
      binf->bmiHeader.biWidth    = bm.bmWidth;
      binf->bmiHeader.biHeight   = bm.bmHeight;
      binf->bmiHeader.biPlanes   = 1;  
      binf->bmiHeader.biBitCount = 1;
      binf->bmiHeader.biCompression = BI_RGB;
      binf->bmiHeader.biSizeImage   = bufsize;
      UCHAR* Bits = new UCHAR[bufsize]; 
      ::GetDIBits(MDC,bitmap,0,bm.bmHeight,Bits,binf,DIB_RGB_COLORS);
                                         
      glPixelStorei(GL_UNPACK_ALIGNMENT ,1);
      glRasterPos2i(x,y);
      glBitmap(size.cx,size.cy,0,0,0,0,Bits);
      delete Bits;   
      SelectObject(MDC, oldBmp); 
      ::DeleteDC(MDC);
    }

    BAISCOBJ.H
     

    // baiscobj.h: interface for the baiscobj class.
    //
    //

    #if !defined(AFX_BAISCOBJ_H__6F90C6A0_F5E4_4482_BA6B_136D5C922B31__INCLUDED_)
    #define AFX_BAISCOBJ_H__6F90C6A0_F5E4_4482_BA6B_136D5C922B31__INCLUDED_

    #if _MSC_VER > 1000
    #pragma once
    #endif // _MSC_VER > 1000

    class baiscobj 
    {
    public:
     baiscobj();
     virtual ~baiscobj();
    public:
     float  g_terrain [MAP_W*MAP_W][3];
     GLuint  g_index  [MAP_W*MAP_W* 2];
     float  g_texcoord [MAP_W*MAP_W][2];
     void  InitTerrain(float h); 
     void  DrawSand(); 
     float  GetHeight(float x, float z);

     float     g_eye [3];
     float     g_look[3];
     float     rad_xz; 
     float     g_Angle;
     float     g_elev; 
     BOOL  DisplayScene(); 

     UINT  g_cactus[16];
     BITMAPINFOHEADER  g_bit;
     unsigned char    *g_imageData;
     void  CreateSkyBox(int a,int wi,int he,int le);
     void  texture(UINT textur);
     void  light0();   

     void  picter(float x,float y,float z);
     bool  LoadT8(char *filename, GLuint &texture);
     void  LoadT16(char *filename, GLuint &texture);
     unsigned char* LoadBit(char *filename, BITMAPINFOHEADER *bitmap);

     void  ShowTree(float x,float z,float h,float s,int cactus);
     void  ShowTree0(float x,float z,float h,float s,int cactus);

     CLoad3DS* m_3ds;
     void load3dobj(char* dir,char* cn,int a);
     void Scene(int obj,float x,float h,float z,float r,int re,float size);
    };

    #endif // !defined(AFX_BAISCOBJ_H__6F90C6A0_F5E4_4482_BA6B_136D5C922B31__INCLUDED_)

     
    BAISCOBJ.CPP
     

    #include "stdafx.h"
    #include "baiscobj.h"
    #include "../include/BITMAP.H"

    extern GLfloat r;
    float  gao=1.8f;
    extern CString test;
    //
    baiscobj::baiscobj()
    { g_eye[0]= MAP;//
     g_eye[2]=-MAP;//
     g_Angle=0;//
     g_elev=-0;//

     char appdir[256];
     GetCurrentDirectory(256,appdir);
     CString dir=appdir;
     if(dir.Right(8)!="运行程序")
     SetCurrentDirectory("../运行程序");

     g_imageData = LoadBit("data/images/Terrain1.bmp",&g_bit); //调等高地形图
     LoadT8("data/images/sand0.bmp",  g_cactus[0]); //地面帖图
     LoadT8("data/images/4RBack.bmp",g_cactus[2]); //天空贴图后
     LoadT8("data/images/4Front.bmp",g_cactus[3]); //天空贴图前
     LoadT8("data/images/4Top.bmp",  g_cactus[4]); //天空贴图顶
     LoadT8("data/images/4Left.bmp", g_cactus[5]); //天空贴图左
     LoadT8("data/images/4Right.bmp",g_cactus[6]); //天空贴图右
     LoadT16("data/images/CACTUS0.BMP",g_cactus[11]);    //树1帖图
     LoadT16("data/images/CACTUS1.BMP",g_cactus[12]);    //树2帖图
     LoadT16("data/images/CACTUS2.BMP",g_cactus[13]);    //树3帖图
     LoadT16("data/images/CACTUS3.BMP",g_cactus[14]);    //树4帖图
     InitTerrain(5);//初始化地面
     m_3ds=new CLoad3DS();
     load3dobj("data/3ds/","航天发射台.3DS",0);
     load3dobj("data/3ds/","直升机0.3ds",1);//car.3ds
     load3dobj("data/3ds/","飞机1.3ds",2);//car.3ds
     glEnable(GL_TEXTURE_2D);
    }
    baiscobj::~baiscobj()
    { for(int i=0;i<16;i++) glDeleteTextures(1, &g_cactus[i]);
     glDisableClientState(GL_VERTEX_ARRAY);
     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    }
    void baiscobj::light0()
    { GLfloat light_position[] = {1.0,5.0,1.0,1.0};
     glLightfv(GL_LIGHT0, GL_POSITION, light_position);
     glEnable(GL_LIGHTING);
     glEnable(GL_LIGHT0);
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_COLOR_MATERIAL);
    }
    BOOL baiscobj::DisplayScene()
    { float speed=0.5f;
      float x=g_eye[0],y=g_eye[2],z=g_eye[2];
      if (KEY_DOWN(VK_SHIFT))  speed   =speed*2;
      if (KEY_DOWN(VK_LEFT))   g_Angle-=speed*2;
      if (KEY_DOWN(VK_RIGHT))  g_Angle+=speed*2;
      rad_xz = float (3.13149* g_Angle/180.0f);
      if (KEY_DOWN(33))     g_elev +=speed;
      if (KEY_DOWN(34))     g_elev -=speed;
      if (g_elev<-360)     g_elev  =-360;
      if (g_elev> 360)     g_elev  = 360;
      if (KEY_DOWN(VK_UP)) 
      { g_eye[2]+=(float)sin(rad_xz)*speed; 
        g_eye[0]+=(float)cos(rad_xz)*speed; 
      }
      if (KEY_DOWN(VK_DOWN))
      { g_eye[2]-=(float)sin(rad_xz)*speed; 
        g_eye[0]-=(float)cos(rad_xz)*speed; 
      }
      if(g_eye[0]<  MAP_SCALE)   g_eye[0]=  MAP_SCALE;
      if(g_eye[0]> (MAP_W-2)*MAP_SCALE) g_eye[0]= (MAP_W-2)*MAP_SCALE;
      if(g_eye[2]<-(MAP_W-2)*MAP_SCALE) g_eye[2]=-(MAP_W-2)*MAP_SCALE;
      if(g_eye[2]> -MAP_SCALE)   g_eye[2]= -MAP_SCALE;
      g_eye[1] =GetHeight((float)g_eye[0],(float)g_eye[2])+gao;
      g_look[0] = (float)(g_eye[0] +100*cos(rad_xz));
      g_look[2] = (float)(g_eye[2] +100*sin(rad_xz));
      g_look[1] = g_eye[1] +g_elev; 
      gluLookAt(g_eye[0],g_eye[1],g_eye[2],
       g_look[0],g_look[1],g_look[2],
       0.0,1.0,0.0 
         );
      int r0=abs((int)g_Angle);
      test.Format("[方位=%03d X=%3.0f y=%3.0f 高=%2.1f 俯仰角=%2.0f,re=%03.0f]",
        r0%360,g_eye[0],-g_eye[2],g_eye[1],g_elev,r);
      return TRUE;
    }
    //==========================================================================
    void baiscobj::InitTerrain(float h)
    { int index = 0;
      int Vertex;
      for (int z = 0; z < MAP_W; z++)
       for (int x = 0; x < MAP_W; x++)
        { Vertex = z * MAP_W + x;
          g_terrain [Vertex][0] = float(x)*MAP_SCALE;
          g_terrain [Vertex][1] = (float)(g_imageData[(z*MAP_W+x)*3]/3);
          g_terrain [Vertex][2] = -float(z)*MAP_SCALE;
          g_texcoord[Vertex][0] = (float) x;
         g_texcoord[Vertex][1] = (float) z; 
         g_index [index++] = Vertex;
         g_index [index++] = Vertex+ MAP_W;
       }
      glEnableClientState(GL_VERTEX_ARRAY); 
      glVertexPointer    (3,GL_FLOAT,0,g_terrain);
      glEnableClientState(GL_TEXTURE_COORD_ARRAY);
      glTexCoordPointer  (2,GL_FLOAT,0,g_texcoord);
    }
    void baiscobj::DrawSand()
    { glBindTexture(GL_TEXTURE_2D, g_cactus[0]);
      glTexEnvf    (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
      for (int z = 0; z < MAP_W-1; z++)
        glDrawElements(GL_TRIANGLE_STRIP,MAP_W*2,GL_UNSIGNED_INT,&g_index[z*MAP_W*2]);
    }
    float baiscobj::GetHeight(float x, float z)
    {  float CameraX = x/MAP_SCALE;
     float CameraZ =-z/MAP_SCALE; 
     int Col0 = int(CameraX); 
     int Row0 = int(CameraZ);
     int Col1 = Col0 + 1;
     int Row1 = Row0 + 1;
     if (Col1 > MAP_W) Col1 = 0;
     if (Row1 > MAP_W) Row1 = 0;
     float h00=g_terrain[Col0 + Row0*MAP_W][1];
     float h01=g_terrain[Col1 + Row0*MAP_W][1];
     float h11=g_terrain[Col1 + Row1*MAP_W][1];
     float h10=g_terrain[Col0 + Row1*MAP_W][1];
     float tx =CameraX - int(CameraX);
     float ty =CameraZ - int(CameraZ);
     float txty = tx * ty;
     return h00*(1.0f-ty-tx+txty)
       + h01*(tx-txty)
       + h11*txty
       + h10*(ty-txty);
    }
    void baiscobj::CreateSkyBox(int a,int wi,int he,int le)
    { float width =MAP*wi;
     float height=MAP*he;
     float length=MAP*le;
     float x = MAP  -width /2;
     float y = MAP/a-height/2;
     float z = -MAP -length/2;
    ///
     texture(g_cactus[2]);
     glBegin(GL_QUADS);
      glTexCoord2f(1.0f,0.0f); glVertex3f(x+width,y,   z);
      glTexCoord2f(1.0f,1.0f); glVertex3f(x+width,y+height,z);
      glTexCoord2f(0.0f,1.0f); glVertex3f(x,  y+height,z);
      glTexCoord2f(0.0f,0.0f); glVertex3f(x,  y,   z);
     glEnd();
     texture(g_cactus[3]);
     glBegin(GL_QUADS);
      glTexCoord2f(1.0f,0.0f); glVertex3f(x,  y,   z+length);
      glTexCoord2f(1.0f,1.0f); glVertex3f(x,  y+height,z+length);
      glTexCoord2f(0.0f,1.0f); glVertex3f(x+width,y+height,z+length);
      glTexCoord2f(0.0f,0.0f); glVertex3f(x+width,y,   z+length);
     glEnd();

     texture(g_cactus[4]);
     glBegin(GL_QUADS); 
      glTexCoord2f(0.0f,1.0f); glVertex3f(x+width,y+height,z);
      glTexCoord2f(0.0f,0.0f); glVertex3f(x+width,y+height,z+length);
      glTexCoord2f(1.0f,0.0f); glVertex3f(x,  y+height,z+length);
      glTexCoord2f(1.0f,1.0f); glVertex3f(x,  y+height,z);
     glEnd();
     texture(g_cactus[5]);
     glBegin(GL_QUADS);
      glTexCoord2f(1.0f,1.0f); glVertex3f(x,  y+height,z); 
      glTexCoord2f(0.0f,1.0f); glVertex3f(x,  y+height,z+length);
      glTexCoord2f(0.0f,0.0f); glVertex3f(x,  y,   z+length);
      glTexCoord2f(1.0f,0.0f); glVertex3f(x,  y,   z);  
     glEnd();
     texture(g_cactus[6]);
     glBegin(GL_QUADS);
      glTexCoord2f(0.0f,0.0f); glVertex3f(x+width,y,   z);
      glTexCoord2f(1.0f,0.0f); glVertex3f(x+width,y,   z+length);
      glTexCoord2f(1.0f,1.0f); glVertex3f(x+width,y+height,z+length);
      glTexCoord2f(0.0f,1.0f); glVertex3f(x+width,y+height,z);
     glEnd();
    }
    void baiscobj::texture(UINT textur)
    { glBindTexture  (GL_TEXTURE_2D, textur);
     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_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
    }
    //==========================================================================
    void baiscobj::picter(float x,float y,float z)
    {y=GetHeight(x,z);
    glDisable(GL_TEXTURE_2D);
     glPushAttrib(GL_CURRENT_BIT);
     glPushMatrix();
     glTranslatef(x,y+0.5f,z);
     glColor3f(0.0f,1.0f,0.2f);
     auxSolidCube(1);
     glTranslatef(0.0f,0.8f,0.0f);
     glColor3f(0.0f,0.0f,1.0f);
     auxSolidBox(.2f,1.3f,.2f);
     glPopMatrix();
     glPushMatrix();
     glTranslatef(x,y+2.5f,z);
     glRotatef(r-90,0.0,1.0,0.0);
     //=======================================
     glColor3f(1.0f,1.0f,1.0f);
     glRotatef(45, 1.0, 0.0, 0.0);
     auxWireCone(1.5,0.6f); 
     //=======================================
     glRotatef(180, 1.0, 0.0, 0.0);
     glTranslatef(0.0f,0.0f,-0.7f);
     auxWireCone(0.2f,2.0f); 
     glColor3f(FRAND,0,0);
     glTranslatef(0.0f,0.0f,2.0f);
     auxSolidSphere(0.1f);
     glPopMatrix();
     glPushMatrix();
     glTranslatef(x,y+10.0f,z);
     glRotatef(r, 0.0, 1.0, 0.0);
     glTranslatef(x/15,0,0);
     //=============================================
     glColor3f(1.0f,0.0f,0.0f);
     glRotatef(180, 0.0, 1.0, 0.0);
     auxSolidCone(.2,0.6);
     //=============================================
     glColor3f(1.0f,1.0f,1.0f);
     glRotatef(90, 1.0, 0.0, 0.0);
     glTranslatef(0.0f,-1.0f,0); 
     auxSolidCylinder(.2f,1);
     glRotatef(-270, 1.0, 0.0, 0.0);
     glColor3f(FRAND+.6f,0.2f,0.0f);
     glTranslatef(0.0f,-0.0f,-0.2f);
     auxSolidCone(.2,1.5);
     glPopMatrix();
     glEnable(GL_TEXTURE_2D);
     glPopAttrib();
     r+=1.0f;if(r>360) r=0;
     glEnable(GL_TEXTURE_2D);
    }
    bool baiscobj::LoadT8(char *filename, GLuint &texture)
    { AUX_RGBImageRec *pImage = NULL;
     pImage = auxDIBImageLoad(filename);
     if(pImage == NULL)  return false;
     glGenTextures(1, &texture); 
     glBindTexture    (GL_TEXTURE_2D,texture);
     gluBuild2DMipmaps(GL_TEXTURE_2D,4, pImage->sizeX,
           pImage->sizeY,GL_RGB, GL_UNSIGNED_BYTE,pImage->data);
     free(pImage->data);
     free(pImage); 
     return true;
    }
    void baiscobj::LoadT16(char *filename, GLuint &texture)
    { glGenTextures(1, &texture); 
      glBindTexture(GL_TEXTURE_2D, texture);
      BITMAPINFOHEADER bitHeader;
      unsigned char *buffer; 
      buffer=LoadBitmapFileWithAlpha(filename,&bitHeader);
      gluBuild2DMipmaps ( GL_TEXTURE_2D, 
           4,   
           bitHeader.biWidth,
           bitHeader.biHeight,
           GL_RGBA,
           GL_UNSIGNED_BYTE,
           buffer 
         );
      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_MIN_FILTER,GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
      free(buffer); 
    }
    unsigned char * baiscobj::LoadBit(char *filename, BITMAPINFOHEADER *bitmap)
    { FILE *filePtr; 
      BITMAPFILEHEADER  Header;
      unsigned char    *Image;
      unsigned int      imageIdx = 0;
      unsigned char     tempRGB; 
      filePtr = fopen(filename, "rb");
      if (filePtr == NULL)    return NULL;
      fread(&Header, sizeof(BITMAPFILEHEADER), 1, filePtr);
      if (Header.bfType != BITMAP_ID)
      { fclose(filePtr);
        return NULL;
      }
      fread(bitmap, sizeof(BITMAPINFOHEADER), 1, filePtr);
      fseek(filePtr, Header.bfOffBits, SEEK_SET);
      Image = (unsigned char*)malloc(bitmap->biSizeImage);
      if (!Image)
      { free(Image);
        fclose(filePtr);
        return NULL;
      }
      fread(Image, 1, bitmap->biSizeImage, filePtr);
      if (Image == NULL)
      { fclose(filePtr);
        return NULL;
      }
      for (imageIdx = 0; imageIdx < bitmap->biSizeImage; imageIdx+=3)
      { tempRGB = Image[imageIdx];
        Image[imageIdx] = Image[imageIdx + 2];
        Image[imageIdx + 2] = tempRGB;
      }
      fclose(filePtr);
      return Image;
    }
    /
    void baiscobj::ShowTree(float x,float z,float h,float s,int cactus)
    { glEnable(GL_BLEND);
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
      glEnable(GL_ALPHA_TEST);
      glAlphaFunc(GL_GREATER, 0);
      float mat[16];
      glGetFloatv(GL_MODELVIEW_MATRIX, mat);
      vector3_t X(mat[0], mat[4], mat[8]);
      vector3_t Z(mat[1], mat[5], mat[9]);
      glBindTexture(GL_TEXTURE_2D, g_cactus[cactus]);
      vector3_t pos(x,0.0,-z);
      pos.y = GetHeight(x, -z) + h + s;
      glBegin(GL_QUADS);
      glTexCoord2f(0.0,0.0);glVertex3fv((pos+(X+Z)*-h).v);//左下点
      glTexCoord2f(1.0,0.0);glVertex3fv((pos+(X-Z)* h).v);//右下点
      glTexCoord2f(1.0,1.0);glVertex3fv((pos+(X+Z)* h).v);//右上点
      glTexCoord2f(0.0,1.0);glVertex3fv((pos+(Z-X)* h).v);//左上点
      glEnd();
      glDisable(GL_ALPHA);
      glDisable(GL_BLEND);
    }
    void baiscobj::ShowTree0(float x,float z,float h,float s,int cactus)
    { glPushMatrix();//
      float y = GetHeight(x,-z) + h + s;
      glTranslatef(x,y, -z);
      glRotatef(180, 1.0, 0.0, 0.0);
      glEnable(GL_BLEND);
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
      glEnable(GL_ALPHA_TEST);
      glAlphaFunc(GL_GREATER, 0);
     glBindTexture(GL_TEXTURE_2D, g_cactus[cactus]);
    // glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);//
     glBegin(GL_QUADS);
      glTexCoord2f(1.0f, 0.0f); glVertex3f(-h, h, 0.0f);  // 右上点
      glTexCoord2f(0.0f, 0.0f); glVertex3f( h, h, 0.0f);  // 右上点
      glTexCoord2f(0.0f, 1.0f); glVertex3f( h,-h, 0.0f);  // 右下点
      glTexCoord2f(1.0f, 1.0f); glVertex3f(-h,-h, 0.0f);  // 左下点
     glEnd();
      glDisable(GL_ALPHA);
      glDisable(GL_BLEND);
      glPopMatrix();
    }

    void baiscobj::load3dobj(char* dir,char* cn,int a)
    { char appdir[256];
     GetCurrentDirectory(256,appdir);
     SetCurrentDirectory(dir);
     m_3ds->Init(cn,a);
     SetCurrentDirectory(appdir);
    }
    void baiscobj::Scene(int obj,float x,float h,float z,float r,int re,float size)
    {
      glPushMatrix();
      int y=GetHeight(x,z)+h;
      glTranslatef(x,y,z);
      glRotatef(re, 0.0, 1.0, 0.0);
      if(obj>0) glRotatef(-20, 1.0, 0.0, 0.0);
      m_3ds->show3ds(obj,0,0.0f,r,size);
      glPopMatrix();
    }

     
    main.cpp
     

    #include "stdafx.h"
    #include "OpenGL.h"
    //
    OpenGL* m_OpenGL;
    HDC  hDC;  // GDI设备句柄,将窗口连接到 GDI( 图形设备接口)
    HGLRC hRC=NULL; // 渲染描述句柄,将OpenGL调用连接到设备描述表
    HWND hWnd=NULL; // 保存 Windows 分配给程序的窗口句柄
    int  Width = 800;// 窗口宽
    int  Height= 600;// 窗口高
    int  bits  = 16; // 颜色深度


    void GameLoop()
    {   MSG msg;
        BOOL fMessage;
        PeekMessage(&msg, NULL, 0U, 0U, PM_NOREMOVE);
        while(msg.message != WM_QUIT) // 消息循环
        {   fMessage = PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE);
            if(fMessage)    //有消息
       { TranslateMessage(&msg);
                  DispatchMessage(&msg);
       }
            else  m_OpenGL->Render(); //无消息
        }
    }
    LRESULT WINAPI MsgProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam )// 消息处理
    { switch(message)
     { case WM_CREATE:      // 建立窗口
       hDC = GetDC(hWnd);    // 获取当前窗口的设备句柄
       m_OpenGL->SetupPixelFormat(hDC);// 调用显示模式安装功能
       return 0;  break;
      case WM_CLOSE:      // 关闭窗口
       m_OpenGL->CleanUp();   // 结束处理
       PostQuitMessage(0);
       return 0;  break;
      case WM_SIZE:      // 窗口尺寸变化
       Height = HIWORD(lParam);  // 窗口的高
       Width  = LOWORD(lParam);  // 窗口的宽
       if (Height==0) Height=1;  // 防止被0 除
       m_OpenGL->init(Width,Height);
       return 0;  break;
      case WM_DESTROY:     // 退出消息
                PostQuitMessage(0);
                return 0;  break;

            case WM_KEYUP:      // 按ESC退出,全屏模式必需要加入的退出方式。
                switch (wParam)
                { case VK_ESCAPE:
         m_OpenGL->CleanUp(); // 结束处理
            PostQuitMessage(0);
            return 0;break;
                }
      default:   break;
     }
     return (DefWindowProc(hWnd, message, wParam, lParam));
    }
    INT WINAPI WinMain(HINSTANCE hInst,HINSTANCE,LPSTR,INT )// WinMain程序入口
    {   // 注册窗口类
     bool fullScreen =TRUE;
     DWORD dwExStyle;  // Window 扩展风格
     DWORD dwStyle;  // Window 窗口风格
     RECT windowRect;  // 窗口尺寸
     int  nX=0,nY=0;
    /* if (MessageBox(NULL,"使用全屏模式吗?", "将进入OpenGL,选择显示模式",
                 MB_YESNO|MB_ICONQUESTION|MB_SYSTEMMODAL)==IDNO)
      {fullScreen =false;}   // 选择窗口模式
     if (fullScreen)      // 选择全屏模式
     { DEVMODE dmScr;     // 设备模式
      memset(&dmScr,0,sizeof(dmScr)); // 确保内存分配
      dmScr.dmSize=sizeof(dmScr);  // Devmode 结构的大小
      dmScr.dmPelsWidth = Width;  // 屏幕宽
      dmScr.dmPelsHeight= Height;  // 屏幕高
      dmScr.dmBitsPerPel= 16;   // 色彩深度
      dmScr.dmDisplayFrequency=75; // 刷屏速度
      dmScr.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT|DM_DISPLAYFREQUENCY;
      if (ChangeDisplaySettings(&dmScr, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
       {fullScreen=FALSE;}
      dwExStyle=WS_EX_APPWINDOW;  // Window 扩展风格
      dwStyle=WS_POPUP;    // Window 窗口风格
      ShowCursor(FALSE);    // 隐藏鼠标
     }
     else*/
     { dwExStyle=WS_EX_APPWINDOW|WS_EX_WINDOWEDGE; // 使窗口具有3D外观
      dwStyle=WS_OVERLAPPEDWINDOW;    // 使用标准窗口
      //WS_OVERLAPPEDWINDOW是有标题栏,窗口菜单,最大、小化按钮和可调整尺寸的窗口
      int wid=GetSystemMetrics(SM_CXSCREEN);  // 获取当前屏幕宽
      int hei=GetSystemMetrics(SM_CYSCREEN);  // 获取当前屏幕高
      nX=(wid-Width)/2;nY=(hei-Height)/2;   // 计算窗口居中用
     }
    //-------------------------------------------------------------------
     AdjustWindowRectEx(&windowRect,dwStyle,FALSE,dwExStyle);
             //根据窗口风格来调整窗口尺寸达到要求的大小
     char cc[]="tml";
        WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
                          GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                          cc, NULL };
        RegisterClassEx( &wc );
     m_OpenGL=new OpenGL();//
     hWnd = CreateWindowEx(NULL,cc,"学OpenGL编3D游戏 [ 8.显示3D模型 ]          键盘(↑进 ↓退 →右 ←左 UP仰 DOWM俯)",
            dwStyle|WS_CLIPCHILDREN|WS_CLIPSIBLINGS,
            nX, nY,Width, Height,
            NULL,NULL,hInst,NULL); // 创建窗口
     ShowWindow( hWnd, SW_SHOWDEFAULT );    // 显示窗口
     UpdateWindow( hWnd );       // 刷新窗口
     GameLoop();          // 进入消息循环
        return 0;
    }

    展开全文
  • OpenGL游戏开发 .zip

    2020-02-23 21:05:49
    OpenGL变换、OpenGL光照、材质和纹理、OpenGL字体、摄像漫游、构造开空和地形、模型载入、实时阴影、DirectInput的使用、DirectSound的使用、游戏中的物理模拟、粒子系统、构造游戏引擎、3DRPG游戏、Quake室内场景...
  • Ax是用C ++编写的小型渲染“引擎”,可帮助抽象一些创建2D / 3D可视化所需的较低级别的OpenGL样板。 该项目的个人目标是: 了解有关数学/线性代数的更多信息 创建一个可用的C ++项目以帮助进行可视化 了解有关现代...
  • 上层实现了简化的排版引擎,而JS / JSX r ngui Ngui是跨平台(Android / iOS)前端开发框架。 核心代码是用C ++编写的。 底层基于OpenGL绘图。 上层实现了简化的排版引擎和JS / JSX运行环境。 目标是在此基础上开发...
  • LibGDX游戏引擎开发教程】第01期:LibGDX的详细介绍  博主在大学里学的专业就是软件开发与游戏设计,所以对于游戏这个行业一直都有着浓厚的兴趣,却因为 阴差阳错,又或许是缘分不够吧。一直都没有...
  • OpenGL实用开发工具库

    2011-05-07 10:51:19
    OpenGL是强大的渲染引擎,配合Physx这样的物理引擎,你就会知道我们常见的3D有戏开发是多么的简单,这个是OpenGL的实用工具库。OpenGL支持多平台,一般OpenGl的窗口界面实现可以有glut、MFC或者是win32 SDK来开发
  • 最近由于手机项目中需要用到OpenGL ES的知识,所以这段时间正在研究OpenGL的相关知识。因为OpenGL ES是OpenGL的剪裁版本,所以我直接从OpenGL入手,... 那么今天我要介绍的是OpenGL开发之旅基础知识介绍,这很重要,
  • 本教程可以带领大家从一个普通的Android应用开发者进入3D应用的世界,从3D应用开发基础知识开始,完成受众多手机用户所喜爱的3D应用的开发
  • 基于opengl的游戏引擎

    千次阅读 2017-05-21 22:44:02
    今天主要先学习一下opengl的基本知识,对opengl进行进一步的...我们可以使用OpenGL开发出运行效率较高的图形程序或游戏,因为OpenGL非常接近底层硬件并且OpenGL使得我们不必去关注图形硬件的细节。既然我们开发人员不必
  • 最近由于手机项目中需要用到OpenGL ES的知识,所以这段时间正在研究OpenGL的相关知识。因为OpenGL ES是OpenGL的剪裁版本,所以我直接从OpenGL入手,... 那么今天我要介绍的是OpenGL开发之旅基础知识介绍,这很重要,
  • Permafrost Engine是用C语言编写的OpenGL 3.3实时策略游戏引擎。它以旧经典的形象制成,但融合了一些现代思想。 引擎展示 EVERGLORY是使用Permafrost Engine开发的旗舰游戏。 引擎摘要 OpenGL 3.3可编程管道(在...
  • 引言 ...当然这都依赖于 OpenGL 这个东西来渲染(因为物理引擎本身都是一些计算,没有可视化的东西,需要借助渲染层将其可视化),这里先搭一个可以在 Windows 下编写 OpenGL 程序的架子,然后再往...
  • Android 3D游戏开发(基础篇)——Opengl ES游戏引擎实现(送源码)课程描述: 本教程可以带领大家从一个普通的Android应用开发者进入3D应用的世界,从3D应用开发基础知识开始,完成受众多手机用户所喜爱的3D应用的...
  • TowerEngine是由FlorianMärkl/ Metallic Entertainment开发的基于OpenGL的跨平台游戏引擎。 它可以通过GPLv3许可获得。 请注意,此引擎主要是为我自己的项目开发的,而不是用于其他游戏。 当前在“ Psychosis”...
  • 基于openGL编写的渲染引擎 有光照,环境贴图,法线贴图效果 可实现车门打开的动画效果 用于3d全景环视的倒车系统 如有项目合作需求,欢迎来信咨询。kfc1146794539@163.com
  • 学习OpenGL 个人项目,只需学习OPENGL和图形编程。 最终它将成为一个功能全面的游戏引擎。 设置了用于形状和纹理的着色器以及基本的渲染引擎。 为了方便起见,还对代码进行了抽象。 (仅适用于Windows和msvc)
  • 处于早期开发阶段的跨平台2D C ++ / OpenGL游戏引擎。 当前功能: 批量渲染 精灵表 动画制作 粒子 帧缓冲 使用很棒的字体进行位图字体渲染 TTF字体渲染 响应式音频流 平台物理学 简单网格物理学 Lua脚本 序列化 ...
  • C++ gui QT4 OPENGL 开发2

    千次阅读 2009-01-21 10:44:00
    2D绘图是根据X,Y坐标直接在屏幕上作图,而3D绘图是根据X,Y,Z三维坐标在立体空间创造物体,然后根据指定的视觉角度映射在屏幕上,也就是我们可以在不同的角度观察创建的物体,在OPENGL及其他3D引擎中,我们只需要...
  • KlayGE是基于OPENGL的3D游戏引擎之一,采用Pure C++开发,编译方法可以参照网络上的文档,效果一流的棒。
  • 编辑推荐  国内第一部Android 3D游戏开发视频 课程内容  本教程可以带领大家从一个普通的Android应用开发者进入3D应用的世界,从3D应用开发基础知识开始...2:引擎框架(引擎整体构架,NDK框架) 3:工具 4:摄像机

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,732
精华内容 9,892
关键字:

opengl开发引擎