aboutsummaryrefslogtreecommitdiff
path: root/include/render
diff options
context:
space:
mode:
Diffstat (limited to 'include/render')
-rw-r--r--include/render/vulkan.h312
1 files changed, 312 insertions, 0 deletions
diff --git a/include/render/vulkan.h b/include/render/vulkan.h
new file mode 100644
index 00000000..aa40198c
--- /dev/null
+++ b/include/render/vulkan.h
@@ -0,0 +1,312 @@
+#ifndef RENDER_VULKAN_H
+#define RENDER_VULKAN_H
+
+#include <stdint.h>
+#include <string.h>
+#include <stdbool.h>
+#include <vulkan/vulkan.h>
+#include <wlr/render/wlr_renderer.h>
+#include <wlr/render/wlr_texture.h>
+#include <wlr/render/drm_format_set.h>
+#include <wlr/render/interface.h>
+
+struct wlr_vk_descriptor_pool;
+
+// Central vulkan state that should only be needed once per compositor.
+struct wlr_vk_instance {
+ VkInstance instance;
+ VkDebugUtilsMessengerEXT messenger;
+
+ // enabled extensions
+ size_t extension_count;
+ const char **extensions;
+
+ struct {
+ PFN_vkCreateDebugUtilsMessengerEXT createDebugUtilsMessengerEXT;
+ PFN_vkDestroyDebugUtilsMessengerEXT destroyDebugUtilsMessengerEXT;
+ } api;
+};
+
+// Creates and initializes a vulkan instance.
+// Will try to enable the given extensions but not fail if they are not
+// available which can later be checked by the caller.
+// The debug parameter determines if validation layers are enabled and a
+// debug messenger created.
+// `compositor_name` and `compositor_version` are passed to the vulkan driver.
+struct wlr_vk_instance *vulkan_instance_create(size_t ext_count,
+ const char **exts, bool debug);
+void vulkan_instance_destroy(struct wlr_vk_instance *ini);
+
+// Logical vulkan device state.
+// Ownership can be shared by multiple renderers, reference counted
+// with `renderers`.
+struct wlr_vk_device {
+ struct wlr_vk_instance *instance;
+
+ VkPhysicalDevice phdev;
+ VkDevice dev;
+
+ int drm_fd;
+
+ // enabled extensions
+ size_t extension_count;
+ const char **extensions;
+
+ // we only ever need one queue for rendering and transfer commands
+ uint32_t queue_family;
+ VkQueue queue;
+
+ struct {
+ PFN_vkGetMemoryFdPropertiesKHR getMemoryFdPropertiesKHR;
+ } api;
+
+ uint32_t format_prop_count;
+ struct wlr_vk_format_props *format_props;
+ struct wlr_drm_format_set dmabuf_render_formats;
+ struct wlr_drm_format_set dmabuf_texture_formats;
+
+ // supported formats for textures (contains only those formats
+ // that support everything we need for textures)
+ uint32_t shm_format_count;
+ uint32_t *shm_formats; // to implement vulkan_get_shm_texture_formats
+};
+
+// Tries to find the VkPhysicalDevice for the given drm fd.
+// Might find none and return VK_NULL_HANDLE.
+VkPhysicalDevice vulkan_find_drm_phdev(struct wlr_vk_instance *ini, int drm_fd);
+
+// Creates a device for the given instance and physical device.
+// Will try to enable the given extensions but not fail if they are not
+// available which can later be checked by the caller.
+struct wlr_vk_device *vulkan_device_create(struct wlr_vk_instance *ini,
+ VkPhysicalDevice phdev, size_t ext_count, const char **exts);
+void vulkan_device_destroy(struct wlr_vk_device *dev);
+
+// Tries to find any memory bit for the given vulkan device that
+// supports the given flags and is set in req_bits (e.g. if memory
+// type 2 is ok, (req_bits & (1 << 2)) must not be 0.
+// Set req_bits to 0xFFFFFFFF to allow all types.
+int vulkan_find_mem_type(struct wlr_vk_device *device,
+ VkMemoryPropertyFlags flags, uint32_t req_bits);
+
+struct wlr_vk_format {
+ uint32_t drm_format;
+ VkFormat vk_format;
+};
+
+// Returns all known format mappings.
+// Might not be supported for gpu/usecase.
+const struct wlr_vk_format *vulkan_get_format_list(size_t *len);
+const struct wlr_vk_format *vulkan_get_format_from_drm(uint32_t drm_format);
+
+struct wlr_vk_format_modifier_props {
+ VkDrmFormatModifierPropertiesEXT props;
+ VkExternalMemoryFeatureFlags dmabuf_flags;
+ VkExtent2D max_extent;
+ bool export_imported;
+};
+
+struct wlr_vk_format_props {
+ struct wlr_vk_format format;
+ VkExtent2D max_extent; // relevant if not created as dma_buf
+ VkFormatFeatureFlags features; // relevant if not created as dma_buf
+
+ uint32_t render_mod_count;
+ struct wlr_vk_format_modifier_props *render_mods;
+
+ uint32_t texture_mod_count;
+ struct wlr_vk_format_modifier_props *texture_mods;
+};
+
+void vulkan_format_props_query(struct wlr_vk_device *dev,
+ const struct wlr_vk_format *format);
+struct wlr_vk_format_modifier_props *vulkan_format_props_find_modifier(
+ struct wlr_vk_format_props *props, uint64_t mod, bool render);
+void vulkan_format_props_finish(struct wlr_vk_format_props *props);
+
+// For each format we want to render, we need a separate renderpass
+// and therefore also separate pipelines.
+struct wlr_vk_render_format_setup {
+ struct wl_list link;
+ VkFormat render_format; // used in renderpass
+ VkRenderPass render_pass;
+
+ VkPipeline tex_pipe;
+ VkPipeline quad_pipe;
+};
+
+// Renderer-internal represenation of an wlr_buffer imported for rendering.
+struct wlr_vk_render_buffer {
+ struct wlr_buffer *wlr_buffer;
+ struct wlr_vk_renderer *renderer;
+ struct wlr_vk_render_format_setup *render_setup;
+ struct wl_list link; // wlr_vk_renderer.buffers
+
+ VkImage image;
+ VkImageView image_view;
+ VkFramebuffer framebuffer;
+ uint32_t mem_count;
+ VkDeviceMemory memories[WLR_DMABUF_MAX_PLANES];
+ bool transitioned;
+
+ struct wl_listener buffer_destroy;
+};
+
+// Vulkan wlr_renderer implementation on top of a wlr_vk_device.
+struct wlr_vk_renderer {
+ struct wlr_renderer wlr_renderer;
+ struct wlr_backend *backend;
+ struct wlr_vk_device *dev;
+
+ VkCommandPool command_pool;
+
+ VkShaderModule vert_module;
+ VkShaderModule tex_frag_module;
+ VkShaderModule quad_frag_module;
+
+ VkDescriptorSetLayout ds_layout;
+ VkPipelineLayout pipe_layout;
+ VkSampler sampler;
+
+ VkFence fence;
+
+ struct wlr_vk_render_buffer *current_render_buffer;
+
+ // current frame id. Used in wlr_vk_texture.last_used
+ // Increased every time a frame is ended for the renderer
+ uint32_t frame;
+ VkRect2D scissor; // needed for clearing
+
+ VkCommandBuffer cb;
+ VkPipeline bound_pipe;
+
+ uint32_t render_width;
+ uint32_t render_height;
+ float projection[9];
+
+ size_t last_pool_size;
+ struct wl_list descriptor_pools; // type wlr_vk_descriptor_pool
+ struct wl_list render_format_setups;
+
+ struct wl_list textures; // wlr_gles2_texture.link
+ struct wl_list destroy_textures; // wlr_vk_texture to destroy after frame
+ struct wl_list foreign_textures; // wlr_vk_texture to return to foreign queue
+
+ struct wl_list render_buffers; // wlr_vk_render_buffer
+
+ struct {
+ VkCommandBuffer cb;
+ bool recording;
+ struct wl_list buffers; // type wlr_vk_shared_buffer
+ } stage;
+};
+
+// Creates a vulkan renderer for the given device.
+struct wlr_renderer *vulkan_renderer_create_for_device(struct wlr_vk_device *dev);
+
+// stage utility - for uploading/retrieving data
+// Gets an command buffer in recording state which is guaranteed to be
+// executed before the next frame.
+VkCommandBuffer vulkan_record_stage_cb(struct wlr_vk_renderer *renderer);
+
+// Submits the current stage command buffer and waits until it has
+// finished execution.
+bool vulkan_submit_stage_wait(struct wlr_vk_renderer *renderer);
+
+// Suballocates a buffer span with the given size that can be mapped
+// and used as staging buffer. The allocation is implicitly released when the
+// stage cb has finished execution.
+struct wlr_vk_buffer_span vulkan_get_stage_span(
+ struct wlr_vk_renderer *renderer, VkDeviceSize size);
+
+// Tries to allocate a texture descriptor set. Will additionally
+// return the pool it was allocated from when successful (for freeing it later).
+struct wlr_vk_descriptor_pool *vulkan_alloc_texture_ds(
+ struct wlr_vk_renderer *renderer, VkDescriptorSet *ds);
+
+// Frees the given descriptor set from the pool its pool.
+void vulkan_free_ds(struct wlr_vk_renderer *renderer,
+ struct wlr_vk_descriptor_pool *pool, VkDescriptorSet ds);
+struct wlr_vk_format_props *vulkan_format_props_from_drm(
+ struct wlr_vk_device *dev, uint32_t drm_format);
+struct wlr_vk_renderer *vulkan_get_renderer(struct wlr_renderer *r);
+
+// State (e.g. image texture) associated with a surface.
+struct wlr_vk_texture {
+ struct wlr_texture wlr_texture;
+ struct wlr_vk_renderer *renderer;
+ uint32_t mem_count;
+ VkDeviceMemory memories[WLR_DMABUF_MAX_PLANES];
+ VkImage image;
+ VkImageView image_view;
+ const struct wlr_vk_format *format;
+ VkDescriptorSet ds;
+ struct wlr_vk_descriptor_pool *ds_pool;
+ uint32_t last_used; // to track when it can be destroyed
+ bool dmabuf_imported;
+ bool owned; // if dmabuf_imported: whether we have ownership of the image
+ bool transitioned; // if dma_imported: whether we transitioned it away from preinit
+ bool invert_y; // if dma_imported: whether we must flip y
+ struct wl_list foreign_link;
+ struct wl_list destroy_link;
+ struct wl_list link; // wlr_gles2_renderer.textures
+
+ // If imported from a wlr_buffer
+ struct wlr_buffer *buffer;
+ struct wl_listener buffer_destroy;
+};
+
+struct wlr_vk_texture *vulkan_get_texture(struct wlr_texture *wlr_texture);
+VkImage vulkan_import_dmabuf(struct wlr_vk_renderer *renderer,
+ const struct wlr_dmabuf_attributes *attribs,
+ VkDeviceMemory mems[static WLR_DMABUF_MAX_PLANES], uint32_t *n_mems,
+ bool for_render);
+struct wlr_texture *vulkan_texture_from_buffer(
+ struct wlr_renderer *wlr_renderer, struct wlr_buffer *buffer);
+void vulkan_texture_destroy(struct wlr_vk_texture *texture);
+
+struct wlr_vk_descriptor_pool {
+ VkDescriptorPool pool;
+ uint32_t free; // number of textures that can be allocated
+ struct wl_list link;
+};
+
+struct wlr_vk_allocation {
+ VkDeviceSize start;
+ VkDeviceSize size;
+};
+
+// List of suballocated staging buffers.
+// Used to upload to/read from device local images.
+struct wlr_vk_shared_buffer {
+ struct wl_list link;
+ VkBuffer buffer;
+ VkDeviceMemory memory;
+ VkDeviceSize buf_size;
+
+ size_t allocs_size;
+ size_t allocs_capacity;
+ struct wlr_vk_allocation *allocs;
+};
+
+// Suballocated range on a buffer.
+struct wlr_vk_buffer_span {
+ struct wlr_vk_shared_buffer *buffer;
+ struct wlr_vk_allocation alloc;
+};
+
+// util
+bool vulkan_has_extension(size_t count, const char **exts, const char *find);
+const char *vulkan_strerror(VkResult err);
+void vulkan_change_layout(VkCommandBuffer cb, VkImage img,
+ VkImageLayout ol, VkPipelineStageFlags srcs, VkAccessFlags srca,
+ VkImageLayout nl, VkPipelineStageFlags dsts, VkAccessFlags dsta);
+void vulkan_change_layout_queue(VkCommandBuffer cb, VkImage img,
+ VkImageLayout ol, VkPipelineStageFlags srcs, VkAccessFlags srca,
+ VkImageLayout nl, VkPipelineStageFlags dsts, VkAccessFlags dsta,
+ uint32_t src_family, uint32_t dst_family);
+
+#define wlr_vk_error(fmt, res, ...) wlr_log(WLR_ERROR, fmt ": %s (%d)", \
+ vulkan_strerror(res), res, ##__VA_ARGS__)
+
+#endif // RENDER_VULKAN_H