wayland-starter/include/window.hpp

#ifndef H_WINDOW_
#define H_WINDOW_

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

#include <wayland-client-core.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 "shader.h"
#include "xdg-shell-client-protocol.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("[DEBUG] global_binding(%s): compositor %p\n", interface,
             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));
      printf("[DEBUG] global_binding(%s): xdg_wm_base %p\n", interface,
             state->m_wm_base);
      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;
      xdg_wm_base_add_listener(state->m_wm_base, &state->m_wm_base_listener,
                               NULL);
    }
  }

  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("[DEBUG] wl_registry listener bound: %d\n", handle);

    wl_display_roundtrip(m_display);
  }
	~AppState() {
		wl_display_flush(m_display);
		wl_display_roundtrip(m_display);

		if (m_wm_base)
			xdg_wm_base_destroy(m_wm_base);
		if (m_compositor)
			wl_compositor_destroy(m_compositor);

		wl_display_disconnect(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:
	void DestroyWindow(const EGLSurface& surface, struct wl_egl_window* window) {
		eglMakeCurrent(m_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
		eglDestroySurface(m_egl_display, surface);
		wl_egl_window_destroy(window);
	}

	void DestroyContext(const EGLContext& context) {
		eglDestroyContext(m_egl_display, context);
	}

  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);
    }
  }
	~Renderer() {
		// After all windows are destroyed:
		eglTerminate(m_egl_display);
	}

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);
		if (!window->m_runnning) return;
    // auto delta_time = time - window->m_last_time;
    // printf("INFO: frame callback called\n");
    // printf("INFO: time: {%u}\n", time);
    // printf("INFO: last_time: {%u}\n", window->m_last_time);
    // printf("INFO: delta_time: {%u}\n", delta_time);
    // printf("INFO: fps: {%u}\n", 1000 / delta_time);
    window->m_last_time = time;

    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);
  }

  static void xtoplevel_handle_configure(void *data,
                                         struct xdg_toplevel *toplevel,
                                         int32_t width, int32_t height,
                                         struct wl_array *states) {
    UNUSED(toplevel);
    auto window = reinterpret_cast<Window*>(data);
    printf("[DEBUG] received toplevel configure event\n");
    printf("[DEBUG] width = %d, height = %d\n", width, height);
    printf("[DEBUG] %zu states\n", states->size);

		wl_egl_window_resize(window->m_egl_window, width, height, 0, 0);
		glViewport(0, 0, width, height);
		xdg_surface_set_window_geometry(window->m_xsurface, 0, 0, width, height);
  }

  static void xtoplevel_handle_close(void *data,
                                     struct xdg_toplevel *toplevel) {
    auto window = reinterpret_cast<Window*>(data);
    UNUSED(toplevel);
    printf("[DEBUG] window close request received\n");
		window->m_runnning = false;

		glDeleteProgram(window->m_program);
		Renderer::GetInstance()->DestroyWindow(window->m_egl_surface, window->m_egl_window);
		xdg_toplevel_destroy(window->m_toplevel);
		xdg_surface_destroy(window->m_xsurface);
		wl_surface_destroy(window->m_wsurface);
    // if (window->m_program) {
    //     eglMakeCurrent(renderer_display, m_egl_surface, m_egl_surface, m_egl_context);
    //     glDeleteProgram(m_program);
    //     glDeleteBuffers(1, &m_vbo); // if used
    //     eglMakeCurrent(renderer_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    //     m_program = 0;
    // }
		Renderer::GetInstance()->DestroyContext(window->m_egl_context);
  }

  static void xtoplevel_handle_configure_bounds(void *data,
                                                struct xdg_toplevel *toplevel,
                                                int32_t width, int32_t height) {
    UNUSED(data);
    UNUSED(toplevel);
    printf("[DEBUG] window configure bounds, width = %d, height = %d\n", width,
           height);
  }

	static void xtoplevel_handle_wm_capabilities(void *data,
				struct xdg_toplevel *toplevel,
				struct wl_array *capabilities) {
		UNUSED(data);
		UNUSED(toplevel);
		UNUSED(capabilities);
		printf("[DEBUG] window wm_capabilities event received\n");
	}

public:
  Window(size_t width, size_t height) : m_frame_listener({0}), m_last_time(0), m_width(width), m_height(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 = new float[6]{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);

    m_toplevel_listener.configure = xtoplevel_handle_configure;
		m_toplevel_listener.configure_bounds = xtoplevel_handle_configure_bounds;
		m_toplevel_listener.close = xtoplevel_handle_close;
		m_toplevel_listener.wm_capabilities = xtoplevel_handle_wm_capabilities;
    xdg_toplevel_add_listener(m_toplevel, &m_toplevel_listener, this);

    wl_surface_commit(m_wsurface);
  }
  ~Window() {}

  Window(const Window &) = delete;
  Window(Window &&) = delete;

public:
  void Run() {
		m_runnning = true;
    printf("[DEBUG] Run(): display = %p\n", AppState::GetInstance()->m_display);
    while (m_runnning && wl_display_dispatch(AppState::GetInstance()->m_display) != -1) {
    }
  }

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;
  struct xdg_toplevel_listener m_toplevel_listener;

private: // app logic
  uint32_t m_last_time;
	size_t m_width;
	size_t m_height;
	bool m_runnning;
};

#endif // H_WINDOW_