OpenGL5-纹理贴图

代码下载

#include "CELLWinApp.hpp"
#include <gl/GLU.h>
#include <assert.h>
#include <math.h>
#pragma comment(lib,"opengl32.lib")
#pragma comment(lib,"glu32.lib")
#pragma comment(lib,"winmm.lib")

/**
* 经过上几个例子的了解，这一例子介绍OpenGL坐标系
OpenGL使用右手坐标

坐标是OpenGL中用来描述场景的坐标，
Z+轴垂直屏幕向外
，X+从左到右，
Y+轴从下到上，
是右手笛卡尔坐标系统,
我们用这个坐标系来描述物体位置.
即:
从左到右，x递增
从下到上，y递增
从远到近，z递增
坐标系以屏幕中心为原点(0, 0, 0)。你面对屏幕，你的右边是x正轴，上面是y正轴，屏幕指向你的为z正轴

*/

/**
* 纹理坐标，也是这个例子的重点。
* 本节课介绍最常用的，也做好理解的2D纹理坐标
* 实际上就是给一个面贴上一个图片。
首先看下纹理坐标的定义
下面是一个图片,图片的左上角的坐标定义为 0 ,0,（三维中中术语 u(x),v(y)坐标）
u,v(0，0)                             u,v(1,0)
-----------------------------
|                                      |
|                                      |
|                                      |
|                                      |
|                                      |
-----------------------------
u,v(0,1)                             u,v(1,1)
*/
/**
* 顶点结构声明,u,v作弊啊飘
*/
struct Vertex
{
/**
* u,v坐标
*/
float u,v;
/**
* 顶点坐标
*/
float x, y, z;
};

Vertex g_cubeVertices[] =
{
{ 0, 0, -1.0f,-1.0f, 1.0f },
{ 1, 0, 1.0f,-1.0f, 1.0f },
{ 1, 1, 1.0f, 1.0f, 1.0f },
{ 0, 1, -1.0f, 1.0f, 1.0f },

{ 0, 0, -1.0f,-1.0f,-1.0f },
{ 1, 0, -1.0f, 1.0f,-1.0f },
{ 1, 1, 1.0f, 1.0f,-1.0f },
{ 0, 1, 1.0f,-1.0f,-1.0f },

{ 0, 0, -1.0f, 1.0f,-1.0f },
{ 1, 0, -1.0f, 1.0f, 1.0f },
{ 1, 1, 1.0f, 1.0f, 1.0f },
{ 0, 1, 1.0f, 1.0f,-1.0f },

{ 0, 0, -1.0f,-1.0f,-1.0f },
{ 1, 0, 1.0f,-1.0f,-1.0f },
{ 1, 1, 1.0f,-1.0f, 1.0f },
{ 0, 1, -1.0f,-1.0f, 1.0f },

{ 0, 0, 1.0f,-1.0f,-1.0f },
{ 1, 0, 1.0f, 1.0f,-1.0f },
{ 1, 1, 1.0f, 1.0f, 1.0f },
{ 0, 1, 1.0f,-1.0f, 1.0f },

{ 0, 0, -1.0f,-1.0f,-1.0f },
{ 1, 0, -1.0f,-1.0f, 1.0f },
{ 1, 1, -1.0f, 1.0f, 1.0f },
{ 0, 1, -1.0f, 1.0f,-1.0f }
};

