wayland-starter/include/window.hpp

#ifndef H_WINDOW_
#define H_WINDOW_

#include <string>
#include <cstddef>
#include <cstdio>
#include <stdbool.h>

#include <wayland-client-protocol.h>
#include <wayland-client.h>

#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GLES2/gl2.h>
#include <wayland-egl-core.h>
#include <wayland-egl.h>

#include "xdg-shell-client-protocol.h"
#include "shader.h"

#define UNUSED(x) (void)(x)

class Window;
class Renderer;

class AppState {
public:
	static AppState* GetInstance() {
		if (!AppState::s_instance) AppState::s_instance = new AppState();
		return AppState::s_instance;
	}
private:
static void wm_base_handle_ping(void *data, struct xdg_wm_base *wm_base,
                         uint32_t serial) {
  UNUSED(data);
  printf("INFO: ping method fired! sending pong...\n");
  xdg_wm_base_pong(wm_base, serial);
}

	static void registry_handle_global(void *data, struct wl_registry *registry,
			uint32_t name, const char *interface,
			uint32_t version) {
		UNUSED(data);
		auto state = reinterpret_cast<AppState*>(data);

		printf("HANDLE_GLOBAL: new interface '%s', name = %d, version = %d\n",
				interface, name, version);
		std::string interface_name(interface);
		if (interface_name == "wl_compositor") {
			state->m_compositor = reinterpret_cast<struct wl_compositor *>(
					wl_registry_bind(registry, name, &wl_compositor_interface, version));
			printf("%p compositor binding\n", state->m_compositor);
		}
		if (interface_name == "xdg_wm_base") {
			state->m_wm_base = reinterpret_cast<struct xdg_wm_base *>(
					wl_registry_bind(registry, name, &xdg_wm_base_interface, version));
			if (state->m_wm_base == NULL) {
				fprintf(stderr, "ERROR: could not bind to xdg_wm_base\n");
			}
			state->m_wm_base_listener.ping = wm_base_handle_ping;
			int res = xdg_wm_base_add_listener(state->m_wm_base, &state->m_wm_base_listener,
					NULL);
			printf("bound to wm_base: %d\n", res);
		}
	}

	static void registry_handle_global_remove(void *data, struct wl_registry *registry,
			uint32_t name) {
		UNUSED(data);
		UNUSED(registry);
		UNUSED(name);
	}
private:
	AppState() {
		m_display = wl_display_connect(NULL);
		if (m_display == NULL) {
			fprintf(stderr, "ERROR: could not connect to wl display\n");
			exit(1);
		}

		struct wl_registry *registry = wl_display_get_registry(m_display);
		if (registry == NULL) {
			fprintf(stderr, "ERROR: could not connect to wl registry\n");
			exit(1);
		}

		m_reg_listener.global = registry_handle_global;
		m_reg_listener.global_remove = registry_handle_global_remove;

		auto handle = wl_registry_add_listener(registry, &m_reg_listener, this);
		printf("registry listener bound: %d\n", handle);

		wl_display_roundtrip(m_display);
	}
private:
	static AppState* s_instance;

  struct wl_display *m_display = nullptr;
  struct wl_compositor *m_compositor = nullptr;
  struct xdg_wm_base *m_wm_base = nullptr;

	struct xdg_wm_base_listener m_wm_base_listener;
	struct wl_registry_listener m_reg_listener;

	friend class Window;
	friend class Renderer;
};

AppState* AppState::s_instance = nullptr;

class Renderer {
public:
	static Renderer* GetInstance() {
		if (!s_instance) s_instance = new Renderer;
		return s_instance;
	}
public:
	const EGLConfig& GetConfig() const { return m_config; }
public:
	EGLContext CreateContext() {
		EGLint ctx_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};

