第三章：初始化 OpenGL 4.0

原文地址：

////////////////////////////////////////////////////////////////////////////////
// Filename: openglclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _OPENGLCLASS_H_
#define _OPENGLCLASS_H_

/////////////
// LINKING //
/////////////
#pragma comment(lib, "opengl32.lib")

//////////////
// INCLUDES //
//////////////
#include <windows.h>
#include <gl\gl.h>
#include <math.h>

/////////////
// DEFINES //
/////////////
#define WGL_DRAW_TO_WINDOW_ARB         0x2001
#define WGL_ACCELERATION_ARB           0x2003
#define WGL_SWAP_METHOD_ARB            0x2007
#define WGL_SUPPORT_OPENGL_ARB         0x2010
#define WGL_DOUBLE_BUFFER_ARB          0x2011
#define WGL_PIXEL_TYPE_ARB             0x2013
#define WGL_COLOR_BITS_ARB             0x2014
#define WGL_DEPTH_BITS_ARB             0x2022
#define WGL_STENCIL_BITS_ARB           0x2023
#define WGL_FULL_ACCELERATION_ARB      0x2027
#define WGL_SWAP_EXCHANGE_ARB          0x2028
#define WGL_TYPE_RGBA_ARB              0x202B
#define WGL_CONTEXT_MAJOR_VERSION_ARB  0x2091
#define WGL_CONTEXT_MINOR_VERSION_ARB  0x2092
#define GL_ARRAY_BUFFER                   0x8892
#define GL_STATIC_DRAW                    0x88E4
#define GL_FRAGMENT_SHADER                0x8B30
#define GL_VERTEX_SHADER                  0x8B31
#define GL_COMPILE_STATUS                 0x8B81
#define GL_LINK_STATUS                    0x8B82
#define GL_INFO_LOG_LENGTH                0x8B84
#define GL_TEXTURE0                       0x84C0
#define GL_BGRA                           0x80E1
#define GL_ELEMENT_ARRAY_BUFFER           0x8893

//////////////
// TYPEDEFS //
//////////////
typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats,
                                                        int *piFormats, UINT *nNumFormats);
typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int *attribList);
typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval);
typedef void (APIENTRY * PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
typedef void (APIENTRY * PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer);
typedef void (APIENTRY * PFNGLBINDVERTEXARRAYPROC) (GLuint array);
typedef void (APIENTRY * PFNGLBUFFERDATAPROC) (GLenum target, ptrdiff_t size, const GLvoid *data, GLenum usage);
typedef void (APIENTRY * PFNGLCOMPILESHADERPROC) (GLuint shader);
typedef GLuint (APIENTRY * PFNGLCREATEPROGRAMPROC) (void);
typedef GLuint (APIENTRY * PFNGLCREATESHADERPROC) (GLenum type);
typedef void (APIENTRY * PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
typedef void (APIENTRY * PFNGLDELETEPROGRAMPROC) (GLuint program);
typedef void (APIENTRY * PFNGLDELETESHADERPROC) (GLuint shader);
typedef void (APIENTRY * PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint *arrays);
typedef void (APIENTRY * PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader);
typedef void (APIENTRY * PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index);
typedef void (APIENTRY * PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
typedef void (APIENTRY * PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint *arrays);
typedef GLint (APIENTRY * PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const char *name);
typedef void (APIENTRY * PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, char *infoLog);
typedef void (APIENTRY * PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params);
typedef void (APIENTRY * PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, char *infoLog);
typedef void (APIENTRY * PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
typedef void (APIENTRY * PFNGLLINKPROGRAMPROC) (GLuint program);
typedef void (APIENTRY * PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const char* *string, const GLint *length);
typedef void (APIENTRY * PFNGLUSEPROGRAMPROC) (GLuint program);
typedef void (APIENTRY * PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
                                                        const GLvoid *pointer);
typedef void (APIENTRY * PFNGLBINDATTRIBLOCATIONPROC) (GLuint program, GLuint index, const char *name);
typedef GLint (APIENTRY * PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const char *name);
typedef void (APIENTRY * PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
typedef void (APIENTRY * PFNGLACTIVETEXTUREPROC) (GLenum texture);
typedef void (APIENTRY * PFNGLUNIFORM1IPROC) (GLint location, GLint v0);
typedef void (APIENTRY * PFNGLGENERATEMIPMAPPROC) (GLenum target);
typedef void (APIENTRY * PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint index);
typedef void (APIENTRY * PFNGLUNIFORM3FVPROC) (GLint location, GLsizei count, const GLfloat *value);
typedef void (APIENTRY * PFNGLUNIFORM4FVPROC) (GLint location, GLsizei count, const GLfloat *value);

////////////////////////////////////////////////////////////////////////////////
// Class name: OpenGLClass
////////////////////////////////////////////////////////////////////////////////
class OpenGLClass
{
public:
 OpenGLClass();
 OpenGLClass(const OpenGLClass&);
 ~OpenGLClass();

 bool InitializeExtensions(HWND);
 bool InitializeOpenGL(HWND, int, int, float, float, bool);
 void Shutdown(HWND);

 void BeginScene(float, float, float, float);
 void EndScene();

 void GetWorldMatrix(float*);
 void GetProjectionMatrix(float*);
 void GetVideoCardInfo(char*);

 void BuildIdentityMatrix(float*);
 void BuildPerspectiveFovLHMatrix(float*, float, float, float, float);
 void MatrixRotationY(float*, float);
 void MatrixTranslation(float*, float, float, float);
 void MatrixMultiply(float*, float*, float*);

private:
 bool LoadExtensionList();

private:
 HDC m_deviceContext;
 HGLRC m_renderingContext;

PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB;
 PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribsARB;
 PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT;

 float m_worldMatrix[16];
 float m_projectionMatrix[16];
 char m_videoCardDescription[128];

public:
 PFNGLATTACHSHADERPROC glAttachShader;
 PFNGLBINDBUFFERPROC glBindBuffer;
 PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
 PFNGLBUFFERDATAPROC glBufferData;
 PFNGLCOMPILESHADERPROC glCompileShader;
 PFNGLCREATEPROGRAMPROC glCreateProgram;
 PFNGLCREATESHADERPROC glCreateShader;
 PFNGLDELETEBUFFERSPROC glDeleteBuffers;
 PFNGLDELETEPROGRAMPROC glDeleteProgram;
 PFNGLDELETESHADERPROC glDeleteShader;
 PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
 PFNGLDETACHSHADERPROC glDetachShader;
 PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray;
 PFNGLGENBUFFERSPROC glGenBuffers;
 PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
 PFNGLGETATTRIBLOCATIONPROC glGetAttribLocation;
 PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
 PFNGLGETPROGRAMIVPROC glGetProgramiv;
 PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
 PFNGLGETSHADERIVPROC glGetShaderiv;
 PFNGLLINKPROGRAMPROC glLinkProgram;
 PFNGLSHADERSOURCEPROC glShaderSource;
 PFNGLUSEPROGRAMPROC glUseProgram;
 PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer;
 PFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation;
 PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
 PFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv;
 PFNGLACTIVETEXTUREPROC glActiveTexture;
 PFNGLUNIFORM1IPROC glUniform1i;
 PFNGLGENERATEMIPMAPPROC glGenerateMipmap;
 PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray;
 PFNGLUNIFORM3FVPROC glUniform3fv;
 PFNGLUNIFORM4FVPROC glUniform4fv;
};

#endif

////////////////////////////////////////////////////////////////////////////////
// Filename: openglclass.cpp
////////////////////////////////////////////////////////////////////////////////
#include "openglclass.h"

OpenGLClass::OpenGLClass()
{
 m_deviceContext = 0;
 m_renderingContext = 0;
}

OpenGLClass::OpenGLClass(const OpenGLClass& other)
{
}

OpenGLClass::~OpenGLClass()
{
}

bool OpenGLClass::InitializeExtensions(HWND hwnd)
{
 HDC deviceContext;
 PIXELFORMATDESCRIPTOR pixelFormat;
 int error;
 HGLRC renderContext;
 bool result;

 // Get the device context for this window.
// 获得窗口设备上下文。
 deviceContext = GetDC(hwnd);
 if(!deviceContext)
 {
  return false;
 }

 // Set a temporary default pixel format.
// 设置默认的临时像素格式。
 error = SetPixelFormat(deviceContext, 1, &pixelFormat);
 if(error != 1)
 {
  return false;
 }

 // Create a temporary rendering context.
// 创建临时渲染上下文。
 renderContext = wglCreateContext(deviceContext);
 if(!renderContext)
 {
  return false;
 }

 // Set the temporary rendering context as the current rendering context for this window.
// 为窗口设置临时渲染上下文。
 error = wglMakeCurrent(deviceContext, renderContext);
 if(error != 1)
 {
  return false;
 }

 // Initialize the OpenGL extensions needed for this application.  Note that a temporary rendering context was needed to do so.
// 初始化程序需要的OpenGL扩展。
 result = LoadExtensionList();
 if(!result)
 {
  return false;
 }

 // Release the temporary rendering context now that the extensions have been loaded.
// 释放临时渲染上下文，现在扩展已经被加载。
 wglMakeCurrent(NULL, NULL);
 wglDeleteContext(renderContext);
 renderContext = NULL;

 // Release the device context for this window.
// 释放窗口设备上下文。
 ReleaseDC(hwnd, deviceContext);
 deviceContext = 0;

 return true;
}

bool OpenGLClass::InitializeOpenGL(HWND hwnd, int screenWidth, int screenHeight, float screenDepth, float screenNear, bool vsync)
{
 int attributeListInt[19];
 int pixelFormat[1];
 unsigned int formatCount;
 int result;
 PIXELFORMATDESCRIPTOR pixelFormatDescriptor;
 int attributeList[5];
 float fieldOfView, screenAspect;
 char *vendorString, *rendererString;

 // Get the device context for this window.
 m_deviceContext = GetDC(hwnd);
 if(!m_deviceContext)
 {
  return false;
 }
 
 // Support for OpenGL rendering.
 attributeListInt[0] = WGL_SUPPORT_OPENGL_ARB;
 attributeListInt[1] = TRUE;

 // Support for rendering to a window.
 attributeListInt[2] = WGL_DRAW_TO_WINDOW_ARB;
 attributeListInt[3] = TRUE;

 // Support for hardware acceleration.
 attributeListInt[4] = WGL_ACCELERATION_ARB;
 attributeListInt[5] = WGL_FULL_ACCELERATION_ARB;

 // Support for 24bit color.
 attributeListInt[6] = WGL_COLOR_BITS_ARB;
 attributeListInt[7] = 24;

 // Support for 24 bit depth buffer.
 attributeListInt[8] = WGL_DEPTH_BITS_ARB;
 attributeListInt[9] = 24;

 // Support for double buffer.
 attributeListInt[10] = WGL_DOUBLE_BUFFER_ARB;
 attributeListInt[11] = TRUE;

 // Support for swapping front and back buffer.
 attributeListInt[12] = WGL_SWAP_METHOD_ARB;
 attributeListInt[13] = WGL_SWAP_EXCHANGE_ARB;

 // Support for the RGBA pixel type.
 attributeListInt[14] = WGL_PIXEL_TYPE_ARB;
 attributeListInt[15] = WGL_TYPE_RGBA_ARB;

 // Support for a 8 bit stencil buffer.
 attributeListInt[16] = WGL_STENCIL_BITS_ARB;
 attributeListInt[17] = 8;

 // Null terminate the attribute list.
 attributeListInt[18] = 0;

 // Query for a pixel format that fits the attributes we want.
 result = wglChoosePixelFormatARB(m_deviceContext, attributeListInt, NULL, 1, pixelFormat, &formatCount);
 if(result != 1)
 {
  return false;
 }

 // If the video card/display can handle our desired pixel format then we set it as the current one.
 result = SetPixelFormat(m_deviceContext, pixelFormat[0], &pixelFormatDescriptor);
 if(result != 1)
 {
  return false;
 }

 // Set the 4.0 version of OpenGL in the attribute list.
 attributeList[0] = WGL_CONTEXT_MAJOR_VERSION_ARB;
 attributeList[1] = 4;
 attributeList[2] = WGL_CONTEXT_MINOR_VERSION_ARB;
 attributeList[3] = 0;

 // Null terminate the attribute list.
 attributeList[4] = 0;

 // Create a OpenGL 4.0 rendering context.
 m_renderingContext = wglCreateContextAttribsARB(m_deviceContext, 0, attributeList);
 if(m_renderingContext == NULL)
 {
  return false;
 }

 // Set the rendering context to active.
 result = wglMakeCurrent(m_deviceContext, m_renderingContext);
 if(result != 1)
 {
  return false;
 }
 
 // Set the depth buffer to be entirely cleared to 1.0 values.
 glClearDepth(1.0f);

 // Enable depth testing.
 glEnable(GL_DEPTH_TEST);
 
 // Set the polygon winding to front facing for the left handed system.
 glFrontFace(GL_CW);

 // Enable back face culling.
 glEnable(GL_CULL_FACE);
 glCullFace(GL_BACK);

 // Initialize the world/model matrix to the identity matrix.
 BuildIdentityMatrix(m_worldMatrix);

 // Set the field of view and screen aspect ratio.
 fieldOfView = 3.14159265358979323846f / 4.0f;
 screenAspect = (float)screenWidth / (float)screenHeight;

 // Build the perspective projection matrix.
 BuildPerspectiveFovLHMatrix(m_projectionMatrix, fieldOfView, screenAspect, screenNear, screenDepth);

 // Get the name of the video card.
 vendorString = (char*)glGetString(GL_VENDOR);
 rendererString = (char*)glGetString(GL_RENDERER);

 // Store the video card name in a class member variable so it can be retrieved later.
 strcpy_s(m_videoCardDescription, vendorString);
 strcat_s(m_videoCardDescription, " - ");
 strcat_s(m_videoCardDescription, rendererString);

 // Turn on or off the vertical sync depending on the input bool value.
 if(vsync)
 {
  result = wglSwapIntervalEXT(1);
 }
 else
 {
  result = wglSwapIntervalEXT(0);
 }

 // Check if vsync was set correctly.
 if(result != 1)
 {
  return false;
 }

 return true;
}

void OpenGLClass::Shutdown(HWND hwnd)
{
 // Release the rendering context.
 if(m_renderingContext)
 {
  wglMakeCurrent(NULL, NULL);
  wglDeleteContext(m_renderingContext);
  m_renderingContext = 0;
 }

 // Release the device context.
 if(m_deviceContext)
 {
  ReleaseDC(hwnd, m_deviceContext);
  m_deviceContext = 0;
 }

 return;
}

void OpenGLClass::BeginScene(float red, float green, float blue, float alpha)
{
 // Set the color to clear the screen to.
 glClearColor(red, green, blue, alpha);

 // Clear the screen and depth buffer.
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 return;
}

void OpenGLClass::EndScene()
{
 // Present the back buffer to the screen since rendering is complete.
 SwapBuffers(m_deviceContext);

 return;
}

bool OpenGLClass::LoadExtensionList()
{
 // Load the OpenGL extensions that this application will be using.
 wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB");
 if(!wglChoosePixelFormatARB)
 {
  return false;
 }

 wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)wglGetProcAddress("wglCreateContextAttribsARB");
 if(!wglCreateContextAttribsARB)
 {
  return false;
 }

 wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT");
 if(!wglSwapIntervalEXT)
 {
  return false;
 }

 glAttachShader = (PFNGLATTACHSHADERPROC)wglGetProcAddress("glAttachShader");
 if(!glAttachShader)
 {
  return false;
 }

 glBindBuffer = (PFNGLBINDBUFFERPROC)wglGetProcAddress("glBindBuffer");
 if(!glBindBuffer)
 {
  return false;
 }

 glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)wglGetProcAddress("glBindVertexArray");
 if(!glBindVertexArray)
 {
  return false;
 }

 glBufferData = (PFNGLBUFFERDATAPROC)wglGetProcAddress("glBufferData");
 if(!glBufferData)
 {
  return false;
 }

 glCompileShader = (PFNGLCOMPILESHADERPROC)wglGetProcAddress("glCompileShader");
 if(!glCompileShader)
 {
  return false;
 }

 glCreateProgram = (PFNGLCREATEPROGRAMPROC)wglGetProcAddress("glCreateProgram");
 if(!glCreateProgram)
 {
  return false;
 }

 glCreateShader = (PFNGLCREATESHADERPROC)wglGetProcAddress("glCreateShader");
 if(!glCreateShader)
 {
  return false;
 }

 glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)wglGetProcAddress("glDeleteBuffers");
 if(!glDeleteBuffers)
 {
  return false;
 }

 glDeleteProgram = (PFNGLDELETEPROGRAMPROC)wglGetProcAddress("glDeleteProgram");
 if(!glDeleteProgram)
 {
  return false;
 }

 glDeleteShader = (PFNGLDELETESHADERPROC)wglGetProcAddress("glDeleteShader");
 if(!glDeleteShader)
 {
  return false;
 }

 glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)wglGetProcAddress("glDeleteVertexArrays");
 if(!glDeleteVertexArrays)
 {
  return false;
 }

 glDetachShader = (PFNGLDETACHSHADERPROC)wglGetProcAddress("glDetachShader");
 if(!glDetachShader)
 {
  return false;
 }

 glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)wglGetProcAddress("glEnableVertexAttribArray");
 if(!glEnableVertexAttribArray)
 {
  return false;
 }

 glGenBuffers = (PFNGLGENBUFFERSPROC)wglGetProcAddress("glGenBuffers");
 if(!glGenBuffers)
 {
  return false;
 }

 glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)wglGetProcAddress("glGenVertexArrays");
 if(!glGenVertexArrays)
 {
  return false;
 }

 glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)wglGetProcAddress("glGetAttribLocation");
 if(!glGetAttribLocation)
 {
  return false;
 }

 glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)wglGetProcAddress("glGetProgramInfoLog");
 if(!glGetProgramInfoLog)
 {
  return false;
 }

 glGetProgramiv = (PFNGLGETPROGRAMIVPROC)wglGetProcAddress("glGetProgramiv");
 if(!glGetProgramiv)
 {
  return false;
 }

 glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)wglGetProcAddress("glGetShaderInfoLog");
 if(!glGetShaderInfoLog)
 {
  return false;
 }

 glGetShaderiv = (PFNGLGETSHADERIVPROC)wglGetProcAddress("glGetShaderiv");
 if(!glGetShaderiv)
 {
  return false;
 }

 glLinkProgram = (PFNGLLINKPROGRAMPROC)wglGetProcAddress("glLinkProgram");
 if(!glLinkProgram)
 {
  return false;
 }

 glShaderSource = (PFNGLSHADERSOURCEPROC)wglGetProcAddress("glShaderSource");
 if(!glShaderSource)
 {
  return false;
 }

 glUseProgram = (PFNGLUSEPROGRAMPROC)wglGetProcAddress("glUseProgram");
 if(!glUseProgram)
 {
  return false;
 }

 glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)wglGetProcAddress("glVertexAttribPointer");
 if(!glVertexAttribPointer)
 {
  return false;
 }

 glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)wglGetProcAddress("glBindAttribLocation");
 if(!glBindAttribLocation)
 {
  return false;
 }

 glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)wglGetProcAddress("glGetUniformLocation");
 if(!glGetUniformLocation)
 {
  return false;
 }

 glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)wglGetProcAddress("glUniformMatrix4fv");
 if(!glUniformMatrix4fv)
 {
  return false;
 }

 glActiveTexture = (PFNGLACTIVETEXTUREPROC)wglGetProcAddress("glActiveTexture");
 if(!glActiveTexture)
 {
  return false;
 }

 glUniform1i = (PFNGLUNIFORM1IPROC)wglGetProcAddress("glUniform1i");
 if(!glUniform1i)
 {
  return false;
 }

 glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)wglGetProcAddress("glGenerateMipmap");
 if(!glGenerateMipmap)
 {
  return false;
 }

 glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)wglGetProcAddress("glDisableVertexAttribArray");
 if(!glDisableVertexAttribArray)
 {
  return false;
 }

 glUniform3fv = (PFNGLUNIFORM3FVPROC)wglGetProcAddress("glUniform3fv");
 if(!glUniform3fv)
 {
  return false;
 }

 glUniform4fv = (PFNGLUNIFORM4FVPROC)wglGetProcAddress("glUniform4fv");
 if(!glUniform4fv)
 {
  return false;
 }

 return true;
}

