wintoys

win32_gldemo.c (5713B)

---

 #define WIN32_LEAN_AND_MEAN 1
 #include <windows.h>
 
 #include <EGL/egl.h>
 // #include <EGL/eglplatform.h>
 // #include <GLES2/gl2.h>
 
 static void
 win32_process_messages(void);
 
 LRESULT CALLBACK
 win32_window_proc(HWND window, UINT msg, WPARAM wparam, LPARAM lparam);
 
 static void
 render_init(void);
 
 static void
 render(UINT width, UINT height, EGLDisplay egl_display, EGLSurface egl_surface);
 
 static bool win32_running;
 static HWND win32_window;
 
 int WINAPI
 WinMain(HINSTANCE instance, HINSTANCE prev_instance, PSTR cmdline, int cmdshown)
 {
 	(void) instance;
 	(void) prev_instance;
 	(void) cmdline;
 	(void) cmdshown;
 
 	const char classname[] = "gldemo_wndcls";
 
 	// https://learn.microsoft.com/en-us/windows/win32/api/winuser/ns-winuser-wndclassexa
 	WNDCLASSEXA cls = {
 		.cbSize = sizeof(WNDCLASSEXA),
 		.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW,
 		.lpfnWndProc = win32_window_proc,
 		.hInstance = instance,
 		.lpszClassName = classname,
 	};
 
 	// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-registerclassexa
 	RegisterClassExA(&cls);
 
 	// https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-createwindowexa
 	win32_window = CreateWindowExA(
 			0,
 			classname,
 			"gldemo",
 			WS_OVERLAPPEDWINDOW, 
 			CW_USEDEFAULT,
 			CW_USEDEFAULT,
 			CW_USEDEFAULT,
 			CW_USEDEFAULT,
 			NULL,
 			NULL,
 			instance,
 			NULL);
 
 	if (!win32_window) {
 		fprintf(stderr, "Failed to create Win32 window!\n");
 		return 1;
 	}
 
 	ShowWindow(win32_window, 1);
 
 	// get a handle to the win32 display context
 	HDC egl_hdc = GetDC(win32_window);
 
 	// wrap the HDC on the EGL side
 	EGLDisplay egl_display = eglGetDisplay(egl_hdc);
 
 	// find out what version of EGL we support
 	EGLint major, minor;
 	eglInitialize(egl_display, &major, &minor);
 	fprintf(stderr, "EGL version: %d.%d\n", major, minor);
 
 	// initialise the OpenGL ES version of the GL api
 	// NOTE: this is an alternative version of the OpenGL API that is more
 	// limited, but runs on more devices. consider using this only if
 	// learning OpenGL as it is more transferrable and closer to bare metal
 	// programming! If you would want to move to Vulkan later, it might be
 	// easier to do so having learnt OpenGL ES
 	eglBindAPI(EGL_OPENGL_ES_API);
 
 	// NOTE: if you want the original OpenGL api, use this. it may require
 	// changing some of the context attrs we define later as well to avoid
 	// errors
 	// eglBindAPI(EGL_OPENGL_API);
 
 	// setup some parameters for the API that we expect to hold
 	EGLint config_attrs[] = {
 		EGL_RED_SIZE, 8,
 		EGL_GREEN_SIZE, 8,
 		EGL_BLUE_SIZE, 8,
 		EGL_ALPHA_SIZE, 8,
 		EGL_NONE,
 	};
 
 	// select an API config that matches the parameters we wanted (if any)
 	EGLConfig config;
 	EGLint num_config;
 	eglChooseConfig(egl_display, config_attrs, &config, 1, &num_config);
 
 	// create a surface that allows egl to write to our win32 window
 	EGLint surface_attrs[] = {
 		EGL_NONE,
 	};
 	EGLSurfaec egl_surface = eglCreateWindowSurface(egl_display, config, win32_window, surface_attrs);
 
 	// create an egl context that our GL commands will operate on
 	EGLint context_attrs[] = {
 		EGL_CONTEXT_CLIENT_VERSION, 2,
 		EGL_NONE,
 	};
 	EGLContext egl_context = eglCreateContext(egl_display, config, EGL_NO_CONTEXT, context_attrs);
 
 	// set our current egl display, surface, and context as the ones all
 	// GL commands from the current thread should operate on
 	eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context);
 
 	render_init();
 
 	LARGE_INTEGER perf_frequency, start_perf_count, end_perf_count;
 	QueryPerformanceFrequency(&perf_frequency);
 
 	win32_running = true;
 	while (win32_running) {
 		QueryPerformanceCounter(&start_perf_count);
 		uint64_t start_cycles = __rdtsc();
 
 		win32_process_messages();
 
 		GetClientRect(win32_window, &rect);
 		render(rect.right - rect.left, recv.bottom - rect.top);
 
 		uint64_t end_cycles = __rdtsc();
 		QueryPerformanceCounter(&end_perf_count);
 
 		const uint64_t micros = 1000 * 1000;
 		uint64_t elapsed_micros = (end_perf_count.QuadPart - start_perf_count.QuadPart) * micros / perf_frequency.QuadPart;
 		uint64_t elapsed_cycles = end_cycles - start_cycles;
 
 		char buf[256];
 		snprintf(buf, sizeof buf, "Frame Timings: %" PRIu64 "us, %" PRIu64 " Cy\n", elapsed_micros, elapsed_cycles);
 		OutputDebugString(buf);
 	}
 
 	return 0;
 }
 
 static void
 win32_process_messages(void)
 {
 	MSG msg;
 	while (PeekMessageA(&msg, win32_window, 0, 0, PM_REMOVE)) {
 		switch (msg.message) {
 		default:
 			break;
 		}
 
 		TranslateMessage(&msg);
 		DispatchMessageA(&msg);
 	}
 }
 
 LRESULT CALLBACK
 win32_window_proc(HWND window, UINT msg, WPARAM wparam, LPARAM lparam)
 {
 	switch (msg) {
 	case WM_QUIT:
 	case WM_DESTROY: {
 		win32_running = false;
 	} break;
 
 	default:
 		return DefWindowProcA(window, msg, wparam, lparam);
 	}
 
 	return 0;
 }
 
 // actual rendering implementation
 // ===========================================================================
 
 // this performs one-time setup for our GL render pipeline
 static void
 render_init(void)
 {
 	glClearColor(0.0f, 0.0f, 0.2f, 1.0f);
 }
 
 // this is called for every frame that we want to render with our pipeline
 static void
 render(UINT width, UINT height, EGLDisplay egl_display, EGLSurface egl_surface)
 {
 	// select our entire window as our render viewport
 	glViewport(0, 0, width, height);
 
 	// clear the current viewport to the previously set glClearColor()
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
 	// log any errors encountered during rendering this frame
 	GLuint error = glGetError();
 	if (error != GL_NO_ERROR) {
 		fprintf(stderr, "OpenGL Error : %d\n", error);
 	}
 
 	// finish rendering, and wait for vsync before drawing this frame
 	eglSwapBuffer(egl_display, egl_surface);
 
 	fprintf(stderr, "Rendered frame!\n");
 }