		return eglCreateContext(m_egl_display, m_config,
				EGL_NO_CONTEXT, ctx_attribs);
	}

	EGLSurface CreateSurface(struct wl_egl_window* window) {
		PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC createPlatformWindowSurface =
			reinterpret_cast<PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC>(
					eglGetProcAddress("eglCreatePlatformWindowSurfaceEXT"));

		return createPlatformWindowSurface(
				m_egl_display, m_config, window, NULL);
	}

	void SurfaceSetContext(const EGLSurface& surface, const EGLContext& context) {
		if (!eglMakeCurrent(m_egl_display, surface,
					surface, context)) {
			fprintf(stderr, "ERROR: could not change current EGL context\n");
			fprintf(stderr, "EGL error: 0x%x\n", eglGetError());
			exit(1);
		}
	}

	void SwapBuffers(const EGLSurface& surface)
	{
		eglSwapBuffers(m_egl_display, surface);
	}
private:
	Renderer() {
		PFNEGLGETPLATFORMDISPLAYEXTPROC getPlatformDisplay =
			reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(
					eglGetProcAddress("eglGetPlatformDisplayEXT"));

		m_egl_display = getPlatformDisplay(EGL_PLATFORM_WAYLAND_KHR, AppState::GetInstance()->m_display, NULL);
		if (m_egl_display == NULL) {
			fprintf(stderr, "ERROR: could not get platform display\n");
			fprintf(stderr, "EGL error: 0x%x\n", eglGetError());
			exit(1);
		}

		if (!eglInitialize(m_egl_display, NULL, NULL)) {
			fprintf(stderr, "ERROR: could not initialize EGL\n");
			fprintf(stderr, "EGL error: 0x%x\n", eglGetError());
			exit(1);
		}

		EGLint config_attribs[] = {EGL_SURFACE_TYPE,
			EGL_WINDOW_BIT,
			EGL_RENDERABLE_TYPE,
			EGL_OPENGL_ES2_BIT,
			EGL_RED_SIZE,
			8,
			EGL_GREEN_SIZE,
			8,
			EGL_BLUE_SIZE,
			8,
			EGL_ALPHA_SIZE,
			8,
			EGL_NONE};

		EGLint num_configs;
		if (!eglChooseConfig(m_egl_display, config_attribs, &m_config, 1,
					&num_configs)) {
			fprintf(stderr, "ERROR: could not choose EGL config\n");
			fprintf(stderr, "EGL error: 0x%x\n", eglGetError());
			exit(1);
		}
	}
private:
	static Renderer* s_instance;

	EGLDisplay m_egl_display;
	EGLConfig m_config;
};

Renderer* Renderer::s_instance = nullptr;

class Window {
private:
	static void handle_frame_callback(void *data,
		     struct wl_callback *cb,
		     uint32_t time) {
		auto window = reinterpret_cast<Window*>(data);

		UNUSED(time);
		printf("INFO: frame callback\n");

		wl_callback_destroy(cb);
		auto frame_callback = wl_surface_frame(window->m_wsurface);

		window->m_frame_listener.done = handle_frame_callback;

		wl_callback_add_listener(frame_callback, &window->m_frame_listener, window);

		GLint angle_loc = glGetUniformLocation(window->m_program, "angle");

		static float angle = 0.0f;
		angle += 0.02f;

		glClear(GL_COLOR_BUFFER_BIT);

		glUniform1f(angle_loc, angle);
		glDrawArrays(GL_TRIANGLES, 0, 3);

		Renderer::GetInstance()->SwapBuffers(window->m_egl_surface);
	}

