tmp wobbly

Author: ammen99

plugins/wobbly/wobbly.cpp

@@ -1,6 +1,7 @@
 #include "wayfire/debug.hpp"
 #include "wayfire/opengl.hpp"
 #include "wayfire/region.hpp"
+#include "wayfire/vulkan.hpp"
 #include <memory>
 #include <wayfire/plugin.hpp>
 #include <wayfire/signal-definitions.hpp>
@@ -10,6 +11,9 @@
 #include <wayfire/render-manager.hpp>
 #include <wayfire/plugins/common/util.hpp>
 
+#include "shaders/wobbly.vert.h"
+#include "shaders/wobbly.frag.h"
+
 extern "C"
 {
 #include "wobbly.h"
@@ -599,6 +603,7 @@ class wobbly_transformer_node_t : public wf::scene::transformer_base_node_t
     }
 
     OpenGL::program_t *wobbly_program;
+    std::array<std::shared_ptr<wf::vk::gpu_buffer_t>, 4> vulkan_vertex_buffer;
 
   private:
     wayfire_toplevel_view view;
@@ -884,24 +889,147 @@ class wobbly_render_instance_t :
         damage |= self->get_bounding_box();
     }
 
+    class vulkan_state_t : public wf::custom_data_t
+    {
+      public:
+        std::shared_ptr<wf::vk::graphics_pipeline_t> pipeline;
+    };
+
+    vulkan_state_t& ensure_vk(wf::vulkan_render_state_t& state)
+    {
+        if (auto data = state.get_data<vulkan_state_t>())
+        {
+            return *data;
+        }
+
+        auto vs = state.get_context()->load_shader_module(wobbly_vert_data, sizeof(wobbly_vert_data));
+        auto fs = state.get_context()->load_shader_module(wobbly_frag_data, sizeof(wobbly_frag_data));
+
+        wf::vk::pipeline_params_t params{};
+        params.shaders = {
+            {.stage = VK_SHADER_STAGE_VERTEX_BIT, .shader = vs},
+            {.stage = VK_SHADER_STAGE_FRAGMENT_BIT, .shader = fs},
+        };
+
+        params.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+        params.vertexInputDescription = {{
+            .binding = 0,
+            .stride = sizeof(float) * 4,
+            .inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
+        }};
+        params.vertexAttributeDescription = {
+            {
+                .location = 0,
+                .binding  = 0,
+                .format   = VK_FORMAT_R32G32_SFLOAT,
+                .offset   = 0,
+            },
+            {
+                .location = 1,
+                .binding  = 0,
+                .format   = VK_FORMAT_R32G32_SFLOAT,
+                .offset   = sizeof(float) * 2,
+            },
+        };
+
+        // One descriptor set for the uv texture.
+        params.descriptorSetLayouts = {state.get_context()->get_image_descriptor_set_layout()};
+        params.pushConstants = {
+            VkPushConstantRange{
+                .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
+                .offset     = 0,
+                .size = sizeof(glm::mat4),
+            },
+        };
+
+        auto data = std::make_unique<vulkan_state_t>();
+        data->pipeline = std::make_shared<wf::vk::graphics_pipeline_t>(state.get_context(), params);
+        auto ptr = data.get();
+        state.store_data<vulkan_state_t>(std::move(data));
+        return *ptr;
+    }
+
+    std::shared_ptr<wf::vk::gpu_buffer_t> find_buffer(
+        std::shared_ptr<wf::vk::context_t> ctx, VkDeviceSize total_size)
+    {
+        auto& buffers = self->vulkan_vertex_buffer;
+        for (size_t i = 0; i < buffers.size(); i++)
+        {
+            auto& buffer = buffers[i];
+            // Try to reuse the vertex buffer if possible, to avoid reallocations.
+            if (buffer && (buffer->get_size() >= total_size) && (buffer.use_count() == 1))
+            {
+                //LOGI("Reuse buffer index ", i);
+                return buffers[i];
+            }
+        }
+
+        buffers[0] = ctx->create_buffer(total_size,
+            VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
+        return buffers[0];
+    }
+
     void render(const wf::scene::render_instruction_t& data) override
     {
         std::vector<float> vert, uv;
         auto subbox = self->get_children_bounding_box();
         wobbly_graphics::prepare_geometry(self->model.get(), subbox, vert, uv);
+        const int count_triangles = self->model->x_cells * self->model->y_cells * 2;
 
-        auto tex = wf::gles_texture_t{get_texture(data.target.scale)};
         data.pass->custom_gles_subpass(data.target, [&]
         {
+            auto tex = wf::gles_texture_t{this->get_texture(data.target.scale)};
+            wf::gles::bind_render_buffer(data.target);
             for (auto box : data.damage)
             {
                 wf::gles::render_target_logic_scissor(data.target, wlr_box_from_pixman_box(box));
                 wobbly_graphics::render_triangles(self->wobbly_program, tex,
                     wf::gles::render_target_orthographic_projection(data.target),
-                    vert.data(), uv.data(),
-                    self->model->x_cells * self->model->y_cells * 2);
+                    vert.data(), uv.data(), count_triangles);
             }
         });
+
+        data.pass->custom_vulkan_subpass([&] (wf::vulkan_render_state_t& state,
+                wf::vk::command_buffer_t& cmd_buf)
+        {
+            auto& our_state = ensure_vk(state);
+
+            std::vector<float> unified_buffer;
+            for (size_t i = 0; i < vert.size() / 2; i++)
+            {
+                unified_buffer.push_back(vert[2 * i]);
+                unified_buffer.push_back(vert[2 * i + 1]);
+                unified_buffer.push_back(uv[2 * i]);
+                unified_buffer.push_back(uv[2 * i + 1]);
+            }
+            VkDeviceSize total_size = unified_buffer.size() * sizeof(float);
+
+            auto buffer = find_buffer(state.get_context(), total_size);
+            buffer->write(unified_buffer.data(), total_size);
+
+            auto tex = state.get_descriptor_pool()->get_descriptor_set(cmd_buf,
+                get_texture(data.target.scale));
+
+            cmd_buf.bind_pipeline(our_state.pipeline, data.target);
+            cmd_buf.set_full_viewport(data.target);
+
+            vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, our_state.pipeline->layout(),
+                0, 1, &tex, 0, nullptr);
+
+            auto transform = wf::vk::render_target_transform(data.target);
+            vkCmdPushConstants(cmd_buf, our_state.pipeline->layout(), VK_SHADER_STAGE_VERTEX_BIT,
+                0, sizeof(glm::mat4), &transform);
+
+
+            cmd_buf.bind_buffer(buffer);
+            VkDeviceSize offset = 0;
+            vkCmdBindVertexBuffers(cmd_buf, 0, 1, &buffer->get_buffer(), &offset);
+
+            cmd_buf.for_each_scissor_rect(data.target, (data.damage & data.target.geometry), [&]
+            {
+                vkCmdDraw(cmd_buf, count_triangles * 3, 1, 0, 0);
+            });
+        });
     }
 };
 