void OpenGLClass::GetWorldMatrix(float* matrix)
{
 matrix[0]  = m_worldMatrix[0];
 matrix[1]  = m_worldMatrix[1];
 matrix[2]  = m_worldMatrix[2];
 matrix[3]  = m_worldMatrix[3];

 matrix[4]  = m_worldMatrix[4];
 matrix[5]  = m_worldMatrix[5];
 matrix[6]  = m_worldMatrix[6];
 matrix[7]  = m_worldMatrix[7];

 matrix[8]  = m_worldMatrix[8];
 matrix[9]  = m_worldMatrix[9];
 matrix[10] = m_worldMatrix[10];
 matrix[11] = m_worldMatrix[11];

 matrix[12] = m_worldMatrix[12];
 matrix[13] = m_worldMatrix[13];
 matrix[14] = m_worldMatrix[14];
 matrix[15] = m_worldMatrix[15];

 return;
}

void OpenGLClass::GetProjectionMatrix(float* matrix)
{
 matrix[0]  = m_projectionMatrix[0];
 matrix[1]  = m_projectionMatrix[1];
 matrix[2]  = m_projectionMatrix[2];
 matrix[3]  = m_projectionMatrix[3];

 matrix[4]  = m_projectionMatrix[4];
 matrix[5]  = m_projectionMatrix[5];
 matrix[6]  = m_projectionMatrix[6];
 matrix[7]  = m_projectionMatrix[7];

 matrix[8]  = m_projectionMatrix[8];
 matrix[9]  = m_projectionMatrix[9];
 matrix[10] = m_projectionMatrix[10];
 matrix[11] = m_projectionMatrix[11];

 matrix[12] = m_projectionMatrix[12];
 matrix[13] = m_projectionMatrix[13];
 matrix[14] = m_projectionMatrix[14];
 matrix[15] = m_projectionMatrix[15];

 return;
}

