diff --git a/Makefile b/Makefile index 375a432..f6ac57c 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,7 @@ CFLAGS = -Wall -Wextra -I./include/ -g LIBS = $(shell pkg-config --libs wayland-client wayland-egl egl glesv2) -build/main: src/main.cpp build/shader.o build/xdg-shell-protocol.o +build/main: src/main.cpp include/window.hpp build/shader.o build/xdg-shell-protocol.o g++ -o build/main $(CFLAGS) src/main.cpp build/shader.o build/xdg-shell-protocol.o $(LIBS) build/shader.o: src/shader.cpp include/shader.h diff --git a/include/window.hpp b/include/window.hpp index 8007807..5064051 100644 --- a/include/window.hpp +++ b/include/window.hpp @@ -1,11 +1,12 @@ #ifndef H_WINDOW_ #define H_WINDOW_ -#include #include #include #include +#include +#include #include #include @@ -15,8 +16,8 @@ #include #include -#include "xdg-shell-client-protocol.h" #include "shader.h" +#include "xdg-shell-client-protocol.h" #define UNUSED(x) (void)(x) @@ -25,323 +26,436 @@ class Renderer; class AppState { public: - static AppState* GetInstance() { - if (!AppState::s_instance) AppState::s_instance = new AppState(); - return AppState::s_instance; - } + 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 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(data); + 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(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( - 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( - 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); - } - } + // 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( + 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( + 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); + } - 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); - } + 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); - } + 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; + 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); + 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; + 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; + struct xdg_wm_base_listener m_wm_base_listener; + struct wl_registry_listener m_reg_listener; - friend class Window; - friend class Renderer; + friend class Window; + friend class Renderer; }; -AppState* AppState::s_instance = nullptr; +AppState *AppState::s_instance = nullptr; class Renderer { public: - static Renderer* GetInstance() { - if (!s_instance) s_instance = new Renderer; - return s_instance; - } + static Renderer *GetInstance() { + if (!s_instance) + s_instance = new Renderer; + return s_instance; + } + public: - const EGLConfig& GetConfig() const { return m_config; } + 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); + 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); } - EGLSurface CreateSurface(struct wl_egl_window* window) { - PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC createPlatformWindowSurface = - reinterpret_cast( - eglGetProcAddress("eglCreatePlatformWindowSurfaceEXT")); - - return createPlatformWindowSurface( - m_egl_display, m_config, window, NULL); + void DestroyContext(const EGLContext& context) { + eglDestroyContext(m_egl_display, context); } - 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); - } - } + 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( + 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); + } - void SwapBuffers(const EGLSurface& surface) - { - eglSwapBuffers(m_egl_display, surface); - } private: - Renderer() { - PFNEGLGETPLATFORMDISPLAYEXTPROC getPlatformDisplay = - reinterpret_cast( - eglGetProcAddress("eglGetPlatformDisplayEXT")); + Renderer() { + PFNEGLGETPLATFORMDISPLAYEXTPROC getPlatformDisplay = + reinterpret_cast( + 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); - } + 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); - } + 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 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); - } + 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; +private: + static Renderer *s_instance; + + EGLDisplay m_egl_display; + EGLConfig m_config; }; -Renderer* Renderer::s_instance = nullptr; +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(data); + static void handle_frame_callback(void *data, struct wl_callback *cb, + uint32_t time) { + auto window = reinterpret_cast(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; - UNUSED(time); - printf("INFO: frame callback\n"); + wl_callback_destroy(cb); + auto frame_callback = wl_surface_frame(window->m_wsurface); - wl_callback_destroy(cb); - auto frame_callback = wl_surface_frame(window->m_wsurface); + window->m_frame_listener.done = handle_frame_callback; - window->m_frame_listener.done = handle_frame_callback; + wl_callback_add_listener(frame_callback, &window->m_frame_listener, window); - wl_callback_add_listener(frame_callback, &window->m_frame_listener, window); + GLint angle_loc = glGetUniformLocation(window->m_program, "angle"); - GLint angle_loc = glGetUniformLocation(window->m_program, "angle"); + static float angle = 0.0f; + angle += 0.02f; - static float angle = 0.0f; - angle += 0.02f; + glClear(GL_COLOR_BUFFER_BIT); - glClear(GL_COLOR_BUFFER_BIT); + glUniform1f(angle_loc, angle); + glDrawArrays(GL_TRIANGLES, 0, 3); - glUniform1f(angle_loc, angle); - glDrawArrays(GL_TRIANGLES, 0, 3); + Renderer::GetInstance()->SwapBuffers(window->m_egl_surface); + } - 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(data); - static void xsurface_handle_configure(void *data, struct xdg_surface *surface, - uint32_t serial) { - auto window = reinterpret_cast(data); + xdg_surface_ack_configure(surface, serial); - xdg_surface_ack_configure(surface, serial); + auto frame_callback = wl_surface_frame(window->m_wsurface); + printf("frame cb: %p\n", frame_callback); - auto frame_callback = wl_surface_frame(window->m_wsurface); - printf("frame cb: %p\n", frame_callback); + window->m_frame_listener.done = handle_frame_callback; - window->m_frame_listener.done = handle_frame_callback; + int cb_res = wl_callback_add_listener(frame_callback, + &window->m_frame_listener, window); - int cb_res = wl_callback_add_listener(frame_callback, - &window->m_frame_listener, window); + printf("mount callback listener: %d\n", cb_res); - printf("mount callback listener: %d\n", cb_res); + glClear(GL_COLOR_BUFFER_BIT); + Renderer::GetInstance()->SwapBuffers(window->m_egl_surface); + } - 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(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(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_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); - } + 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_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_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); - } + 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); + 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 *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"; + 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); + 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"); + 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}; + 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); + 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_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_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; + m_xsurface_listener.configure = xsurface_handle_configure; + xdg_surface_add_listener(m_xsurface, &m_xsurface_listener, this); - xdg_surface_add_listener(m_xsurface, &m_xsurface_listener, this); - wl_surface_commit(m_wsurface); + 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); - while (wl_display_dispatch(AppState::GetInstance()->m_display)) { - } - } - ~Window() {} + 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) { + } + } - Window(const Window&) = delete; - Window(Window&&) = delete; private: - EGLSurface m_egl_surface; - EGLContext m_egl_context; + EGLSurface m_egl_surface; + EGLContext m_egl_context; - GLuint m_program; + GLuint m_program; - struct wl_egl_window *m_egl_window; + 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 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_ diff --git a/src/main.cpp b/src/main.cpp index 87eebb7..9da4a89 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -6,7 +6,11 @@ int main(int argc, char **argv) { UNUSED(argc); UNUSED(argv); + AppState::GetInstance(); + Renderer::GetInstance(); + Window window(720, 480); + window.Run(); return 0; }