class Tutorial5 :public CELL::Graphy::CELLWinApp
{
public:
Tutorial5(HINSTANCE hInstance)
:CELL::Graphy::CELLWinApp(hInstance)
,_primitiveType(GL_POINTS)
{
}
virtual void render()
{
do
{
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

static float fXrot = 0.0f;
static float fYrot = 0.0f;
static float fZrot = 0.0f;
/**
* 获取一帧绘制的时间
*/
static DWORD dwBegin = timeGetTime();

float fElpased = float(timeGetTime() - dwBegin) * 0.001f;
dwBegin = timeGetTime();

/**
* 三个方向上，x轴，y轴，z轴，同时旋转
*/

float rotSpeed = 90;

fXrot += rotSpeed * fElpased;
fYrot += rotSpeed * fElpased;
fZrot += rotSpeed * fElpased;

/**
* 指明，要操作的矩阵是模型矩阵
*/
glMatrixMode( GL_MODELVIEW );
/**
* 将模型矩阵清空为单位矩阵,对角线为1的矩阵为单位矩阵，其意义是
* 单位矩阵与定点作用，或者与其他的矩阵做乘法，结果不变
float modelView[4][4] =
{
1,0,0,0
0,1,0,0,
0,0,1,0,
0,0,0,1
};
*/

glLoadIdentity();
/**
* 移动模型矩阵 model view,
* glTranslatef( x, y, z );
* 做了改操作以后，矩阵变为
float modelView[4][4] =
{
1,0,0,0
0,1,0,0,
0,0,1,0,
x,y,z,1
};
*/
glTranslatef( 0.0f, 0.0f, -5.0f );
/**
* 可以调用
* float mat[4][4];
* glGetFloatv(GL_PROJECTION_MATRIX,(float*)mat);
*/

float mat[4][4];
glGetFloatv(GL_MODELVIEW_MATRIX,(float*)mat);
/**
* 进行旋转，将更改modelview 矩阵
*/
glRotatef( fXrot, 1.0f, 0.0f, 0.0f );
glRotatef( fYrot, 0.0f, 1.0f, 0.0f );
glRotatef( fZrot, 0.0f, 0.0f, 1.0f );

/**
* 矩阵将被应用到绘制的的定点上。
* 实际上进行的操作就是 g_cubeVertices 数组中每一个点与矩阵进行相乘，得到新的定点。
* 这个操作是在显卡中完成。所以速度很快。
* 当然，在显卡上，不止是与modelview矩阵相乘，还要和，投影矩阵和观察矩阵进行相乘，
* 就是 MVP * vertex ;
* M = model matrix
* V = view matrix
* P = Project matrix
*/

/**
* 使用纹理
*/
glBindTexture(GL_TEXTURE_2D,_textureId);
glInterleavedArrays( GL_T2F_V3F, 0, g_cubeVertices );
glDrawArrays( GL_QUADS, 0, 24 );

SwapBuffers( _hDC );
} while (false);
}

/**
* 生成投影矩阵
* 后面为了重用性，我们会写一个专门的matrix类，完成矩阵的一系列擦做
* 这个是很有必须要的，当你对Opengl了解的不断深入，你会发现，很多都是和数学有关的
*/
void perspective(float fovy,float aspect,float zNear,float zFar,float matrix[4][4])
{
assert(aspect != float(0));
assert(zFar != zNear);
#define PI 3.14159265358979323f

float rad = fovy * (PI / 180);

float halfFovy = tan(rad / float(2));
matrix[0][0] = float(1) / (aspect * halfFovy);
matrix[1][1] = float(1) / (halfFovy);
matrix[2][2] = -(zFar + zNear) / (zFar - zNear);
matrix[2][3] = -float(1);
matrix[3][2] = -(float(2) * zFar * zNear) / (zFar - zNear);
#undef PI
}
virtual void onInit()
{
/**
* 调用父类的函数。
*/
CELL::Graphy::CELLWinApp::onInit();
/**
* 设置Opengl的投影方式,改例子里面，我们使用正交投影
* OpenGL的投影方式有两种(我知道的):正交，和透视，有兴趣的可以google下
* 这里采用的窗口坐标系，与Windows窗口坐标一直，左上角为 0,0,右下角为 _winWidth,_winHeight
* 这种投影下绘制出来的物体没有三维感
*/
//glOrtho(0,_winWidth,_winHeight,0,1,-1);
//! 修改投影方式-透视投影,
//! 指定我们要进行操作的矩阵，OpenGL是一个状态机，所以要操作那一个状态的时候，需要进行切换
//! 下面的这句话就是切换到投影矩阵上
//! gluPerspective细节实现，参照下面的网址:http://www.opengl.org/sdk/docs/man2/xhtml/gluPerspective.xml

glMatrixMode( GL_PROJECTION );
#if 0

glLoadIdentity();
gluPerspective( 45.0, (GLdouble)_winWidth / (GLdouble)_winHeight, 0.1, 100.0);

float mat[4][4];
glGetFloatv(GL_PROJECTION_MATRIX,(float*)mat);

#else
//! 这里我们也可以自己按照Opengl的投影方式生成一个投影矩阵，
//! 然后将投影矩阵给OpenGL
GLfloat matrix[4][4] =
{
0,0,0,0,
0,0,0,0,
0,0,0,0,
0,0,0,0
};
perspective(45.0f, (GLfloat)_winWidth / (GLfloat)_winHeight, 0.1f, 100.0f,matrix);
glLoadMatrixf((float*)matrix);
#endif
glClearColor(0,0,0,1);

/**
* 增加如下两句话
* glEnable(GL_DEPTH_TEST); 启动深度测试，这样，有遮挡计算，被遮盖的将覆盖
* glEnable(GL_TEXTURE_2D); 启动纹理，支持纹理贴图，这样才可以绘制纹理出来
*/
glEnable(GL_DEPTH_TEST);
glEnable(GL_TEXTURE_2D);
/**
* 读一个bmp图片
*/
HBITMAP hBmp = (HBITMAP)LoadImageA(0,"1.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
/**
* 获取图片的大小
*/
BITMAP bmpInf = {0};
GetObject(hBmp,sizeof(bmpInf),&bmpInf);
/**
* 获取图片的颜色数据(r,g,b)
*/
int size = bmpInf.bmHeight * bmpInf.bmWidth * 3;
char* data = new char[size];

BITMAPINFO bi;
bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
bi.bmiHeader.biWidth = bmpInf.bmWidth;
bi.bmiHeader.biHeight = bmpInf.bmHeight;
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biBitCount = 24;
bi.bmiHeader.biCompression = BI_RGB;
bi.bmiHeader.biSizeImage = size;
bi.bmiHeader.biClrUsed = 0;
bi.bmiHeader.biClrImportant = 0;

/**
* 获取rgb数据
*/
int idata = GetDIBits(_hDC,hBmp,0,bi.bmiHeader.biHeight,data,&bi,DIB_RGB_COLORS);

/**
* 产生一个纹理Id,可以认为是纹理句柄，后面的操作将书用这个纹理id
*/
glGenTextures( 1, &_textureId );

/**
* 使用这个纹理id,或者叫绑定(关联)
*/
glBindTexture( GL_TEXTURE_2D, _textureId );
/**
* 指定纹理的放大,缩小滤波，使用线性方式，即当图片放大的时候插值方式
*/
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
/**
* 将图片的rgb数据上传给opengl.
*/
glTexImage2D(
GL_TEXTURE_2D, //! 指定是二维图片
0, //! 指定为第一级别，纹理可以做mipmap,即lod,离近的就采用级别大的，远则使用较小的纹理
GL_RGB, //! 纹理的使用的存储格式
bmpInf.bmWidth, //! 宽度，老一点的显卡，不支持不规则的纹理，即宽度和高度不是2^n。
bmpInf.bmHeight, //! 宽度，老一点的显卡，不支持不规则的纹理，即宽度和高度不是2^n。
0, //! 是否的边
GL_BGR_EXT, //! 数据的格式，bmp中，windows,操作系统中存储的数据是bgr格式
GL_UNSIGNED_BYTE, //! 数据是8bit数据
data
);
delete []data;
/**
* 删除图片
*/
DeleteObject(hBmp);

}

virtual int events(unsigned msg, unsigned wParam, unsigned lParam)
{
switch(msg)
{
case WM_KEYDOWN:
{
if (wParam == 'S' ||wParam == 'S')
{
_primitiveType += 1;
if (_primitiveType >=GL_POLYGON )
{
_primitiveType = 0;
}
}
}
break;
}
return __super::events(msg,wParam,lParam);
}
protected:
unsigned _primitiveType;
/**
* 保存纹理Id
*/
unsigned _textureId;
};

int CALLBACK _tWinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nShowCmd
)
{
(void*)hInstance;
(void*)hPrevInstance;
(void*)lpCmdLine;
(void*)nShowCmd;

Tutorial5 winApp(hInstance);
winApp.start(640,480);
return 0;
}