void OpenGLClass::GetVideoCardInfo(char* cardName)
{
 strcpy_s(cardName, 128, m_videoCardDescription);
 return;
}

void OpenGLClass::BuildIdentityMatrix(float* matrix)
{
 matrix[0]  = 1.0f;
 matrix[1]  = 0.0f;
 matrix[2]  = 0.0f;
 matrix[3]  = 0.0f;

 matrix[4]  = 0.0f;
 matrix[5]  = 1.0f;
 matrix[6]  = 0.0f;
 matrix[7]  = 0.0f;

 matrix[8]  = 0.0f;
 matrix[9]  = 0.0f;
 matrix[10] = 1.0f;
 matrix[11] = 0.0f;

 matrix[12] = 0.0f;
 matrix[13] = 0.0f;
 matrix[14] = 0.0f;
 matrix[15] = 1.0f;

 return;
}

void OpenGLClass::BuildPerspectiveFovLHMatrix(float* matrix, float fieldOfView, float screenAspect, float screenNear, float screenDepth)
{
 matrix[0]  = 1.0f / (screenAspect * tan(fieldOfView * 0.5f));
 matrix[1]  = 0.0f;
 matrix[2]  = 0.0f;
 matrix[3]  = 0.0f;

 matrix[4]  = 0.0f;
 matrix[5]  = 1.0f / tan(fieldOfView * 0.5f);
 matrix[6]  = 0.0f;
 matrix[7]  = 0.0f;

 matrix[8]  = 0.0f;
 matrix[9]  = 0.0f;
 matrix[10] = screenDepth / (screenDepth - screenNear);
 matrix[11] = 1.0f;

 matrix[12] = 0.0f;
 matrix[13] = 0.0f;
 matrix[14] = (-screenNear * screenDepth) / (screenDepth - screenNear);
 matrix[15] = 0.0f;

 return;
}

