From e1f41b09ffdc295021e8b83a6059233b8c4c70ef Mon Sep 17 00:00:00 2001 From: Luna Date: Sat, 19 Apr 2025 13:36:13 +0200 Subject: [PATCH] mrrrp --- .gitignore | 1 + main.c | 12 +- main_layer.c | 99 +++ nob.c | 37 +- res/{ => images}/neocat.png | Bin res/shaders/{frag.frag => frag.glsl} | 0 res/shaders/{vert.vert => vert.glsl} | 0 src/Wayland/wlr-layer-shell-client-protocol.h | 734 ++++++++++++++++++ src/Wayland/wlr-layer-shell-client.c | 95 +++ src/comp.h | 2 +- src/glfw.c | 2 +- src/gpu_allocator.c | 2 +- src/kitty.c | 1 - src/kitty.h | 2 +- src/lang/ast.h | 2 +- src/paw_phys.c | 118 +++ src/paw_phys.h | 43 +- src/paw_reg.c | 35 + src/paw_reg.h | 32 + src/{paw_object.c => paw_scene.c} | 22 +- src/{paw_object.h => paw_scene.h} | 7 +- src/{vulkan.c => paw_vk.c} | 2 +- src/{vulkan.h => paw_vk.h} | 0 src/register.c | 35 - src/register.h | 32 - src/types.c | 7 +- src/types.h | 10 + src/wayland.c | 96 ++- src/wayland.h | 3 + trig.c | 4 +- 30 files changed, 1322 insertions(+), 113 deletions(-) create mode 100644 main_layer.c rename res/{ => images}/neocat.png (100%) rename res/shaders/{frag.frag => frag.glsl} (100%) rename res/shaders/{vert.vert => vert.glsl} (100%) create mode 100644 src/Wayland/wlr-layer-shell-client-protocol.h create mode 100644 src/Wayland/wlr-layer-shell-client.c create mode 100644 src/paw_reg.c create mode 100644 src/paw_reg.h rename src/{paw_object.c => paw_scene.c} (89%) rename src/{paw_object.h => paw_scene.h} (87%) rename src/{vulkan.c => paw_vk.c} (99%) rename src/{vulkan.h => paw_vk.h} (100%) delete mode 100644 src/register.c delete mode 100644 src/register.h diff --git a/.gitignore b/.gitignore index 51a6a24..be6c3e5 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,4 @@ nob build/* nob.old main +main_layer diff --git a/main.c b/main.c index c66545e..5314a51 100644 --- a/main.c +++ b/main.c @@ -1,6 +1,6 @@ #include "src/comp.h" -#include "src/paw_object.h" -#include "src/register.h" +#include "src/paw_reg.h" +#include "src/paw_scene.h" #include "trig.c" /* #include "src/lang/ast.h" */ @@ -19,9 +19,9 @@ int main() { struct Vk *vk; cat_Comp *state = cat_comp_init("meooow", 500, 500, &vk); - struct Register *reg = make_register(); - reg_attatch_type(reg, "trig", OBJ_MAKE make_trig, OBJ_FREE free_trig, - OBJ_TICK trig_tick); + struct PawReg *reg = paw_reg_make(); + paw_reg_attatch_type(reg, "trig", PAW_OBJ_MAKE make_trig, + PAW_OBJ_FREE free_trig, PAW_OBJ_TICK trig_tick); struct PawScene *scene = paw_scene_make(vk, reg); paw_scene_queue_insert(scene, "trig", trig_make_args(scene)); @@ -32,7 +32,7 @@ int main() { } paw_scene_free(scene); - free_register(reg); + paw_reg_free(reg); cat_comp_uninit(state); diff --git a/main_layer.c b/main_layer.c new file mode 100644 index 0000000..30cf4b6 --- /dev/null +++ b/main_layer.c @@ -0,0 +1,99 @@ +#include "src/kitty.h" +#include "src/matrix.h" +#include "src/types.h" +#include "src/util.h" +#include "src/wayland.h" +#include +#include + +#define INSTANCE_COUNT 1000 +#define TRIG_VERTEX_COUNT 6 +struct Vertex trig_vertices[TRIG_VERTEX_COUNT] = { + (struct Vertex){(struct Vec2){.x = -0.5f, .y = -0.5f}, + (struct Vec3){1.0f, 0.0f, 1.0f}}, + (struct Vertex){(struct Vec2){.x = 0.5f, .y = -0.5f}, + (struct Vec3){1.0f, 0.0f, 0.0f}}, + (struct Vertex){(struct Vec2){.x = 0.5f, .y = 0.5f}, + (struct Vec3){1.0f, 0.0f, 1.0f}}, + (struct Vertex){(struct Vec2){.x = -0.5f, .y = -0.5f}, + (struct Vec3){1.0f, 0.0f, 1.0f}}, + (struct Vertex){(struct Vec2){.x = 0.5f, .y = 0.5f}, + (struct Vec3){1.0f, 0.0f, 1.0f}}, + (struct Vertex){(struct Vec2){.x = -0.5f, .y = 0.5f}, + (struct Vec3){0.0f, 0.0f, 1.0f}}, +}; +struct TrigUBO { + struct mat3x3 view; + struct mat3x3 proj; +}; + +int main() { + struct Vk *vk; + struct cat_Wl *state = cat_init_wl_layer("meooow", &vk); + + struct Vec2 vel[INSTANCE_COUNT]; + struct Vec2 pos[INSTANCE_COUNT]; + float rot[INSTANCE_COUNT]; + struct Kitty *kitty = kitty_make(NULL); + kitty_set_vertex_shader(kitty, "./res/shaders/vert.spv"); + kitty_set_fragment_shader(kitty, "./res/shaders/frag.spv"); + kitty_set_vertex_buffer(kitty, trig_vertices, TRIG_VERTEX_COUNT, + sizeof(struct Vertex)); + kitty_add_vertex_buffer_format(kitty, VK_FORMAT_R32G32_SFLOAT); + kitty_add_vertex_buffer_format(kitty, VK_FORMAT_R32G32B32_SFLOAT); + kitty_attatch_ubo(kitty, sizeof(struct TrigUBO)); + kitty_attatch_ubo(kitty, sizeof(struct mat3x3) * INSTANCE_COUNT); + kitty_attatch_image(kitty, "./res/images/neocat.png"); + uint32_t instance_buffer[INSTANCE_COUNT] = {0}; + for (int i = 0; i < INSTANCE_COUNT; i++) { + instance_buffer[i] = i; + rot[i] = randf() * 2.0f * PI; + pos[i] = (struct Vec2){randf(), randf()}; + vel[i] = vec2_mul( + vec2_normalize((struct Vec2){randf() - 0.5f, randf() - 0.5f}), 0.2f); + /* trig->vel[i] = (struct Vec2){1.0f, 0.0f}; */ + } + kitty_add_instance_buffer(kitty, instance_buffer, INSTANCE_COUNT, + sizeof(uint32_t)); + kitty_add_instance_buffer_format(kitty, VK_FORMAT_R32_UINT); + + kitty_finalise(vk, kitty); + + float delta_secs = 1.0f / 1000.0f; + while (!cat_wl_should_close(state)) { + struct TrigUBO ubo = {0}; + ubo.view = multiply3x3(translate3x3((struct Vec2){-1.5f, -0.5f}), + scale3x3((struct Vec2){1.0f, 1.0f})); + ubo.proj = + scale3x3((struct Vec2){1.f, (float)vk->width / (float)vk->heigh}); + kitty_set_next_ubo(vk, kitty, 0, &ubo); + + struct mat3x3 *model = kitty_get_next_ubo_pointer(vk, kitty, 1); + for (int i = 0; i < INSTANCE_COUNT; i++) { + pos[i] = vec2_add(pos[i], vec2_mul(vel[i], delta_secs)); + rot[i] += delta_secs; + if (pos[i].x < 0 || pos[i].x > 2.5) { + vel[i].x = -vel[i].x; + } + if (pos[i].y < -0.5 || pos[i].y > 2) { + vel[i].y = -vel[i].y; + } + model[i] = IDENT3x3; + model[i] = multiply3x3(model[i], translate3x3(pos[i])); + model[i] = multiply3x3(model[i], rotate3x3(rot[i])); + model[i] = multiply3x3(model[i], scale3x3((struct Vec2){0.1f, 0.1f})); + } + cat_wl_draw(state); + struct timespec t = { + .tv_sec = 0, + .tv_nsec = 10000000, + }; + nanosleep(&t, NULL); + } + + kitty_free(vk, kitty); + cat_uninit_wl(state); + + state = NULL; + vk = NULL; +} diff --git a/nob.c b/nob.c index b0f4172..c8b6a6f 100644 --- a/nob.c +++ b/nob.c @@ -48,11 +48,16 @@ bool process_res(char *res_base) { if (memcmp(tmp + 1, "vert", strlen("vert")) == 0 || memcmp(tmp + 1, "frag", strlen("frag")) == 0) { *tmp = 0x0; - // path now looks like meooow 0x0 glsl - cmd_append(&cmd, scomp, "-c"); - cmd_append(&cmd, "-o", temp_sprintf("%s%s%s", res_base, path, ".spv"), - temp_sprintf("%s%s.%s", res_base, path, tmp + 1)); - da_append(&procs, cmd_run_async_and_reset(&cmd)); + char *output = temp_sprintf("%s%s%s", res_base, path, ".spv"); + char *input = temp_sprintf("%s%s.%s", res_base, path, tmp + 1); + if (nob_needs_rebuild(output, (const char **)&input, 1)) { + // path now looks like meooow 0x0 glsl + cmd_append(&cmd, scomp, "-c"); + cmd_append(&cmd, "-o", input, output); + da_append(&procs, cmd_run_async_and_reset(&cmd)); + } else { + printf("skipping %s, already up to date\n", input); + } } } @@ -103,14 +108,20 @@ bool discover_build(char *src_base, char *build_base) { } if (*(tmp + 1) == 'c') { *tmp = 0x0; - // path now looks like meooow 0x0 c - cmd_append(&cmd, comp, "-c"); - for (int j = 0; j < len(cflags); j++) { - cmd_append(&cmd, cflags[j]); + char *output = temp_sprintf("%s%s%s", build_base, path, ".o"); + char *input = temp_sprintf("%s%s%s", src_base, path, ".c"); + if (nob_needs_rebuild(output, (const char **)&input, 1)) { + // path now looks like meooow 0x0 c + cmd_append(&cmd, comp, "-c"); + for (int j = 0; j < len(cflags); j++) { + cmd_append(&cmd, cflags[j]); + } + cmd_append(&cmd, "-o", output, + temp_sprintf("%s%s%s", src_base, path, ".c")); + da_append(&procs, cmd_run_async_and_reset(&cmd)); + } else { + printf("skipping %s, already up to date\n", input); } - cmd_append(&cmd, "-o", temp_sprintf("%s%s%s", build_base, path, ".o"), - temp_sprintf("%s%s%s", src_base, path, ".c")); - da_append(&procs, cmd_run_async_and_reset(&cmd)); da_append(&src_cpaths, temp_sprintf("%s%s%s", build_base, path, ".o")); } @@ -158,7 +169,7 @@ int main(int argc, char **argv) { for (int j = 0; j < len(cflags); j++) { cmd_append(&cmd, cflags[j]); } - cmd_append(&cmd, "-o", "main", "main.c"); + cmd_append(&cmd, "-o", "main_layer", "main_layer.c"); for (int i = 0; i < src_cpaths.count; i++) { cmd_append(&cmd, src_cpaths.items[i]); } diff --git a/res/neocat.png b/res/images/neocat.png similarity index 100% rename from res/neocat.png rename to res/images/neocat.png diff --git a/res/shaders/frag.frag b/res/shaders/frag.glsl similarity index 100% rename from res/shaders/frag.frag rename to res/shaders/frag.glsl diff --git a/res/shaders/vert.vert b/res/shaders/vert.glsl similarity index 100% rename from res/shaders/vert.vert rename to res/shaders/vert.glsl diff --git a/src/Wayland/wlr-layer-shell-client-protocol.h b/src/Wayland/wlr-layer-shell-client-protocol.h new file mode 100644 index 0000000..24dc45c --- /dev/null +++ b/src/Wayland/wlr-layer-shell-client-protocol.h @@ -0,0 +1,734 @@ +/* Generated by wayland-scanner 1.23.0 */ + +#ifndef WLR_LAYER_SHELL_UNSTABLE_V1_CLIENT_PROTOCOL_H +#define WLR_LAYER_SHELL_UNSTABLE_V1_CLIENT_PROTOCOL_H + +#include +#include +#include "wayland-client.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @page page_wlr_layer_shell_unstable_v1 The wlr_layer_shell_unstable_v1 protocol + * @section page_ifaces_wlr_layer_shell_unstable_v1 Interfaces + * - @subpage page_iface_zwlr_layer_shell_v1 - create surfaces that are layers of the desktop + * - @subpage page_iface_zwlr_layer_surface_v1 - layer metadata interface + * @section page_copyright_wlr_layer_shell_unstable_v1 Copyright + * 
+ *
+ * Copyright © 2017 Drew DeVault
+ *
+ * Permission to use, copy, modify, distribute, and sell this
+ * software and its documentation for any purpose is hereby granted
+ * without fee, provided that the above copyright notice appear in
+ * all copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of
+ * the copyright holders not be used in advertising or publicity
+ * pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied
+ * warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ *
+ */ +struct wl_output; +struct wl_surface; +struct xdg_popup; +struct zwlr_layer_shell_v1; +struct zwlr_layer_surface_v1; + +#ifndef ZWLR_LAYER_SHELL_V1_INTERFACE +#define ZWLR_LAYER_SHELL_V1_INTERFACE +/** + * @page page_iface_zwlr_layer_shell_v1 zwlr_layer_shell_v1 + * @section page_iface_zwlr_layer_shell_v1_desc Description + * + * Clients can use this interface to assign the surface_layer role to + * wl_surfaces. Such surfaces are assigned to a "layer" of the output and + * rendered with a defined z-depth respective to each other. They may also be + * anchored to the edges and corners of a screen and specify input handling + * semantics. This interface should be suitable for the implementation of + * many desktop shell components, and a broad number of other applications + * that interact with the desktop. + * @section page_iface_zwlr_layer_shell_v1_api API + * See @ref iface_zwlr_layer_shell_v1. + */ +/** + * @defgroup iface_zwlr_layer_shell_v1 The zwlr_layer_shell_v1 interface + * + * Clients can use this interface to assign the surface_layer role to + * wl_surfaces. Such surfaces are assigned to a "layer" of the output and + * rendered with a defined z-depth respective to each other. They may also be + * anchored to the edges and corners of a screen and specify input handling + * semantics. This interface should be suitable for the implementation of + * many desktop shell components, and a broad number of other applications + * that interact with the desktop. + */ +extern const struct wl_interface zwlr_layer_shell_v1_interface; +#endif +#ifndef ZWLR_LAYER_SURFACE_V1_INTERFACE +#define ZWLR_LAYER_SURFACE_V1_INTERFACE +/** + * @page page_iface_zwlr_layer_surface_v1 zwlr_layer_surface_v1 + * @section page_iface_zwlr_layer_surface_v1_desc Description + * + * An interface that may be implemented by a wl_surface, for surfaces that + * are designed to be rendered as a layer of a stacked desktop-like + * environment. + * + * Layer surface state (layer, size, anchor, exclusive zone, + * margin, interactivity) is double-buffered, and will be applied at the + * time wl_surface.commit of the corresponding wl_surface is called. + * + * Attaching a null buffer to a layer surface unmaps it. + * + * Unmapping a layer_surface means that the surface cannot be shown by the + * compositor until it is explicitly mapped again. The layer_surface + * returns to the state it had right after layer_shell.get_layer_surface. + * The client can re-map the surface by performing a commit without any + * buffer attached, waiting for a configure event and handling it as usual. + * @section page_iface_zwlr_layer_surface_v1_api API + * See @ref iface_zwlr_layer_surface_v1. + */ +/** + * @defgroup iface_zwlr_layer_surface_v1 The zwlr_layer_surface_v1 interface + * + * An interface that may be implemented by a wl_surface, for surfaces that + * are designed to be rendered as a layer of a stacked desktop-like + * environment. + * + * Layer surface state (layer, size, anchor, exclusive zone, + * margin, interactivity) is double-buffered, and will be applied at the + * time wl_surface.commit of the corresponding wl_surface is called. + * + * Attaching a null buffer to a layer surface unmaps it. + * + * Unmapping a layer_surface means that the surface cannot be shown by the + * compositor until it is explicitly mapped again. The layer_surface + * returns to the state it had right after layer_shell.get_layer_surface. + * The client can re-map the surface by performing a commit without any + * buffer attached, waiting for a configure event and handling it as usual. + */ +extern const struct wl_interface zwlr_layer_surface_v1_interface; +#endif + +#ifndef ZWLR_LAYER_SHELL_V1_ERROR_ENUM +#define ZWLR_LAYER_SHELL_V1_ERROR_ENUM +enum zwlr_layer_shell_v1_error { + /** + * wl_surface has another role + */ + ZWLR_LAYER_SHELL_V1_ERROR_ROLE = 0, + /** + * layer value is invalid + */ + ZWLR_LAYER_SHELL_V1_ERROR_INVALID_LAYER = 1, + /** + * wl_surface has a buffer attached or committed + */ + ZWLR_LAYER_SHELL_V1_ERROR_ALREADY_CONSTRUCTED = 2, +}; +#endif /* ZWLR_LAYER_SHELL_V1_ERROR_ENUM */ + +#ifndef ZWLR_LAYER_SHELL_V1_LAYER_ENUM +#define ZWLR_LAYER_SHELL_V1_LAYER_ENUM +/** + * @ingroup iface_zwlr_layer_shell_v1 + * available layers for surfaces + * + * These values indicate which layers a surface can be rendered in. They + * are ordered by z depth, bottom-most first. Traditional shell surfaces + * will typically be rendered between the bottom and top layers. + * Fullscreen shell surfaces are typically rendered at the top layer. + * Multiple surfaces can share a single layer, and ordering within a + * single layer is undefined. + */ +enum zwlr_layer_shell_v1_layer { + ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND = 0, + ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM = 1, + ZWLR_LAYER_SHELL_V1_LAYER_TOP = 2, + ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY = 3, +}; +#endif /* ZWLR_LAYER_SHELL_V1_LAYER_ENUM */ + +#define ZWLR_LAYER_SHELL_V1_GET_LAYER_SURFACE 0 +#define ZWLR_LAYER_SHELL_V1_DESTROY 1 + + +/** + * @ingroup iface_zwlr_layer_shell_v1 + */ +#define ZWLR_LAYER_SHELL_V1_GET_LAYER_SURFACE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_shell_v1 + */ +#define ZWLR_LAYER_SHELL_V1_DESTROY_SINCE_VERSION 3 + +/** @ingroup iface_zwlr_layer_shell_v1 */ +static inline void +zwlr_layer_shell_v1_set_user_data(struct zwlr_layer_shell_v1 *zwlr_layer_shell_v1, void *user_data) +{ + wl_proxy_set_user_data((struct wl_proxy *) zwlr_layer_shell_v1, user_data); +} + +/** @ingroup iface_zwlr_layer_shell_v1 */ +static inline void * +zwlr_layer_shell_v1_get_user_data(struct zwlr_layer_shell_v1 *zwlr_layer_shell_v1) +{ + return wl_proxy_get_user_data((struct wl_proxy *) zwlr_layer_shell_v1); +} + +static inline uint32_t +zwlr_layer_shell_v1_get_version(struct zwlr_layer_shell_v1 *zwlr_layer_shell_v1) +{ + return wl_proxy_get_version((struct wl_proxy *) zwlr_layer_shell_v1); +} + +/** + * @ingroup iface_zwlr_layer_shell_v1 + * + * Create a layer surface for an existing surface. This assigns the role of + * layer_surface, or raises a protocol error if another role is already + * assigned. + * + * Creating a layer surface from a wl_surface which has a buffer attached + * or committed is a client error, and any attempts by a client to attach + * or manipulate a buffer prior to the first layer_surface.configure call + * must also be treated as errors. + * + * After creating a layer_surface object and setting it up, the client + * must perform an initial commit without any buffer attached. + * The compositor will reply with a layer_surface.configure event. + * The client must acknowledge it and is then allowed to attach a buffer + * to map the surface. + * + * You may pass NULL for output to allow the compositor to decide which + * output to use. Generally this will be the one that the user most + * recently interacted with. + * + * Clients can specify a namespace that defines the purpose of the layer + * surface. + */ +static inline struct zwlr_layer_surface_v1 * +zwlr_layer_shell_v1_get_layer_surface(struct zwlr_layer_shell_v1 *zwlr_layer_shell_v1, struct wl_surface *surface, struct wl_output *output, uint32_t layer, const char *namespace) +{ + struct wl_proxy *id; + + id = wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_shell_v1, + ZWLR_LAYER_SHELL_V1_GET_LAYER_SURFACE, &zwlr_layer_surface_v1_interface, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_shell_v1), 0, NULL, surface, output, layer, namespace); + + return (struct zwlr_layer_surface_v1 *) id; +} + +/** + * @ingroup iface_zwlr_layer_shell_v1 + * + * This request indicates that the client will not use the layer_shell + * object any more. Objects that have been created through this instance + * are not affected. + */ +static inline void +zwlr_layer_shell_v1_destroy(struct zwlr_layer_shell_v1 *zwlr_layer_shell_v1) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_shell_v1, + ZWLR_LAYER_SHELL_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_shell_v1), WL_MARSHAL_FLAG_DESTROY); +} + +#ifndef ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM +#define ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM +/** + * @ingroup iface_zwlr_layer_surface_v1 + * types of keyboard interaction possible for a layer shell surface + * + * Types of keyboard interaction possible for layer shell surfaces. The + * rationale for this is twofold: (1) some applications are not interested + * in keyboard events and not allowing them to be focused can improve the + * desktop experience; (2) some applications will want to take exclusive + * keyboard focus. + */ +enum zwlr_layer_surface_v1_keyboard_interactivity { + /** + * no keyboard focus is possible + * + * This value indicates that this surface is not interested in + * keyboard events and the compositor should never assign it the + * keyboard focus. + * + * This is the default value, set for newly created layer shell + * surfaces. + * + * This is useful for e.g. desktop widgets that display information + * or only have interaction with non-keyboard input devices. + */ + ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE = 0, + /** + * request exclusive keyboard focus + * + * Request exclusive keyboard focus if this surface is above the + * shell surface layer. + * + * For the top and overlay layers, the seat will always give + * exclusive keyboard focus to the top-most layer which has + * keyboard interactivity set to exclusive. If this layer contains + * multiple surfaces with keyboard interactivity set to exclusive, + * the compositor determines the one receiving keyboard events in + * an implementation- defined manner. In this case, no guarantee is + * made when this surface will receive keyboard focus (if ever). + * + * For the bottom and background layers, the compositor is allowed + * to use normal focus semantics. + * + * This setting is mainly intended for applications that need to + * ensure they receive all keyboard events, such as a lock screen + * or a password prompt. + */ + ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_EXCLUSIVE = 1, + /** + * request regular keyboard focus semantics + * + * This requests the compositor to allow this surface to be + * focused and unfocused by the user in an implementation-defined + * manner. The user should be able to unfocus this surface even + * regardless of the layer it is on. + * + * Typically, the compositor will want to use its normal mechanism + * to manage keyboard focus between layer shell surfaces with this + * setting and regular toplevels on the desktop layer (e.g. click + * to focus). Nevertheless, it is possible for a compositor to + * require a special interaction to focus or unfocus layer shell + * surfaces (e.g. requiring a click even if focus follows the mouse + * normally, or providing a keybinding to switch focus between + * layers). + * + * This setting is mainly intended for desktop shell components + * (e.g. panels) that allow keyboard interaction. Using this option + * can allow implementing a desktop shell that can be fully usable + * without the mouse. + * @since 4 + */ + ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND = 2, +}; +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND_SINCE_VERSION 4 +#endif /* ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ENUM */ + +#ifndef ZWLR_LAYER_SURFACE_V1_ERROR_ENUM +#define ZWLR_LAYER_SURFACE_V1_ERROR_ENUM +enum zwlr_layer_surface_v1_error { + /** + * provided surface state is invalid + */ + ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SURFACE_STATE = 0, + /** + * size is invalid + */ + ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_SIZE = 1, + /** + * anchor bitfield is invalid + */ + ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_ANCHOR = 2, + /** + * keyboard interactivity is invalid + */ + ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_KEYBOARD_INTERACTIVITY = 3, + /** + * exclusive edge is invalid given the surface anchors + */ + ZWLR_LAYER_SURFACE_V1_ERROR_INVALID_EXCLUSIVE_EDGE = 4, +}; +#endif /* ZWLR_LAYER_SURFACE_V1_ERROR_ENUM */ + +#ifndef ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM +#define ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM +enum zwlr_layer_surface_v1_anchor { + /** + * the top edge of the anchor rectangle + */ + ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP = 1, + /** + * the bottom edge of the anchor rectangle + */ + ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM = 2, + /** + * the left edge of the anchor rectangle + */ + ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT = 4, + /** + * the right edge of the anchor rectangle + */ + ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT = 8, +}; +#endif /* ZWLR_LAYER_SURFACE_V1_ANCHOR_ENUM */ + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * @struct zwlr_layer_surface_v1_listener + */ +struct zwlr_layer_surface_v1_listener { + /** + * suggest a surface change + * + * The configure event asks the client to resize its surface. + * + * Clients should arrange their surface for the new states, and + * then send an ack_configure request with the serial sent in this + * configure event at some point before committing the new surface. + * + * The client is free to dismiss all but the last configure event + * it received. + * + * The width and height arguments specify the size of the window in + * surface-local coordinates. + * + * The size is a hint, in the sense that the client is free to + * ignore it if it doesn't resize, pick a smaller size (to satisfy + * aspect ratio or resize in steps of NxM pixels). If the client + * picks a smaller size and is anchored to two opposite anchors + * (e.g. 'top' and 'bottom'), the surface will be centered on this + * axis. + * + * If the width or height arguments are zero, it means the client + * should decide its own window dimension. + */ + void (*configure)(void *data, + struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, + uint32_t serial, + uint32_t width, + uint32_t height); + /** + * surface should be closed + * + * The closed event is sent by the compositor when the surface + * will no longer be shown. The output may have been destroyed or + * the user may have asked for it to be removed. Further changes to + * the surface will be ignored. The client should destroy the + * resource after receiving this event, and create a new surface if + * they so choose. + */ + void (*closed)(void *data, + struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1); +}; + +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +static inline int +zwlr_layer_surface_v1_add_listener(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, + const struct zwlr_layer_surface_v1_listener *listener, void *data) +{ + return wl_proxy_add_listener((struct wl_proxy *) zwlr_layer_surface_v1, + (void (**)(void)) listener, data); +} + +#define ZWLR_LAYER_SURFACE_V1_SET_SIZE 0 +#define ZWLR_LAYER_SURFACE_V1_SET_ANCHOR 1 +#define ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_ZONE 2 +#define ZWLR_LAYER_SURFACE_V1_SET_MARGIN 3 +#define ZWLR_LAYER_SURFACE_V1_SET_KEYBOARD_INTERACTIVITY 4 +#define ZWLR_LAYER_SURFACE_V1_GET_POPUP 5 +#define ZWLR_LAYER_SURFACE_V1_ACK_CONFIGURE 6 +#define ZWLR_LAYER_SURFACE_V1_DESTROY 7 +#define ZWLR_LAYER_SURFACE_V1_SET_LAYER 8 +#define ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_EDGE 9 + +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_CONFIGURE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_CLOSED_SINCE_VERSION 1 + +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_SIZE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_ANCHOR_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_ZONE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_MARGIN_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_KEYBOARD_INTERACTIVITY_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_GET_POPUP_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_ACK_CONFIGURE_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_DESTROY_SINCE_VERSION 1 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_LAYER_SINCE_VERSION 2 +/** + * @ingroup iface_zwlr_layer_surface_v1 + */ +#define ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_EDGE_SINCE_VERSION 5 + +/** @ingroup iface_zwlr_layer_surface_v1 */ +static inline void +zwlr_layer_surface_v1_set_user_data(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, void *user_data) +{ + wl_proxy_set_user_data((struct wl_proxy *) zwlr_layer_surface_v1, user_data); +} + +/** @ingroup iface_zwlr_layer_surface_v1 */ +static inline void * +zwlr_layer_surface_v1_get_user_data(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1) +{ + return wl_proxy_get_user_data((struct wl_proxy *) zwlr_layer_surface_v1); +} + +static inline uint32_t +zwlr_layer_surface_v1_get_version(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1) +{ + return wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * + * Sets the size of the surface in surface-local coordinates. The + * compositor will display the surface centered with respect to its + * anchors. + * + * If you pass 0 for either value, the compositor will assign it and + * inform you of the assignment in the configure event. You must set your + * anchor to opposite edges in the dimensions you omit; not doing so is a + * protocol error. Both values are 0 by default. + * + * Size is double-buffered, see wl_surface.commit. + */ +static inline void +zwlr_layer_surface_v1_set_size(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, uint32_t width, uint32_t height) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1, + ZWLR_LAYER_SURFACE_V1_SET_SIZE, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, width, height); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * + * Requests that the compositor anchor the surface to the specified edges + * and corners. If two orthogonal edges are specified (e.g. 'top' and + * 'left'), then the anchor point will be the intersection of the edges + * (e.g. the top left corner of the output); otherwise the anchor point + * will be centered on that edge, or in the center if none is specified. + * + * Anchor is double-buffered, see wl_surface.commit. + */ +static inline void +zwlr_layer_surface_v1_set_anchor(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, uint32_t anchor) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1, + ZWLR_LAYER_SURFACE_V1_SET_ANCHOR, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, anchor); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * + * Requests that the compositor avoids occluding an area with other + * surfaces. The compositor's use of this information is + * implementation-dependent - do not assume that this region will not + * actually be occluded. + * + * A positive value is only meaningful if the surface is anchored to one + * edge or an edge and both perpendicular edges. If the surface is not + * anchored, anchored to only two perpendicular edges (a corner), anchored + * to only two parallel edges or anchored to all edges, a positive value + * will be treated the same as zero. + * + * A positive zone is the distance from the edge in surface-local + * coordinates to consider exclusive. + * + * Surfaces that do not wish to have an exclusive zone may instead specify + * how they should interact with surfaces that do. If set to zero, the + * surface indicates that it would like to be moved to avoid occluding + * surfaces with a positive exclusive zone. If set to -1, the surface + * indicates that it would not like to be moved to accommodate for other + * surfaces, and the compositor should extend it all the way to the edges + * it is anchored to. + * + * For example, a panel might set its exclusive zone to 10, so that + * maximized shell surfaces are not shown on top of it. A notification + * might set its exclusive zone to 0, so that it is moved to avoid + * occluding the panel, but shell surfaces are shown underneath it. A + * wallpaper or lock screen might set their exclusive zone to -1, so that + * they stretch below or over the panel. + * + * The default value is 0. + * + * Exclusive zone is double-buffered, see wl_surface.commit. + */ +static inline void +zwlr_layer_surface_v1_set_exclusive_zone(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, int32_t zone) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1, + ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_ZONE, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, zone); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * + * Requests that the surface be placed some distance away from the anchor + * point on the output, in surface-local coordinates. Setting this value + * for edges you are not anchored to has no effect. + * + * The exclusive zone includes the margin. + * + * Margin is double-buffered, see wl_surface.commit. + */ +static inline void +zwlr_layer_surface_v1_set_margin(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, int32_t top, int32_t right, int32_t bottom, int32_t left) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1, + ZWLR_LAYER_SURFACE_V1_SET_MARGIN, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, top, right, bottom, left); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * + * Set how keyboard events are delivered to this surface. By default, + * layer shell surfaces do not receive keyboard events; this request can + * be used to change this. + * + * This setting is inherited by child surfaces set by the get_popup + * request. + * + * Layer surfaces receive pointer, touch, and tablet events normally. If + * you do not want to receive them, set the input region on your surface + * to an empty region. + * + * Keyboard interactivity is double-buffered, see wl_surface.commit. + */ +static inline void +zwlr_layer_surface_v1_set_keyboard_interactivity(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, uint32_t keyboard_interactivity) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1, + ZWLR_LAYER_SURFACE_V1_SET_KEYBOARD_INTERACTIVITY, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, keyboard_interactivity); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * + * This assigns an xdg_popup's parent to this layer_surface. This popup + * should have been created via xdg_surface::get_popup with the parent set + * to NULL, and this request must be invoked before committing the popup's + * initial state. + * + * See the documentation of xdg_popup for more details about what an + * xdg_popup is and how it is used. + */ +static inline void +zwlr_layer_surface_v1_get_popup(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, struct xdg_popup *popup) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1, + ZWLR_LAYER_SURFACE_V1_GET_POPUP, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, popup); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * + * When a configure event is received, if a client commits the + * surface in response to the configure event, then the client + * must make an ack_configure request sometime before the commit + * request, passing along the serial of the configure event. + * + * If the client receives multiple configure events before it + * can respond to one, it only has to ack the last configure event. + * + * A client is not required to commit immediately after sending + * an ack_configure request - it may even ack_configure several times + * before its next surface commit. + * + * A client may send multiple ack_configure requests before committing, but + * only the last request sent before a commit indicates which configure + * event the client really is responding to. + */ +static inline void +zwlr_layer_surface_v1_ack_configure(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, uint32_t serial) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1, + ZWLR_LAYER_SURFACE_V1_ACK_CONFIGURE, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, serial); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * + * This request destroys the layer surface. + */ +static inline void +zwlr_layer_surface_v1_destroy(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1, + ZWLR_LAYER_SURFACE_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), WL_MARSHAL_FLAG_DESTROY); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * + * Change the layer that the surface is rendered on. + * + * Layer is double-buffered, see wl_surface.commit. + */ +static inline void +zwlr_layer_surface_v1_set_layer(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, uint32_t layer) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1, + ZWLR_LAYER_SURFACE_V1_SET_LAYER, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, layer); +} + +/** + * @ingroup iface_zwlr_layer_surface_v1 + * + * Requests an edge for the exclusive zone to apply. The exclusive + * edge will be automatically deduced from anchor points when possible, + * but when the surface is anchored to a corner, it will be necessary + * to set it explicitly to disambiguate, as it is not possible to deduce + * which one of the two corner edges should be used. + * + * The edge must be one the surface is anchored to, otherwise the + * invalid_exclusive_edge protocol error will be raised. + */ +static inline void +zwlr_layer_surface_v1_set_exclusive_edge(struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, uint32_t edge) +{ + wl_proxy_marshal_flags((struct wl_proxy *) zwlr_layer_surface_v1, + ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_EDGE, NULL, wl_proxy_get_version((struct wl_proxy *) zwlr_layer_surface_v1), 0, edge); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/Wayland/wlr-layer-shell-client.c b/src/Wayland/wlr-layer-shell-client.c new file mode 100644 index 0000000..169c939 --- /dev/null +++ b/src/Wayland/wlr-layer-shell-client.c @@ -0,0 +1,95 @@ +/* Generated by wayland-scanner 1.23.0 */ + +/* + * Copyright © 2017 Drew DeVault + * + * Permission to use, copy, modify, distribute, and sell this + * software and its documentation for any purpose is hereby granted + * without fee, provided that the above copyright notice appear in + * all copies and that both that copyright notice and this permission + * notice appear in supporting documentation, and that the name of + * the copyright holders not be used in advertising or publicity + * pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied + * warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS + * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, + * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + * THIS SOFTWARE. + */ + +#include +#include +#include +#include "wayland-util.h" + +#ifndef __has_attribute +# define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */ +#endif + +#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4) +#define WL_PRIVATE __attribute__ ((visibility("hidden"))) +#else +#define WL_PRIVATE +#endif + +extern const struct wl_interface wl_output_interface; +extern const struct wl_interface wl_surface_interface; +extern const struct wl_interface xdg_popup_interface; +extern const struct wl_interface zwlr_layer_surface_v1_interface; + +static const struct wl_interface *wlr_layer_shell_unstable_v1_types[] = { + NULL, + NULL, + NULL, + NULL, + &zwlr_layer_surface_v1_interface, + &wl_surface_interface, + &wl_output_interface, + NULL, + NULL, + &xdg_popup_interface, +}; + +static const struct wl_message zwlr_layer_shell_v1_requests[] = { + { "get_layer_surface", "no?ous", wlr_layer_shell_unstable_v1_types + 4 }, + { "destroy", "3", wlr_layer_shell_unstable_v1_types + 0 }, +}; + +WL_PRIVATE const struct wl_interface zwlr_layer_shell_v1_interface = { + "zwlr_layer_shell_v1", 5, + 2, zwlr_layer_shell_v1_requests, + 0, NULL, +}; + +static const struct wl_message zwlr_layer_surface_v1_requests[] = { + { "set_size", "uu", wlr_layer_shell_unstable_v1_types + 0 }, + { "set_anchor", "u", wlr_layer_shell_unstable_v1_types + 0 }, + { "set_exclusive_zone", "i", wlr_layer_shell_unstable_v1_types + 0 }, + { "set_margin", "iiii", wlr_layer_shell_unstable_v1_types + 0 }, + { "set_keyboard_interactivity", "u", wlr_layer_shell_unstable_v1_types + 0 }, + { "get_popup", "o", wlr_layer_shell_unstable_v1_types + 9 }, + { "ack_configure", "u", wlr_layer_shell_unstable_v1_types + 0 }, + { "destroy", "", wlr_layer_shell_unstable_v1_types + 0 }, + { "set_layer", "2u", wlr_layer_shell_unstable_v1_types + 0 }, + { "set_exclusive_edge", "5u", wlr_layer_shell_unstable_v1_types + 0 }, +}; + +static const struct wl_message zwlr_layer_surface_v1_events[] = { + { "configure", "uuu", wlr_layer_shell_unstable_v1_types + 0 }, + { "closed", "", wlr_layer_shell_unstable_v1_types + 0 }, +}; + +WL_PRIVATE const struct wl_interface zwlr_layer_surface_v1_interface = { + "zwlr_layer_surface_v1", 5, + 10, zwlr_layer_surface_v1_requests, + 2, zwlr_layer_surface_v1_events, +}; + diff --git a/src/comp.h b/src/comp.h index f593427..9618cfb 100644 --- a/src/comp.h +++ b/src/comp.h @@ -7,7 +7,7 @@ #ifdef WAYLAND -#include "vulkan.h" +#include "paw_vk.h" #include "wayland.h" typedef struct cat_Wl cat_Comp; diff --git a/src/glfw.c b/src/glfw.c index 1030bb0..126365e 100644 --- a/src/glfw.c +++ b/src/glfw.c @@ -1,5 +1,5 @@ #include "paw_log.h" -#include "vulkan.h" +#include "paw_vk.h" #include #include diff --git a/src/gpu_allocator.c b/src/gpu_allocator.c index 64514e6..b0478d6 100644 --- a/src/gpu_allocator.c +++ b/src/gpu_allocator.c @@ -1,4 +1,4 @@ -#include "vulkan.h" +#include "paw_vk.h" #include #include diff --git a/src/kitty.c b/src/kitty.c index 0360ba5..a91029c 100644 --- a/src/kitty.c +++ b/src/kitty.c @@ -7,7 +7,6 @@ #include "kitty.h" #include "paw_allocator.h" #include "paw_da.h" -#include "vulkan.h" #include "vulkan_helpers.h" struct Kitty *kitty_make(struct PawMem *mem) { diff --git a/src/kitty.h b/src/kitty.h index f88c3c1..af64d01 100644 --- a/src/kitty.h +++ b/src/kitty.h @@ -2,7 +2,7 @@ #define INCLUDE_KITTY #include "image.h" -#include "vulkan.h" +#include "paw_vk.h" #include enum KittyAttatchType { diff --git a/src/lang/ast.h b/src/lang/ast.h index 72ce9a1..5365ea1 100644 --- a/src/lang/ast.h +++ b/src/lang/ast.h @@ -7,7 +7,7 @@ #include "../paw_allocator.h" #include "../paw_da.h" -#include "../paw_object.h" +#include "../paw_scene.h" #define paw_p void * #define paw_sp int diff --git a/src/paw_phys.c b/src/paw_phys.c index f888acc..82179f5 100644 --- a/src/paw_phys.c +++ b/src/paw_phys.c @@ -1,6 +1,7 @@ #include "paw_phys.h" #include "paw_da.h" #include "paw_log.h" +#include "types.h" struct PawPWorld2 *paw_world2_make() { struct PawMem *mem = paw_memmake(2048); @@ -31,6 +32,7 @@ void paw_pbody2_set_layer(struct PawPBody2 *body, uint8_t layer, bool val) { } } +// pos is relative to body->pos but is not rotated void paw_pbody2_apply_impulse(struct PawPBody2 *body, struct Vec2 pos, struct Vec2 force) { paw_da_append(&body->impulse_queue, @@ -50,3 +52,119 @@ void paw_world2d_remove_body(struct PawPWorld2 *world, struct PawPBody2 *body) { } meow("body not found!"); } + +void paw_world2d_apply_velocity(struct PawPWorld2 *world, float delta) { + for (int i = 0; i < world->bodies.count; i++) { + world->bodies.items[i]->lvel.x += + world->bodies.items[i]->const_force.x * delta; + world->bodies.items[i]->lvel.y += + world->bodies.items[i]->const_force.y * delta; + world->bodies.items[i]->pos.x += world->bodies.items[i]->lvel.x * delta; + world->bodies.items[i]->pos.y += world->bodies.items[i]->lvel.y * delta; + world->bodies.items[i]->rot += world->bodies.items[i]->rvel * delta; + } +} + +void paw_world2d_apply_impulses(struct PawPWorld2 *world) { + for (int i = 0; i < world->bodies.count; i++) { + struct PawPBody2 *body = world->bodies.items[i]; + for (int j = 0; j < body->impulse_queue.count; j++) { + struct Vec2 force = body->impulse_queue.items[i].force; + struct Vec2 arm = body->impulse_queue.items[i].pos; + struct Vec2 orthogonal = vec2_sub( + force, vec2_mul(arm, vec2_dot(force, arm) / vec2_dot(arm, arm))); + body->rvel += vec2_len(arm) * vec2_len(orthogonal) / body->inertia; + body->lvel.x += force.x / body->mass; + body->lvel.y += force.y / body->mass; + } + body->impulse_queue.count = 0; + } +} + +bool paw_pbody2_is_colliding(struct PawPWorld2 *world, struct PawPBody2 *body, + struct PawCollisionInfo2 *info) { + struct PawPBody2 *a = body; + for (int i = 0; i < world->bodies.count; i++) { + if (world->bodies.items[i] == body || + (world->bodies.items[i]->layers & body->layers) == 0) { + continue; + } + struct PawPBody2 *b = world->bodies.items[i]; + switch (a->type) { + case PAW_PBODY_RECT: + switch (b->type) { + case PAW_PBODY_RECT:; + struct Vec2 exa = a->shape.rect; + struct Vec2 ac[] = { + vec2_rotate(vec2(-exa.x / 2.0f, -exa.y / 2.0f), a->rot), + vec2_rotate(vec2(exa.x / 2.0f, -exa.y / 2.0f), a->rot), + vec2_rotate(vec2(exa.x / 2.0f, exa.y / 2.0f), a->rot), + vec2_rotate(vec2(-exa.x / 2.0f, exa.y / 2.0f), a->rot), + }; + struct Vec2 exb = b->shape.rect; + struct Vec2 bc[] = { + vec2_rotate(vec2(-exb.x / 2.0f, -exb.y / 2.0f), b->rot), + vec2_rotate(vec2(exb.x / 2.0f, -exb.y / 2.0f), b->rot), + vec2_rotate(vec2(exb.x / 2.0f, exb.y / 2.0f), b->rot), + vec2_rotate(vec2(-exb.x / 2.0f, exb.y / 2.0f), b->rot), + }; + struct Vec2 axis[] = { + vec2_sub(ac[0], ac[2]), + vec2_sub(ac[1], ac[3]), + vec2_sub(bc[0], bc[2]), + vec2_sub(bc[1], bc[3]), + }; + break; + case PAW_PBODY_CIRCLE: + break; + } + case PAW_PBODY_CIRCLE: + switch (b->type) { + case PAW_PBODY_RECT: + break; + case PAW_PBODY_CIRCLE: + if (vec2_len(vec2_sub(a->pos, b->pos)) < + a->shape.circle + b->shape.circle) { + if (info == NULL) { + return true; + } else { + info->res = vec2_mul(vec2_normalize(vec2_sub(a->pos, b->pos)), + a->shape.circle); + info->pos = vec2_add(a->pos, vec2_negate(info->pos)); + info->other = b; + return true; + } + } + break; + } + break; + } + } + return false; +} + +void paw_world2d_tick(struct PawPWorld2 *world, float delta) { + paw_world2d_apply_impulses(world); + paw_world2d_apply_velocity(world, delta); + // yes every collision will be countet twice, i dont care + for (int i = 0; i < world->bodies.count; i++) { + struct PawCollisionInfo2 info = {0}; + if (paw_pbody2_is_colliding(world, world->bodies.items[i], &info)) { + continue; + } + struct PawPBody2 *a = world->bodies.items[i]; + if (info.other->mode != PAW_PBODY_AREA) { + a->collision_callback(info, a->callback_data); + } + paw_pbody2_apply_impulse(a, info.pos, info.res); + if (a->mode == PAW_PBODY_RIGID && info.other->mode == PAW_PBODY_RIGID) { + a->pos.x += info.res.x / 2.0f; + a->pos.y += info.res.y / 2.0f; + } else if (a->mode == PAW_PBODY_RIGID && + info.other->mode == PAW_PBODY_STATIC) { + a->pos.x += info.res.x; + a->pos.y += info.res.y; + } + } + paw_world2d_apply_impulses(world); +} diff --git a/src/paw_phys.h b/src/paw_phys.h index f9953d5..7ee906b 100644 --- a/src/paw_phys.h +++ b/src/paw_phys.h @@ -8,6 +8,12 @@ #include #include +struct PawCollisionInfo2 { + struct Vec2 pos; // global coordinates + struct Vec2 res; // vec to add to a to get it outside of the collision + struct PawPBody2 *other; +}; + struct PawImpulse2 { struct Vec2 pos; struct Vec2 force; @@ -18,16 +24,41 @@ enum PawPBodyType2 { PAW_PBODY_RECT, PAW_PBODY_CIRCLE, }; + +enum PawPBodyMode { + PAW_PBODY_AREA, + PAW_PBODY_RIGID, + PAW_PBODY_STATIC, +}; + struct PawPBody2 { + enum PawPBodyMode mode; enum PawPBodyType2 type; // !! important !! union { - struct Vec2 rect; - float cirle; - }; - uint32_t layers; // use helper func - struct Vec2 pos; // should not be modified - float rot; // should not be modified + struct Vec2 rect; // if |offset| is equal to 0, the body rotates around the + // center + float circle; // if |offset| is equal to 0, the body rotates around the + // center of the circle + } shape; + float mass; // lvel += .... / mass + float inertia; // rvel += .... / inertia + struct Vec2 const_force; // use this for gravity + uint32_t layers; // use helper func + struct Vec2 offset; // the form is offset by this amount, aka whenn creating a + // body -offset is the center of gravity + + struct Vec2 pos; + float rot; + + struct Vec2 lvel; + float rvel; + struct da_PawImpulse2 impulse_queue; + + void *callback_data; + // will be called once for every collision (there can only ever be one + // collision between two unique bodies) + void (*collision_callback)(struct PawCollisionInfo2 info, void *); }; paw_da_define(da_PawPBody2, struct PawPBody2 *); diff --git a/src/paw_reg.c b/src/paw_reg.c new file mode 100644 index 0000000..4f44fd3 --- /dev/null +++ b/src/paw_reg.c @@ -0,0 +1,35 @@ +#include "paw_reg.h" +#include "paw_log.h" +#include "paw_scene.h" + +#include +#include + +struct PawReg *paw_reg_make() { + struct PawReg *reg = malloc(sizeof(struct PawReg)); + paw_da_make_inplace(®->reg); + return reg; +} + +void paw_reg_free(struct PawReg *reg) { + paw_da_free(®->reg); + free(reg); +} + +void paw_reg_attatch_type(struct PawReg *reg, char *name, + void *(*make)(struct PawScene *, char *, int len), + void (*free)(struct PawScene *, void *), + void (*tick)(struct PawScene *, void *)) { + struct PawType type = {name, make, free, tick}; + paw_da_append(®->reg, type); +} + +struct PawType *paw_reg_get_type(struct PawReg *reg, char *name) { + for (int i = 0; i < reg->reg.count; i++) { + if (strcmp(reg->reg.items[i].name, name) == 0) { + return ®->reg.items[i]; + } + } + meow("did not find %s in register", name); + return NULL; +} diff --git a/src/paw_reg.h b/src/paw_reg.h new file mode 100644 index 0000000..0a2d55b --- /dev/null +++ b/src/paw_reg.h @@ -0,0 +1,32 @@ +#ifndef INCLUDE_WAYLANDCLIENT_REGISTER_H_ +#define INCLUDE_WAYLANDCLIENT_REGISTER_H_ + +#include "paw_scene.h" + +struct PawType { + char *name; + + void *(*make)(struct PawScene *, char *, int len); + void (*free)(struct PawScene *, void *); + void (*tick)(struct PawScene *, void *); +}; + +paw_da_define(da_PawType, struct PawType); + +struct PawReg { + struct da_PawType reg; +}; + +#define PAW_OBJ_FREE (void (*)(struct PawScene *, void *)) +#define PAW_OBJ_TICK (void (*)(struct PawScene *, void *)) +#define PAW_OBJ_MAKE (void *(*)(struct PawScene *, char *, int len)) + +struct PawReg *paw_reg_make(); +void paw_reg_free(struct PawReg *reg); +struct PawType *paw_reg_get_type(struct PawReg *reg, char *name); +void paw_reg_attatch_type(struct PawReg *reg, char *name, + void *(*make)(struct PawScene *, char *, int len), + void (*free)(struct PawScene *, void *), + void (*tick)(struct PawScene *, void *)); + +#endif // INCLUDE_WAYLANDCLIENT_REGISTER_H_ diff --git a/src/paw_object.c b/src/paw_scene.c similarity index 89% rename from src/paw_object.c rename to src/paw_scene.c index b9dc899..f363d9a 100644 --- a/src/paw_object.c +++ b/src/paw_scene.c @@ -1,7 +1,7 @@ -#include "paw_object.h" +#include "paw_scene.h" #include "paw_allocator.h" #include "paw_log.h" -#include "register.h" +#include "paw_reg.h" #include #include @@ -9,13 +9,13 @@ #define DT_TARGET 0.016 -struct PawScene *paw_scene_make(struct Vk *vk, struct Register *reg) { +struct PawScene *paw_scene_make(struct Vk *vk, struct PawReg *reg) { struct PawScene *scene = malloc(sizeof(struct PawScene)); memset(scene, 0, sizeof(struct PawScene)); scene->vk = vk; scene->mem = paw_memmake(100000); if (reg == NULL) { - scene->reg = make_register(); + scene->reg = paw_reg_make(); } else { scene->reg = reg; } @@ -92,7 +92,12 @@ void paw_scene_tick(struct PawScene *scene) { void paw_scene_queue_insert(struct PawScene *scene, char *name, void *object_data) { - struct Type *type = reg_get_type(scene->reg, name); + struct PawType *type = paw_reg_get_type(scene->reg, name); + if (type == NULL) { + meow("oopsie could not get type %s", name); + paw_print_backtrace(); + return; + } struct PawObject *object = paw_memmalloc(scene->mem, sizeof(struct PawObject)); object->type = type; @@ -101,7 +106,12 @@ void paw_scene_queue_insert(struct PawScene *scene, char *name, } void paw_scene_queue_insert_from_data(struct PawScene *scene, char *name, char *data, int len) { - struct Type *type = reg_get_type(scene->reg, name); + struct PawType *type = paw_reg_get_type(scene->reg, name); + if (type == NULL) { + meow("oopsie could not get type %s", name); + paw_print_backtrace(); + return; + } struct PawObject *object = paw_memmalloc(scene->mem, sizeof(struct PawObject)); object->type = type; diff --git a/src/paw_object.h b/src/paw_scene.h similarity index 87% rename from src/paw_object.h rename to src/paw_scene.h index fd40109..9efce5d 100644 --- a/src/paw_object.h +++ b/src/paw_scene.h @@ -13,7 +13,7 @@ struct PawScene { struct da_Object objects; struct da_Object insert_queue; struct da_Named named; - struct Register *reg; + struct PawReg *reg; float delta_secs; long avg_delta; @@ -23,7 +23,7 @@ struct PawScene { }; struct PawObject { - struct Type *type; + struct PawType *type; void *data; }; @@ -32,7 +32,8 @@ struct PawNamed { struct PawObject *object; }; -struct PawScene *paw_scene_make(struct Vk *vk, struct Register *reg); +// if reg is NULL, a new register will be made +struct PawScene *paw_scene_make(struct Vk *vk, struct PawReg *reg); void paw_scene_free(struct PawScene *scene); void paw_scene_tick(struct PawScene *scene); void paw_scene_queue_insert(struct PawScene *scene, char *name, diff --git a/src/vulkan.c b/src/paw_vk.c similarity index 99% rename from src/vulkan.c rename to src/paw_vk.c index f7b0b50..c264345 100644 --- a/src/vulkan.c +++ b/src/paw_vk.c @@ -1,4 +1,4 @@ -#include "vulkan.h" +#include "paw_vk.h" #include "kitty.h" #include "types.h" diff --git a/src/vulkan.h b/src/paw_vk.h similarity index 100% rename from src/vulkan.h rename to src/paw_vk.h diff --git a/src/register.c b/src/register.c deleted file mode 100644 index 74486b4..0000000 --- a/src/register.c +++ /dev/null @@ -1,35 +0,0 @@ -#include "register.h" -#include "paw_log.h" -#include "paw_object.h" - -#include -#include - -struct Register *make_register() { - struct Register *reg = malloc(sizeof(struct Register)); - paw_da_make_inplace(®->reg); - return reg; -} - -void free_register(struct Register *reg) { - paw_da_free(®->reg); - free(reg); -} - -void reg_attatch_type(struct Register *reg, char *name, - void *(*make)(struct PawScene *, char *, int len), - void (*free)(struct PawScene *, void *), - void (*tick)(struct PawScene *, void *)) { - struct Type type = {name, make, free, tick}; - paw_da_append(®->reg, type); -} - -struct Type *reg_get_type(struct Register *reg, char *name) { - for (int i = 0; i < reg->reg.count; i++) { - if (strcmp(reg->reg.items[i].name, name) == 0) { - return ®->reg.items[i]; - } - } - meow("did not find %s in register", name); - return NULL; -} diff --git a/src/register.h b/src/register.h deleted file mode 100644 index 5faea0a..0000000 --- a/src/register.h +++ /dev/null @@ -1,32 +0,0 @@ -#ifndef INCLUDE_WAYLANDCLIENT_REGISTER_H_ -#define INCLUDE_WAYLANDCLIENT_REGISTER_H_ - -#include "paw_object.h" - -paw_da_define(da_Type, struct Type); - -struct Type { - char *name; - - void *(*make)(struct PawScene *, char *, int len); - void (*free)(struct PawScene *, void *); - void (*tick)(struct PawScene *, void *); -}; - -struct Register { - struct da_Type reg; -}; - -#define OBJ_FREE (void (*)(struct PawScene *, void *)) -#define OBJ_TICK (void (*)(struct PawScene *, void *)) -#define OBJ_MAKE (void *(*)(struct PawScene *, char *, int len)) - -struct Register *make_register(); -void free_register(struct Register *reg); -struct Type *reg_get_type(struct Register *reg, char *name); -void reg_attatch_type(struct Register *reg, char *name, - void *(*make)(struct PawScene *, char *, int len), - void (*free)(struct PawScene *, void *), - void (*tick)(struct PawScene *, void *)); - -#endif // INCLUDE_WAYLANDCLIENT_REGISTER_H_ diff --git a/src/types.c b/src/types.c index 9857999..7c5f6ef 100644 --- a/src/types.c +++ b/src/types.c @@ -1,7 +1,5 @@ #include "types.h" -#include "math.h" - struct Vec2 vec2_normalize(struct Vec2 v) { float abs = sqrt(v.x * v.x + v.y * v.y); return (struct Vec2){v.x / abs, v.y / abs}; @@ -10,3 +8,8 @@ struct Vec2 vec2_rotate(struct Vec2 v, float alpha) { return (struct Vec2){v.x * cosf(alpha) - v.y * sinf(alpha), v.x * sinf(alpha) + v.y * cosf(alpha)}; } +// v1 onto v2 +struct Vec2 vec2_project(struct Vec2 v1, struct Vec2 v2) { + float n = (v1.x * v2.x + v1.y * v2.y) / (v2.x * v2.x + v2.y * v2.y); + return (struct Vec2){v2.x * n, v2.y * n}; +} diff --git a/src/types.h b/src/types.h index e18215a..04d6205 100644 --- a/src/types.h +++ b/src/types.h @@ -3,6 +3,8 @@ #define PI 3.141592653589793238462643f +#include + struct Vec2 { union { struct { @@ -11,12 +13,20 @@ struct Vec2 { float arr[2]; }; }; +static inline struct Vec2 vec2(float x, float y) { return (struct Vec2){x, y}; } #define vec2_mul(v, n) \ (struct Vec2) { (v).x *(n), (v).y *(n) } #define vec2_add(v1, v2) \ (struct Vec2) { (v1).x + (v2).x, (v1).y + (v2).y } +#define vec2_sub(v1, v2) \ + (struct Vec2) { (v1).x - (v2).x, (v1).y - (v2).y } +#define vec2_dot(v1, v2) ((v1).x * (v2).x + (v1).y * (v2).y) +#define vec2_len(v) (sqrt((v).x * (v).x + (v).y * (v).y)) +#define vec2_negate(v) \ + (struct Vec2) { -(v).x, -(v).y } struct Vec2 vec2_normalize(struct Vec2 v); struct Vec2 vec2_rotate(struct Vec2 v, float alpha); +struct Vec2 vec2_project(struct Vec2 v1, struct Vec2 v2); struct IVec2 { int x, y; diff --git a/src/wayland.c b/src/wayland.c index 03c83fc..d7bfdc1 100644 --- a/src/wayland.c +++ b/src/wayland.c @@ -1,3 +1,4 @@ +#include "Wayland/wlr-layer-shell-client-protocol.h" #include "Wayland/xdg-shell-client-protocol.h" #include @@ -16,18 +17,25 @@ #include "paw_da.h" #include "paw_log.h" -#include "vulkan.h" +#include "paw_vk.h" #include +enum cat_Wl_mode { + CAT_WL_WINDOW, + CAT_WL_LAYER, +}; + struct cat_Wl { struct wl_display *display; struct wl_registry *registry; struct wl_compositor *compositor; struct xdg_wm_base *wm_base; struct wl_seat *seat; + struct zwlr_layer_shell_v1 *layer_shell; struct wl_surface *wl_surface; struct xdg_surface *xdg_surface; + struct zwlr_layer_surface_v1 *layer_surface; struct xdg_toplevel *xdg_toplevel; struct wl_keyboard *keyboard; struct wl_pointer *pointer; @@ -43,6 +51,7 @@ struct cat_Wl { bool should_close; struct Vk *vk; struct Hashmap_ui32 *keys; + enum cat_Wl_mode mode; struct da_uint32_t pressed; struct da_uint32_t released; @@ -213,6 +222,9 @@ static void registry_global(void *data, struct wl_registry *registry, } else if (strcmp(interface, wl_seat_interface.name) == 0) { state->seat = wl_registry_bind(registry, name, &wl_seat_interface, 8); wl_seat_add_listener(state->seat, &seat_listener, state); + } else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) { + state->layer_shell = + wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, 5); } meow("interface %s: version %d", interface, version); } @@ -227,6 +239,27 @@ static const struct wl_registry_listener registry_listener = { .global_remove = registry_global_remove, }; +void layer_surface_configure( + void *data, struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1, + uint32_t serial, uint32_t width, uint32_t height) { + meow("surface configured :0"); + struct cat_Wl *state = data; + zwlr_layer_surface_v1_ack_configure(state->layer_surface, serial); + if (state->resize_coming) { + state->resize_ready = true; + } +} + +void layer_surface_closed(void *data, + struct zwlr_layer_surface_v1 *zwlr_layer_surface_v1) { + meow("surface closed :0"); +} + +static const struct zwlr_layer_surface_v1_listener layer_surface_listener = { + .configure = layer_surface_configure, + .closed = layer_surface_closed, +}; + VkSurfaceKHR create_wayland_surface(void *data, VkInstance instance) { struct cat_Wl *state = data; VkSurfaceKHR surface; @@ -242,6 +275,7 @@ struct cat_Wl *cat_init_wl(const char *name, int width, int heigh, struct Vk **vk) { struct cat_Wl *state = malloc(sizeof(struct cat_Wl)); memset(state, 0, sizeof(struct cat_Wl)); + state->mode = CAT_WL_WINDOW; state->keys = create_hashmap_ui32(); paw_da_make_inplace(&state->pressed); paw_da_make_inplace(&state->released); @@ -278,6 +312,62 @@ struct cat_Wl *cat_init_wl(const char *name, int width, int heigh, return state; } +struct cat_Wl *cat_init_wl_layer(const char *name, struct Vk **vk) { + struct cat_Wl *state = malloc(sizeof(struct cat_Wl)); + memset(state, 0, sizeof(struct cat_Wl)); + state->mode = CAT_WL_WINDOW; + state->keys = create_hashmap_ui32(); + paw_da_make_inplace(&state->pressed); + paw_da_make_inplace(&state->released); + + state->should_close = state->resize_ready = state->resize_coming = false; + + state->width = 1280; + state->heigh = 800; + + state->xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS); + + state->display = wl_display_connect(NULL); + + state->registry = wl_display_get_registry(state->display); + wl_registry_add_listener(state->registry, ®istry_listener, state); + wl_display_roundtrip(state->display); + + state->wl_surface = wl_compositor_create_surface(state->compositor); + + state->layer_surface = zwlr_layer_shell_v1_get_layer_surface( + state->layer_shell, state->wl_surface, NULL, + ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "wlroots"); + zwlr_layer_surface_v1_add_listener(state->layer_surface, + &layer_surface_listener, state); + zwlr_layer_surface_v1_set_size(state->layer_surface, state->width, + state->heigh); + zwlr_layer_surface_v1_set_margin(state->layer_surface, 0, 0, 0, 0); + zwlr_layer_surface_v1_set_keyboard_interactivity( + state->layer_surface, ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_NONE); + zwlr_layer_surface_v1_set_anchor(state->layer_surface, 0); + + /* state->xdg_surface = */ + /* xdg_wm_base_get_xdg_surface(state->wm_base, state->wl_surface); */ + /* xdg_surface_add_listener(state->xdg_surface, &xdg_surface_listener, state); + */ + /* state->xdg_toplevel = xdg_surface_get_toplevel(state->xdg_surface); */ + /* xdg_toplevel_add_listener(state->xdg_toplevel, &toplevel_listener, state); + */ + /**/ + /* xdg_toplevel_set_title(state->xdg_toplevel, name); */ + /* xdg_toplevel_set_app_id(state->xdg_toplevel, name); */ + + wl_surface_commit(state->wl_surface); + wl_display_roundtrip(state->display); + wl_surface_commit(state->wl_surface); + + state->vk = + init_vk(state, state->width, state->heigh, create_wayland_surface); + *vk = state->vk; + return state; +} + void cat_wl_draw(struct cat_Wl *state) { paw_da_reset(&state->pressed); paw_da_reset(&state->released); @@ -328,6 +418,10 @@ void cat_uninit_wl(struct cat_Wl *state) { xdg_surface_destroy(state->xdg_surface); wl_surface_destroy(state->wl_surface); + if (state->layer_shell != NULL) { + zwlr_layer_shell_v1_destroy(state->layer_shell); + } + xdg_wm_base_destroy(state->wm_base); wl_compositor_destroy(state->compositor); wl_registry_destroy(state->registry); diff --git a/src/wayland.h b/src/wayland.h index c0dca01..1e362e2 100644 --- a/src/wayland.h +++ b/src/wayland.h @@ -1,10 +1,13 @@ #ifndef INCLUDE_WAYLANDCLIENT_CAT_WAYLAND_H_ #define INCLUDE_WAYLANDCLIENT_CAT_WAYLAND_H_ +#include "paw_vk.h" #include #include struct cat_Wl; + +struct cat_Wl *cat_init_wl_layer(const char *name, struct Vk **vk); struct cat_Wl *cat_init_wl(const char *name, int width, int heigh, struct Vk **vk); void cat_wl_draw(struct cat_Wl *state); diff --git a/trig.c b/trig.c index 00b2f50..151a867 100644 --- a/trig.c +++ b/trig.c @@ -2,7 +2,7 @@ #include "src/matrix.h" #include "src/paw_allocator.h" #include "src/paw_log.h" -#include "src/paw_object.h" +#include "src/paw_scene.h" #include "src/types.h" #include "src/util.h" @@ -47,7 +47,7 @@ struct Trig *trig_make_args(struct PawScene *scene) { kitty_attatch_ubo(trig->kitty, sizeof(struct TrigUBO)); kitty_attatch_ubo(trig->kitty, sizeof(struct mat3x3) * INSTANCE_COUNT); - kitty_attatch_image(trig->kitty, "./res/neocat.png"); + kitty_attatch_image(trig->kitty, "./res/images/neocat.png"); uint32_t instance_buffer[INSTANCE_COUNT] = {0}; for (int i = 0; i < INSTANCE_COUNT; i++) {