	static void xsurface_handle_configure(void *data, struct xdg_surface *surface,
			uint32_t serial) {
		auto window = reinterpret_cast<Window*>(data);

		xdg_surface_ack_configure(surface, serial);

		auto frame_callback = wl_surface_frame(window->m_wsurface);
		printf("frame cb: %p\n", frame_callback);

		window->m_frame_listener.done = handle_frame_callback;

		int cb_res = wl_callback_add_listener(frame_callback,
				&window->m_frame_listener, window);

		printf("mount callback listener: %d\n", cb_res);

		glClear(GL_COLOR_BUFFER_BIT);
		Renderer::GetInstance()->SwapBuffers(window->m_egl_surface);
	}

public:
	Window(size_t width, size_t height) {
		m_wsurface = wl_compositor_create_surface(AppState::GetInstance()->m_compositor);
		if (m_wsurface == NULL) {
			fprintf(stderr, "ERROR: could not connect create a surface\n");
			exit(1);
		}

		m_egl_window =
			wl_egl_window_create(m_wsurface, width, height);
		if (m_egl_window == NULL) {
			fprintf(stderr, "ERROR: could not create wl_egl_window\n");
			exit(1);
		}

		m_egl_surface = Renderer::GetInstance()->CreateSurface(m_egl_window);
		if (m_egl_surface == NULL) {
			fprintf(stderr, "ERROR: could not create EGL window surface\n");
			fprintf(stderr, "EGL error: 0x%x\n", eglGetError());
			exit(1);
		}

		m_egl_context = Renderer::GetInstance()->CreateContext();
		if (m_egl_context == NULL) {
			fprintf(stderr, "ERROR: could not create EGL context\n");
			fprintf(stderr, "EGL error: 0x%x\n", eglGetError());
			exit(1);
		}

		Renderer::GetInstance()->SurfaceSetContext(m_egl_surface, m_egl_context);

		const char *vs_src = "attribute vec2 pos;\n"
			"uniform float angle;\n"
			"void main() {\n"
			"  float c = cos(angle);\n"
			"  float s = sin(angle);\n"
			"  mat2 rot = mat2(c, -s, s, c);\n"
			"  gl_Position = vec4(rot * pos, 0.0, 1.0);\n"
			"}\n";

		const char *fs_src = "precision mediump float;\n"
			"void main() {\n"
			"  gl_FragColor = vec4(1.0, 0.3, 0.2, 1.0);\n"
			"}\n";

		m_program = create_program(vs_src, fs_src);
		glUseProgram(m_program);

		GLint pos_loc = glGetAttribLocation(m_program, "pos");
		// GLint angle_loc = glGetUniformLocation(app_state->program, "angle");

		float vertices[] = {0.0f, 0.6f, -0.6f, -0.6f, 0.6f, -0.6f};

		glEnableVertexAttribArray(pos_loc);
		glVertexAttribPointer(pos_loc, 2, GL_FLOAT, GL_FALSE, 0, vertices);
		glViewport(0, 0, width, height);
		glClearColor(0.2f, 0.4f, 0.8f, 1.0f);

		m_xsurface =
			xdg_wm_base_get_xdg_surface(AppState::GetInstance()->m_wm_base, m_wsurface);
		if (m_xsurface == NULL) {
			fprintf(stderr, "ERROR: could not get an xdg surface\n");
			exit(1);
		}

		m_toplevel = xdg_surface_get_toplevel(m_xsurface);
		if (m_toplevel == NULL) {
			fprintf(stderr, "ERROR: could not get an xdg toplevel\n");
			exit(1);
		}

		m_xsurface_listener.configure = xsurface_handle_configure;

		xdg_surface_add_listener(m_xsurface, &m_xsurface_listener, this);
		wl_surface_commit(m_wsurface);

		while (wl_display_dispatch(AppState::GetInstance()->m_display)) {
		}
	}
	~Window() {}

	Window(const Window&) = delete;
	Window(Window&&) = delete;
private:
	EGLSurface m_egl_surface;
	EGLContext m_egl_context;

	GLuint m_program;

	struct wl_egl_window *m_egl_window;
  struct wl_surface *m_wsurface;
  struct xdg_surface *m_xsurface;
  struct xdg_toplevel *m_toplevel;

	struct wl_callback_listener m_frame_listener;
	struct xdg_surface_listener m_xsurface_listener;
};

#endif // H_WINDOW_