void OpenGLClass::MatrixRotationY(float* matrix, float angle)
{
 matrix[0]  = cosf(angle);
 matrix[1]  = 0.0f;
 matrix[2]  = -sinf(angle);
 matrix[3]  = 0.0f;

 matrix[4]  = 0.0f;
 matrix[5]  = 1.0f;
 matrix[6]  = 0.0f;
 matrix[7]  = 0.0f;

 matrix[8]  = sinf(angle);
 matrix[9]  = 0.0f;
 matrix[10] = cosf(angle);
 matrix[11] = 0.0f;

 matrix[12] = 0.0f;
 matrix[13] = 0.0f;
 matrix[14] = 0.0f;
 matrix[15] = 1.0f;

 return;
}

void OpenGLClass::MatrixTranslation(float* matrix, float x, float y, float z)
{
 matrix[0]  = 1.0f;
 matrix[1]  = 0.0f;
 matrix[2]  = 0.0f;
 matrix[3]  = 0.0f;

 matrix[4]  = 0.0f;
 matrix[5]  = 1.0f;
 matrix[6]  = 0.0f;
 matrix[7]  = 0.0f;

 matrix[8]  = 0.0f;
 matrix[9]  = 0.0f;
 matrix[10] = 1.0f;
 matrix[11] = 0.0f;

 matrix[12] = x;
 matrix[13] = y;
 matrix[14] = z;
 matrix[15] = 1.0f;

 return;
}