@@ -923,14 +1051,6 @@ class wayfire_wobbly : public wf::plugin_interface_t
   public:
     void init() override
     {
-        if (!wf::get_core().is_gles2())
-        {
-            const char *render_type =
-                wf::get_core().is_vulkan() ? "vulkan" : (wf::get_core().is_pixman() ? "pixman" : "unknown");
-            LOGE("wobbly: requires GLES2 support, but current renderer is ", render_type);
-            return;
-        }
-
         wf::get_core().connect(&wobbly_changed);
         wf::gles::run_in_context_if_gles([&]
         {

shaders/meson.build

@@ -2,6 +2,8 @@
 shaders = [
   'core-basic.vert',
   'core-basic.frag',
+  'wobbly.vert',
+  'wobbly.frag',
 ]
 
 glslang = find_program('glslang', 'glslangValidator', native: true, required: true)

shaders/wobbly.frag

@@ -0,0 +1,27 @@
+#version 450
+
+layout(location = 0) out vec4 out_color;
+
+layout(set = 0, binding = 0) uniform sampler2D tex;
+layout(set = 0, binding = 1, column_major) uniform UVT {
+    mat3 uv_transform;
+} uvt;
+
+layout(location = 0) in vec2 uv;
+
+float srgb_channel_to_linear(float x) {
+	return mix(x / 12.92,
+		pow((x + 0.055) / 1.055, 2.4),
+		x > 0.04045);
+}
+
+
+void main() {
+    vec4 r = texture(tex, (uvt.uv_transform * vec3(uv, 1.0)).xy);
+    r = vec4(srgb_channel_to_linear(r.r),
+                srgb_channel_to_linear(r.g),
+                srgb_channel_to_linear(r.b),
+                r.a);
+    //r = pow(r, vec4(2.2));
+    out_color = r;
+}

shaders/wobbly.vert

@@ -0,0 +1,15 @@
+#version 450
+
+layout(push_constant, column_major) uniform UBO {
+	mat4 mvp;
+} data;
+
+layout(location = 0) out vec2 uv;
+
+layout(location = 0) in vec2 pos;
+layout(location = 1) in vec2 uv_in;
+
+void main() {
+	gl_Position = data.mvp * vec4(pos, 0.0, 1.0);
+	uv = uv_in;
+}

src/api/wayfire/nonstd/wlroots-full.hpp

@@ -48,6 +48,8 @@ extern "C"
 #undef static
 #include <wlr/types/wlr_buffer.h>
 #include <wlr/types/wlr_viewporter.h>
+#include <wlr/types/wlr_color_management_v1.h>
+#include <wlr/types/wlr_color_representation_v1.h>
 
 #include <wlr/types/wlr_damage_ring.h>
 #include <wlr/types/wlr_presentation_time.h>

src/api/wayfire/render.hpp

@@ -24,6 +24,20 @@ namespace vk
 class command_buffer_t;
 }
 
+/**
+ * A struct which describes the color space of a given texture.
+ */
+struct color_transform_t
+{
+    wlr_color_transfer_function transfer_function = WLR_COLOR_TRANSFER_FUNCTION_EXT_LINEAR;
+    wlr_color_named_primaries primaries = WLR_COLOR_NAMED_PRIMARIES_SRGB;
+	wlr_color_encoding color_encoding = WLR_COLOR_ENCODING_NONE;
+	wlr_color_range color_range = WLR_COLOR_RANGE_NONE;
+
+    bool operator ==(const color_transform_t& other) const;
+    bool operator !=(const color_transform_t& other) const;
+};
+
 /**
  * A wrapper around wlr_texture which ensures that the texture is kept alive as long as the wrapper object
  * is alive.
@@ -51,6 +65,10 @@ class texture_t : public wf::signal::provider_t
     std::optional<wlr_scale_filter_mode> get_filter_mode() const;
     void set_filter_mode(const std::optional<wlr_scale_filter_mode>& mode);
 
+    // Getters and setters for color_transform
+    std::optional<color_transform_t> get_color_transform() const;
+    void set_color_transform(const std::optional<color_transform_t>& ct);
+
     /**
      * Manage an existing wlr_texture created from a wlr_buffer.
      * We keep the texture alive by keeping the associated buffer alive.
@@ -96,6 +114,7 @@ class texture_t : public wf::signal::provider_t
     std::optional<wlr_fbox> source_box = {};
     wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
     std::optional<wlr_scale_filter_mode> filter_mode = {};
+    std::optional<color_transform_t> color_transform = {};
 };
 
 /**

src/api/wayfire/unstable/wlr-surface-node.hpp

@@ -22,6 +22,7 @@ struct surface_state_t
     wf::dimensions_t size = {0, 0};
     std::optional<wlr_fbox> src_viewport;
     wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
+    std::optional<wf::color_transform_t> color_transform;
 
     // Sequence number of the last commit read from a wlr_surface state
     std::optional<uint32_t> seq{};
@@ -66,7 +67,7 @@ class wlr_surface_node_t : public node_t, public zero_copy_texturable_node_t
     void gen_render_instances(std::vector<render_instance_uptr>& instances, damage_callback damage,
         wf::output_t *output) override;
     wf::geometry_t get_bounding_box() override;
-    std::optional<std::shared_ptr<wf::texture_t>> to_texture() const override;
+    std::shared_ptr<wf::texture_t> to_texture() const override;
 
     wlr_surface *get_surface() const;
     void apply_state(surface_state_t&& state);

src/api/wayfire/view-transform.hpp

@@ -22,9 +22,9 @@ class zero_copy_texturable_node_t
      * Get a texture from the node without copying.
      * Note that this operation might fail for non-trivial transformers.
      */
-    virtual std::optional<std::shared_ptr<wf::texture_t>> to_texture() const
+    virtual std::shared_ptr<wf::texture_t> to_texture() const
     {
-        return {};
+        return nullptr;
     }
 };
 
@@ -88,18 +88,22 @@ template<class NodeType>
 class transformer_render_instance_t : public render_instance_t
 {
   protected:
-    std::optional<std::shared_ptr<wf::texture_t>> zero_copy_texture()
+    std::shared_ptr<wf::texture_t> zero_copy_texture()
     {
         if (self->get_children().size() == 1)
         {
             auto child = self->get_children().front().get();
             if (auto zcopy = dynamic_cast<zero_copy_texturable_node_t*>(child))
             {
-                return zcopy->to_texture();
+                auto tex = zcopy->to_texture();
+                if (tex && !tex->get_color_transform())
+                {
+                    return tex;
+                }
             }
         }
 
-        return {};
+        return nullptr;
     }
 
     // A pointer to the transformer node this render instance belongs to.
@@ -128,7 +132,7 @@ class transformer_render_instance_t : public render_instance_t
         if (auto tex = zero_copy_texture())
         {
             self->release_buffers();
-            return *tex;
+            return tex;
         }
 
         return self->get_updated_contents(self->get_children_bounding_box(), scale, children);