oglutil.cpp

3D赛车游戏源代码-用Visual Studio 2005

#include "StdAfx.h"
#include "OGLutil.h"	

//-------------------------------------------------------------------------------
// CDisplay类的构造函数
//-------------------------------------------------------------------------------
CDisplay::CDisplay()
{
	m_hRC = NULL;
	m_hDC = NULL;
	m_hWnd = NULL;
	m_bWindowed = false;
}

//-------------------------------------------------------------------------------
// CDisplay类的构造函数
//-------------------------------------------------------------------------------
CDisplay::~CDisplay()
{
}

//-------------------------------------------------------------------------------
// 创建全屏模式窗口
//-------------------------------------------------------------------------------
bool CDisplay::CreateFullScreenDisplay(HWND hWnd, DWORD dwWidth, DWORD dwHeight, DWORD dwBpp)
{
	return true;
}

//-------------------------------------------------------------------------------
// 创建窗口模式窗口
//-------------------------------------------------------------------------------
bool CDisplay::CreateWindowedDisplay(HWND hWnd, DWORD dwWidth, DWORD dwHeight)
{
	GLuint		PixelFormat = 0;
	GLuint		bits = 16;

	m_hWnd	= hWnd;
	m_bWindowed = true;

	static	PIXELFORMATDESCRIPTOR pfd=				
	{
		sizeof(PIXELFORMATDESCRIPTOR),			
		1,									
		PFD_DRAW_TO_WINDOW |				
		PFD_SUPPORT_OPENGL |			
		PFD_DOUBLEBUFFER,				
		PFD_TYPE_RGBA,					
		bits,							
		0, 0, 0, 0, 0, 0,				
		0,								
		0,								
		0,										
		0, 0, 0, 0,						
		16,									
		0,										
		0,										
		PFD_MAIN_PLANE,						
		0,										
		0, 0, 0										
	};
	
	if (!(m_hDC = GetDC(m_hWnd)))
	{
		return false;
	}

	if (!(PixelFormat = ChoosePixelFormat(m_hDC, &pfd)))	
	{
		return false;
	}

	if (!SetPixelFormat(m_hDC, PixelFormat, &pfd))	
	{
		return false;
	}

	if (!(m_hRC=wglCreateContext(m_hDC)))			
	{
		return false;
	}

	if (!wglMakeCurrent(m_hDC,m_hRC))				
	{
		return false;
	}

	ResizeScene(dwWidth, dwHeight);
	Init();
	return true;
}

//-------------------------------------------------------------------------------
// 摧毁
//-------------------------------------------------------------------------------
bool CDisplay::DestroyObjects()
{
	Term();
	return true;
}

//-------------------------------------------------------------------------------
// 初始化
//-------------------------------------------------------------------------------
bool CDisplay::Init()
{
	glShadeModel(GL_SMOOTH);					
	glClearColor(0.0f, 0.0f, 0.0f, 0.5f);		
	glClearDepth(1.0f);							
	glEnable(GL_DEPTH_TEST);					
	glDepthFunc(GL_LEQUAL);						
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	return true;	
}

//-------------------------------------------------------------------------------
// 结束
//-------------------------------------------------------------------------------
bool CDisplay::Term()
{
	if (!m_bWindowed)						
	{
		ChangeDisplaySettings(NULL,0);		
		ShowCursor(TRUE);
		m_bWindowed = true;
	}

	if (m_hRC)							
	{
		wglMakeCurrent(NULL,NULL);			
		wglDeleteContext(m_hRC);				
		m_hRC = NULL;
	}

	if (m_hDC)	
	{
		ReleaseDC(m_hWnd, m_hDC);
		m_hDC = NULL;
	}
	return true;
}

//-------------------------------------------------------------------------------
// 重置窗口大小
//-------------------------------------------------------------------------------
void CDisplay::ResizeScene(GLsizei width, GLsizei height)
{
	if (height == 0)			
	{
		height = 1;			
	}

	glViewport(0, 0, width, height);	

	glMatrixMode(GL_PROJECTION);	
	glLoadIdentity();				

	//gluPerspective(90.0f, (GLfloat)width / (GLfloat)height, 1.f, 1800.0f);
	gluPerspective(56.0f, (GLfloat)width / (GLfloat)height, 1.f, 1800.0f);

	glMatrixMode(GL_MODELVIEW);		
	glLoadIdentity();		
}

//-------------------------------------------------------------------------------
// 开始绘制
//-------------------------------------------------------------------------------
void CDisplay::BeginDraw()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	
	glLoadIdentity();	
	glDisable(GL_TEXTURE_2D);
	glColor3ub(255, 255, 255);
}