void OpenGLClass::MatrixMultiply(float* result, float* matrix1, float* matrix2)
{
 result[0]  = (matrix1[0] * matrix2[0]) + (matrix1[1] * matrix2[4]) + (matrix1[2] * matrix2[8]) + (matrix1[3] * matrix2[12]);
 result[1]  = (matrix1[0] * matrix2[1]) + (matrix1[1] * matrix2[5]) + (matrix1[2] * matrix2[9]) + (matrix1[3] * matrix2[13]);
 result[2]  = (matrix1[0] * matrix2[2]) + (matrix1[1] * matrix2[6]) + (matrix1[2] * matrix2[10]) + (matrix1[3] * matrix2[14]);
 result[3]  = (matrix1[0] * matrix2[3]) + (matrix1[1] * matrix2[7]) + (matrix1[2] * matrix2[11]) + (matrix1[3] * matrix2[15]);

 result[4]  = (matrix1[4] * matrix2[0]) + (matrix1[5] * matrix2[4]) + (matrix1[6] * matrix2[8]) + (matrix1[7] * matrix2[12]);
 result[5]  = (matrix1[4] * matrix2[1]) + (matrix1[5] * matrix2[5]) + (matrix1[6] * matrix2[9]) + (matrix1[7] * matrix2[13]);
 result[6]  = (matrix1[4] * matrix2[2]) + (matrix1[5] * matrix2[6]) + (matrix1[6] * matrix2[10]) + (matrix1[7] * matrix2[14]);
 result[7]  = (matrix1[4] * matrix2[3]) + (matrix1[5] * matrix2[7]) + (matrix1[6] * matrix2[11]) + (matrix1[7] * matrix2[15]);

 result[8]  = (matrix1[8] * matrix2[0]) + (matrix1[9] * matrix2[4]) + (matrix1[10] * matrix2[8]) + (matrix1[11] * matrix2[12]);
 result[9]  = (matrix1[8] * matrix2[1]) + (matrix1[9] * matrix2[5]) + (matrix1[10] * matrix2[9]) + (matrix1[11] * matrix2[13]);
 result[10] = (matrix1[8] * matrix2[2]) + (matrix1[9] * matrix2[6]) + (matrix1[10] * matrix2[10]) + (matrix1[11] * matrix2[14]);
 result[11] = (matrix1[8] * matrix2[3]) + (matrix1[9] * matrix2[7]) + (matrix1[10] * matrix2[11]) + (matrix1[11] * matrix2[15]);

 result[12] = (matrix1[12] * matrix2[0]) + (matrix1[13] * matrix2[4]) + (matrix1[14] * matrix2[8]) + (matrix1[15] * matrix2[12]);
 result[13] = (matrix1[12] * matrix2[1]) + (matrix1[13] * matrix2[5]) + (matrix1[14] * matrix2[9]) + (matrix1[15] * matrix2[13]);
 result[14] = (matrix1[12] * matrix2[2]) + (matrix1[13] * matrix2[6]) + (matrix1[14] * matrix2[10]) + (matrix1[15] * matrix2[14]);
 result[15] = (matrix1[12] * matrix2[3]) + (matrix1[13] * matrix2[7]) + (matrix1[14] * matrix2[11]) + (matrix1[15] * matrix2[15]);

 return;
}

////////////////////////////////////////////////////////////////////////////////
// Filename: systemclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _SYSTEMCLASS_H_
#define _SYSTEMCLASS_H_

///////////////////////////////
// PRE-PROCESSING DIRECTIVES //
///////////////////////////////
#define WIN32_LEAN_AND_MEAN

//////////////
// INCLUDES //
//////////////
#include <windows.h>

///////////////////////
// MY CLASS INCLUDES //
///////////////////////
#include "openglclass.h"
#include "inputclass.h"
#include "graphicsclass.h"

////////////////////////////////////////////////////////////////////////////////
// Class name: SystemClass
////////////////////////////////////////////////////////////////////////////////
class SystemClass
{
public:
 SystemClass();
 SystemClass(const SystemClass&);
 ~SystemClass();

 bool Initialize();
 void Shutdown();
 void Run();

 LRESULT CALLBACK MessageHandler(HWND, UINT, WPARAM, LPARAM);

private:
 bool Frame();
 bool InitializeWindows(OpenGLClass*, int&, int&);
 void ShutdownWindows();

private:
 LPCWSTR m_applicationName;
 HINSTANCE m_hinstance;
 HWND m_hwnd;

 OpenGLClass* m_OpenGL;
 InputClass* m_Input;
 GraphicsClass* m_Graphics;
};

/////////////////////////
// FUNCTION PROTOTYPES //
/////////////////////////
static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

/////////////
// GLOBALS //
/////////////
static SystemClass* ApplicationHandle = 0;

#endif

////////////////////////////////////////////////////////////////////////////////
// Filename: systemclass.cpp
////////////////////////////////////////////////////////////////////////////////
#include "systemclass.h"

SystemClass::SystemClass()
{
 m_OpenGL = 0;
 m_Input = 0;
 m_Graphics = 0;
}

SystemClass::SystemClass(const SystemClass& other)
{
}

SystemClass::~SystemClass()
{
}

