Windows窗口中创建OpenGL上下文并调用OpenGL函数

#include <Windows.h>
#include <iostream>
#include <GL/GL.h>
#pragma comment (lib, "opengl32.lib")

enum {GL_VERTEX_SHADER=0x8B31, GL_COMPILE_STATUS=0x8B81, GL_FRAGMENT_SHADER=0x8B30, GL_LINK_STATUS=0x8B82, GL_ARRAY_BUFFER=0x8892, GL_STATIC_DRAW=0x88E4};

void* GetGLFuncAddress(const char* name);

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

typedef  GLuint(__stdcall *hGlCreateShader)(GLenum shaderType);
hGlCreateShader glCreateShader;

typedef void (__stdcall *hGlShaderSource)(GLuint shader, GLsizei count, const char** string, const GLint* length);
hGlShaderSource glShaderSource;

typedef void (__stdcall *hGlCompileShader)(GLuint shader);
hGlCompileShader glCompileShader;

typedef void (__stdcall *hGlGetShaderiv)(GLuint shader, GLenum pname, GLint* params);
hGlGetShaderiv glGetShaderiv;

typedef void (__stdcall *hGlGetShaderInfoLog)(GLuint shader, GLsizei maxLength, GLsizei* length, char* infoLog);
hGlGetShaderInfoLog glGetShaderInfoLog;

typedef GLuint (__stdcall *hGlCreateProgram)(void);
hGlCreateProgram glCreateProgram;

typedef void (__stdcall *hGlAttachShader)(GLuint program, GLuint shader);
hGlAttachShader glAttachShader;

typedef void (__stdcall *hGlLinkProgram)(GLuint program);
hGlLinkProgram glLinkProgram;

typedef void (__stdcall *hGlGetProgramiv)(GLuint program, GLenum pname, GLint* params);
hGlGetProgramiv glGetProgramiv;


typedef void (__stdcall * hGlGetProgramInfoLog)(GLuint program, GLsizei maxLength, GLsizei* length, char* infoLog);
hGlGetProgramInfoLog glGetProgramInfoLog;

typedef void (__stdcall *hGlDeleteShader)(GLuint shader);
hGlDeleteShader glDeleteShader;

typedef void (__stdcall * hGlGenVertexArrays)(GLsizei n, GLuint* arrays);
hGlGenVertexArrays glGenVertexArrays;

typedef void (__stdcall *hGlGenBuffers)(GLsizei n, GLuint* buffers);
hGlGenBuffers glGenBuffers;

typedef void (__stdcall *hGlBindVertexArray)(GLuint array);
hGlBindVertexArray glBindVertexArray;

typedef void (__stdcall * hGlBindBuffer)(GLenum target, GLuint buffer);
hGlBindBuffer glBindBuffer;

typedef signed int GLsizeiptr;

typedef void (__stdcall *hGlBufferData)(GLenum target, GLsizeiptr size, const void* data, GLenum usage);
hGlBufferData glBufferData;

typedef void (__stdcall *hGlVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer);
hGlVertexAttribPointer glVertexAttribPointer;

typedef void (__stdcall *hGlEnableVertexAttribArray)(GLuint index);
hGlEnableVertexAttribArray glEnableVertexAttribArray;

typedef void (__stdcall * hGlUseProgram)(GLuint program);
hGlUseProgram glUseProgram;

//typedef void (__stdcall *hGlDrawArrays)(GLenum mode, GLint first, GLsizei count);
//hGlDrawArrays glDrawArrays;

const char* vertexShaderSource = "#version 450 core\n"
"layout (location = 0) in vec3 aPos;\n"
"void main()\n"
"{\n"
"   gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n"
"}\0";
const char* fragmentShaderSource = "#version 450 core\n"
"out vec4 FragColor;\n"
"void main()\n"
"{\n"
"   FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n"
"}\n\0";

GLuint vertexShader, fragmentShader;
GLuint shaderProgram;
GLuint VAO, VBO;

float vertices[] = {
		-0.5f, -0.5f, 0.0f, // left  
		 0.5f, -0.5f, 0.0f, // right 
		 0.0f,  0.5f, 0.0f  // top   
};

HGLRC glContext;
HDC hdc;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
	const WCHAR* lpszClassName = L"glsample";

	HWND hWnd;
	MSG msg = { 0 };
	WNDCLASS wc = {0};
	wc.style = 0;
	wc.lpfnWndProc = WndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.lpszClassName = lpszClassName;
	if (!RegisterClass(&wc))
		return -1;

	hWnd = CreateWindow(lpszClassName, L"我的第一个OpenGL窗口", WS_OVERLAPPEDWINDOW, 0, 0, 640, 480, 0, 0, hInstance, 0);
	
	

	ShowWindow(hWnd, nShowCmd);
	UpdateWindow(hWnd);

	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return 0;
}


LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_CREATE: 
	{
		PIXELFORMATDESCRIPTOR pfd =
		{
			sizeof(PIXELFORMATDESCRIPTOR),
			1,
			PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,    //Flags
			PFD_TYPE_RGBA,        // The kind of framebuffer. RGBA or palette.
			32,                   // Colordepth of the framebuffer.
			0, 0, 0, 0, 0, 0,
			0,
			0,
			0,
			0, 0, 0, 0,
			24,                   // Number of bits for the depthbuffer
			8,                    // Number of bits for the stencilbuffer
			0,                    // Number of Aux buffers in the framebuffer.
			PFD_MAIN_PLANE,
			0,
			0, 0, 0
		};
		hdc = GetDC(hWnd);
		int iPixelFormat = ChoosePixelFormat(hdc, &pfd);
		SetPixelFormat(hdc, iPixelFormat, &pfd);
		glContext = wglCreateContext(hdc);
		wglMakeCurrent(hdc, glContext);

		glCreateShader = (hGlCreateShader)GetGLFuncAddress("glCreateShader");
		glShaderSource = (hGlShaderSource)GetGLFuncAddress("glShaderSource");
		glCompileShader = (hGlCompileShader)GetGLFuncAddress("glCompileShader");
		glGetShaderiv = (hGlGetShaderiv)GetGLFuncAddress("glGetShaderiv");
		glGetShaderInfoLog = (hGlGetShaderInfoLog)GetGLFuncAddress("glGetShaderInfoLog");
		glCreateProgram = (hGlCreateProgram)GetGLFuncAddress("glCreateProgram");
		glAttachShader = (hGlAttachShader)GetGLFuncAddress("glAttachShader");
		glLinkProgram = (hGlLinkProgram)GetGLFuncAddress("glLinkProgram");
		glGetProgramiv = (hGlGetProgramiv)GetGLFuncAddress("glGetProgramiv");
		glGetProgramInfoLog = (hGlGetProgramInfoLog)GetGLFuncAddress("glGetProgramInfoLog");
		glDeleteShader = (hGlDeleteShader)GetGLFuncAddress("glDeleteShader");
		glGenVertexArrays = (hGlGenVertexArrays)GetGLFuncAddress("glGenVertexArrays");
		glGenBuffers = (hGlGenBuffers)GetGLFuncAddress("glGenBuffers");
		glBindVertexArray = (hGlBindVertexArray)GetGLFuncAddress("glBindVertexArray");
		glBindBuffer = (hGlBindBuffer)GetGLFuncAddress("glBindBuffer");
		glBufferData = (hGlBufferData)GetGLFuncAddress("glBufferData");
		glVertexAttribPointer = (hGlVertexAttribPointer)GetGLFuncAddress("glVertexAttribPointer");
		glEnableVertexAttribArray = (hGlEnableVertexAttribArray)GetGLFuncAddress("glEnableVertexAttribArray");
		glBindVertexArray = (hGlBindVertexArray)GetGLFuncAddress("glBindVertexArray");
		glUseProgram = (hGlUseProgram)GetGLFuncAddress("glUseProgram");
		//glDrawArrays = (hGlDrawArrays)GetGLFuncAddress("glDrawArrays");
		
		vertexShader = glCreateShader(GL_VERTEX_SHADER);
		
		glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);

		glCompileShader(vertexShader);

		int success;
		char infoLog[512];
		
		glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);

		if (!success)
		{
			glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
			MessageBoxA(hWnd, infoLog, "顶点着色器编译错误!", 0);
			return -1;
		}

		fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
		glCompileShader(fragmentShader);
		glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
		if (!success)
		{
			glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
			MessageBoxA(hWnd, infoLog, "片段着色器编译错误!", 0);
			return -1;
		}
		
		shaderProgram = glCreateProgram();
		glAttachShader(shaderProgram, vertexShader);
		glAttachShader(shaderProgram, fragmentShader);
		
		glLinkProgram(shaderProgram);
		glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);

		if (!success)
		{
			glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
			MessageBoxA(hWnd, infoLog, "着色器程序连接错误!", 0);
			return -1;
		}

		glDeleteShader(vertexShader);
		glDeleteShader(fragmentShader);

		glGenVertexArrays(1, &VAO);
		glGenBuffers(1, &VBO);

		glBindVertexArray(VAO);
		glBindBuffer(GL_ARRAY_BUFFER, VBO);
		
		glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)sizeof(vertices), vertices, GL_STATIC_DRAW);
		
		glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
		glEnableVertexAttribArray(0);

		glBindBuffer(GL_ARRAY_BUFFER, 0);
		glBindVertexArray(0);

		return 0;

	}
		break;
	case WM_PAINT:
	{
		if (glContext)
		{
			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

			glUseProgram(shaderProgram);
			glBindVertexArray(VAO);
			glDrawArrays(GL_TRIANGLES, 0, 3);

			SwapBuffers(hdc);
		}
		return 0;
	}
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

void* GetGLFuncAddress(const char* name)
{
	void* p = (void*)wglGetProcAddress(name);
	if (p == 0 ||
		(p == (void*)0x1) || (p == (void*)0x2) || (p == (void*)0x3) ||
		(p == (void*)-1))
	{
		HMODULE module = LoadLibraryA("opengl32.dll");
		p = (void*)GetProcAddress(module, name);
	}

	return p;
}

最终效果