//-------------------------------------------------------------------------------
// 结束绘制
//-------------------------------------------------------------------------------
void CDisplay::EndDraw()
{
	glFlush();
}

//-------------------------------------------------------------------------------
// 切换缓冲区
//-------------------------------------------------------------------------------
bool CDisplay::Present()
{
	SwapBuffers(m_hDC);
	return true;
}

//-------------------------------------------------------------------------------
// 一个全局的CRenderer变量
//-------------------------------------------------------------------------------
CRenderer g_Renderer;

//-------------------------------------------------------------------------------
// 渲染三角形网孔
//-------------------------------------------------------------------------------
void CRenderer::RenderTriMesh(const RenderVertex *vertexList, int vertexCount, const RenderTri *triList, int triCount)
{
	glColor3ub(255, 255, 255);
	glBegin(GL_TRIANGLES);
	//glBegin(GL_LINE_STRIP);
	
	for (int i = 0; i < triCount; ++i)
	{
		const RenderTri &tri = triList[i]; 
		const RenderVertex &v1 = vertexList[(tri.index[0])];
		const RenderVertex &v2 = vertexList[(tri.index[1])];
		const RenderVertex &v3 = vertexList[(tri.index[2])];
		
		glTexCoord2f(v1.u, v1.v);
		glVertex3f(v1.p.x, v1.p.y, v1.p.z);
		glTexCoord2f(v2.u, v2.v);
		glVertex3f(v2.p.x, v2.p.y, v2.p.z);
		glTexCoord2f(v3.u, v3.v);
		glVertex3f(v3.p.x, v3.p.y, v3.p.z);
		
	}

	glEnd();
}

//-------------------------------------------------------------------------------
// 一个全局的CRenderer变量
//-------------------------------------------------------------------------------
void CRenderer::SelectTexture(TextureReference &texture)
{
	if (texture.handle < 1)
	{
		glDisable(GL_TEXTURE_2D);
	}
	else
	{
		glEnable(GL_TEXTURE_2D);
		glBindTexture(GL_TEXTURE_2D, texture.handle);
	}
}

//-------------------------------------------------------------------------------
// 把当前视图矩阵入栈
//-------------------------------------------------------------------------------
void CRenderer::PushModelViewMatrix()
{
	glPushMatrix();
}

//-------------------------------------------------------------------------------
// 弹出栈顶视图矩阵
//-------------------------------------------------------------------------------
void CRenderer::PopModelViewMatrix()
{
	glPopMatrix();
}

//-------------------------------------------------------------------------------
// 当前视图矩阵乘以一个矩阵
//-------------------------------------------------------------------------------
void CRenderer::MulMatrix(const float *m)
{
	glMultMatrixf(m);
}

//-------------------------------------------------------------------------------
// 渲染一个盒子，测试用
//-------------------------------------------------------------------------------
void CRenderer::RenderBox(const Vector3& min, const Vector3& max)
{
	glColor3ub(255, 255, 255);
	
	glDisable(GL_TEXTURE_2D);
	glBegin(GL_LINE_STRIP);
	
	/*for (int i = 0; i<8; ++i)
	{
		Vector3 curCorner((i & 1) ? max.x : min.x,
							(i & 2) ? max.y : min.y,
							(i & 4) ? max.z : min.z
							);

		glVertex3f(curCorner.x, curCorner.y, curCorner.z);
	}*/

	glVertex3f(min.x, min.y, min.z);
	glVertex3f(max.x, min.y, min.z);
	glVertex3f(max.x, max.y, min.z);
	glVertex3f(min.x, max.y, min.z);
	glVertex3f(min.x, max.y, max.z);
	glVertex3f(max.x, max.y, max.z);
	glVertex3f(max.x, min.y, max.z);
	glVertex3f(min.x, min.y, max.z);
	glVertex3f(min.x, min.y, min.z);
	glVertex3f(min.x, max.y, min.z);
	glVertex3f(min.x, max.y, max.z);
	glVertex3f(min.x, min.y, max.z);
	glVertex3f(max.x, min.y, max.z);
	glVertex3f(max.x, min.y, min.z);
	glVertex3f(max.x, max.y, min.z);
	glVertex3f(max.x, max.y, max.z);
	
	//glVertex3f(-0.97f, 1.22f, -0.062f);
	//glVertex3f(-0.91f, 0.6f, -0.06f);

	glEnd();

	glColor3ub(0, 0, 0);
	glEnable(GL_TEXTURE_2D);
}