bool SystemClass::Initialize()
{
 int screenWidth, screenHeight;
 bool result;

 // Initialize the width and height of the screen to zero.
 screenWidth = 0;
 screenHeight = 0;

 // Create the OpenGL object.
 m_OpenGL = new OpenGLClass;
 if(!m_OpenGL)
 {
  return false;
 }

 // Create the window the application will be using and also initialize OpenGL.
 result = InitializeWindows(m_OpenGL, screenWidth, screenHeight);
 if(!result)
 {
  MessageBox(m_hwnd, L"Could not initialize the window.", L"Error", MB_OK);
  return false;
 }
 
 // Create the input object.  This object will be used to handle reading the input from the user.
 m_Input = new InputClass;
 if(!m_Input)
 {
  return false;
 }

 // Initialize the input object.
 m_Input->Initialize();

 // Create the graphics object.  This object will handle rendering all the graphics for this application.
 m_Graphics = new GraphicsClass;
 if(!m_Graphics)
 {
  return false;
 }

 // Initialize the graphics object.
 result = m_Graphics->Initialize(m_OpenGL, m_hwnd);
 if(!result)
 {
  return false;
 }

 return true;
}

void SystemClass::Shutdown()
{
 // Release the graphics object.
 if(m_Graphics)
 {
  m_Graphics->Shutdown();
  delete m_Graphics;
  m_Graphics = 0;
 }

 // Release the input object.
 if(m_Input)
 {
  delete m_Input;
  m_Input = 0;
 }

// Release the OpenGL object.
 if(m_OpenGL)
 {
  m_OpenGL->Shutdown(m_hwnd);
  delete m_OpenGL;
  m_OpenGL = 0;
 }

 // Shutdown the window.
 ShutdownWindows();
 
 return;
}

void SystemClass::Run()
{
 MSG msg;
 bool done, result;

 // Initialize the message structure.
 ZeroMemory(&msg, sizeof(MSG));
 
 // Loop until there is a quit message from the window or the user.
 done = false;
 while(!done)
 {
  // Handle the windows messages.
  if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
  {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
  }

  // If windows signals to end the application then exit out.
  if(msg.message == WM_QUIT)
  {
   done = true;
  }
  else
  {
   // Otherwise do the frame processing.
   result = Frame();
   if(!result)
   {
    done = true;
   }
  }
 }

 return;
}

bool SystemClass::Frame()
{
 bool result;

 // Check if the user pressed escape and wants to exit the application.
 if(m_Input->IsKeyDown(VK_ESCAPE))
 {
  return false;
 }

 // Do the frame processing for the graphics object.
 result = m_Graphics->Frame();
 if(!result)
 {
  return false;
 }

 return true;
}

LRESULT CALLBACK SystemClass::MessageHandler(HWND hwnd, UINT umsg, WPARAM wparam, LPARAM lparam)
{
 switch(umsg)
 {
  // Check if a key has been pressed on the keyboard.
  case WM_KEYDOWN:
  {
   // If a key is pressed send it to the input object so it can record that state.
   m_Input->KeyDown((unsigned int)wparam);
   return 0;
  }

  // Check if a key has been released on the keyboard.
  case WM_KEYUP:
  {
   // If a key is released then send it to the input object so it can unset the state for that key.
   m_Input->KeyUp((unsigned int)wparam);
   return 0;
  }

  // Any other messages send to the default message handler as our application won't make use of them.
  default:
  {
   return DefWindowProc(hwnd, umsg, wparam, lparam);
  }
 }
}

bool SystemClass::InitializeWindows(OpenGLClass* OpenGL, int& screenWidth, int& screenHeight)
{
 WNDCLASSEX wc;
 DEVMODE dmScreenSettings;
 int posX, posY;
 bool result;

 // Get an external pointer to this object.
 ApplicationHandle = this;

 // Get the instance of this application.
 m_hinstance = GetModuleHandle(NULL);

 // Give the application a name.
 m_applicationName = L"Engine";

 // Setup the windows class with default settings.
 wc.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
 wc.lpfnWndProc   = WndProc;
 wc.cbClsExtra    = 0;
 wc.cbWndExtra    = 0;
 wc.hInstance     = m_hinstance;
 wc.hIcon         = LoadIcon(NULL, IDI_WINLOGO);
 wc.hIconSm       = wc.hIcon;
 wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
 wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
 wc.lpszMenuName  = NULL;
 wc.lpszClassName = m_applicationName;
 wc.cbSize        = sizeof(WNDCLASSEX);
 
 // Register the window class.
 RegisterClassEx(&wc);

 // Create a temporary window for the OpenGL extension setup.
 m_hwnd = CreateWindowEx(WS_EX_APPWINDOW, m_applicationName, m_applicationName, WS_POPUP,
    0, 0, 640, 480, NULL, NULL, m_hinstance, NULL);
 if(m_hwnd == NULL)
 {
  return false;
 }

 // Don't show the window.
 ShowWindow(m_hwnd, SW_HIDE);

 // Initialize a temporary OpenGL window and load the OpenGL extensions.
 result = OpenGL->InitializeExtensions(m_hwnd);
 if(!result)
 {
  MessageBox(m_hwnd, L"Could not initialize the OpenGL extensions.", L"Error", MB_OK);
  return false;
 }

 // Release the temporary window now that the extensions have been initialized.
 DestroyWindow(m_hwnd);
 m_hwnd = NULL;

 // Determine the resolution of the clients desktop screen.
 screenWidth  = GetSystemMetrics(SM_CXSCREEN);
 screenHeight = GetSystemMetrics(SM_CYSCREEN);

 // Setup the screen settings depending on whether it is running in full screen or in windowed mode.
 if(FULL_SCREEN)
 {
  // If full screen set the screen to maximum size of the users desktop and 32bit.
  memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
  dmScreenSettings.dmSize       = sizeof(dmScreenSettings);
  dmScreenSettings.dmPelsWidth  = (unsigned long)screenWidth;
  dmScreenSettings.dmPelsHeight = (unsigned long)screenHeight;
  dmScreenSettings.dmBitsPerPel = 32;
  dmScreenSettings.dmFields     = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

  // Change the display settings to full screen.
  ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN);

  // Set the position of the window to the top left corner.
  posX = posY = 0;
 }
 else
 {
  // If windowed then set it to 800x600 resolution.
  screenWidth  = 800;
  screenHeight = 600;

  // Place the window in the middle of the screen.
  posX = (GetSystemMetrics(SM_CXSCREEN) - screenWidth)  / 2;
  posY = (GetSystemMetrics(SM_CYSCREEN) - screenHeight) / 2;
 }

 // Create the window with the screen settings and get the handle to it.
 m_hwnd = CreateWindowEx(WS_EX_APPWINDOW, m_applicationName, m_applicationName, WS_POPUP,
    posX, posY, screenWidth, screenHeight, NULL, NULL, m_hinstance, NULL);
 if(m_hwnd == NULL)
 {
  return false;
 }

// Initialize OpenGL now that the window has been created.
 result = m_OpenGL->InitializeOpenGL(m_hwnd, screenWidth, screenHeight, SCREEN_DEPTH, SCREEN_NEAR, VSYNC_ENABLED);
 if(!result)
 {
  MessageBox(m_hwnd, L"Could not initialize OpenGL, check if video card supports OpenGL 4.0.", L"Error", MB_OK);
  return false;
 }

 // Bring the window up on the screen and set it as main focus.
 ShowWindow(m_hwnd, SW_SHOW);
 SetForegroundWindow(m_hwnd);
 SetFocus(m_hwnd);

 // Hide the mouse cursor.
 ShowCursor(false);

 return true;
}

void SystemClass::ShutdownWindows()
{
 // Show the mouse cursor.
 ShowCursor(true);

 // Fix the display settings if leaving full screen mode.
 if(FULL_SCREEN)
 {
  ChangeDisplaySettings(NULL, 0);
 }

 // Remove the window.
 DestroyWindow(m_hwnd);
 m_hwnd = NULL;

 // Remove the application instance.
 UnregisterClass(m_applicationName, m_hinstance);
 m_hinstance = NULL;

 // Release the pointer to this class.
 ApplicationHandle = NULL;

 return;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam)
{
 switch(umessage)
 {
  // Check if the window is being closed.
  case WM_CLOSE:
  {
   PostQuitMessage(0);
   return 0;
  }

  // All other messages pass to the message handler in the system class.
  default:
  {
   return ApplicationHandle->MessageHandler(hwnd, umessage, wparam, lparam);
  }
 }
}

////////////////////////////////////////////////////////////////////////////////
// Filename: graphicsclass.h
////////////////////////////////////////////////////////////////////////////////
#ifndef _GRAPHICSCLASS_H_
#define _GRAPHICSCLASS_H_

///////////////////////
// MY CLASS INCLUDES //
///////////////////////
#include "openglclass.h"

/////////////
// GLOBALS //
/////////////
const bool FULL_SCREEN = false;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;

////////////////////////////////////////////////////////////////////////////////
// Class name: GraphicsClass
////////////////////////////////////////////////////////////////////////////////
class GraphicsClass
{
public:
 GraphicsClass();
 GraphicsClass(const GraphicsClass&);
 ~GraphicsClass();

 bool Initialize(OpenGLClass*, HWND);
 void Shutdown();
 bool Frame();

private:
 bool Render();

private:
We now have an OpenGL class object.

 OpenGLClass* m_OpenGL;
};

#endif

////////////////////////////////////////////////////////////////////////////////
// Filename: graphicsclass.cpp
////////////////////////////////////////////////////////////////////////////////
#include "graphicsclass.h"

GraphicsClass::GraphicsClass()
{
 m_OpenGL = 0;
}

GraphicsClass::GraphicsClass(const GraphicsClass& other)
{
}

GraphicsClass::~GraphicsClass()
{
}

bool GraphicsClass::Initialize(OpenGLClass* OpenGL, HWND hwnd)
{
 // Store a pointer to the OpenGL class object.
 m_OpenGL = OpenGL;

 return true;
}

void GraphicsClass::Shutdown()
{
 // Release the pointer to the OpenGL class object.
 m_OpenGL = 0;

 return;
}

bool GraphicsClass::Frame()
{
 bool result;

 // Render the graphics scene.
 result = Render();
 if(!result)
 {
  return false;
 }

 return true;
}

bool GraphicsClass::Render()
{
 // Clear the buffers to begin the scene.
 m_OpenGL->BeginScene(0.5f, 0.5f, 0.5f, 1.0f);

 // Present the rendered scene to the screen.
 m_OpenGL->EndScene();

 return true;
}

第三章：初始化 OpenGL 4.0

原文：http://blog.csdn.net/weyson/article/details/46821795