src/blue_noise.glsl

@@ -1,11 +1,5 @@
 #version 450
 
-struct FloatAndIndex {
-  float value;
-  int pbp;
-  int idx;
-};
-
 int twoToOne(int x, int y, int width, int height) {
   while (x < 0) {
     x += width;
@@ -20,9 +14,11 @@ int twoToOne(int x, int y, int width, int height) {
 
 layout(binding = 0) readonly buffer PreComputed { float precomputed[]; };
 
-layout(binding = 1) buffer FilterInOut { FloatAndIndex filter_in_out[]; };
+layout(binding = 1) writeonly buffer FilterOut { float filter_out[]; };
 
-layout(binding = 2) readonly buffer Other {
+layout(binding = 2) readonly buffer PBP { int pbp[]; };
+
+layout(binding = 3) readonly buffer Other {
   int width;
   int height;
   int filter_size;
@@ -36,20 +32,19 @@ void main() {
     return;
   }
 
-  // filter_in_out[index].idx = int(index);
-
   int x = int(index % width);
   int y = int(index / width);
 
-  filter_in_out[index].value = 0.0F;
+  float sum = 0.0F;
   for (int q = 0; q < filter_size; ++q) {
     int q_prime = height - filter_size / 2 + y + q;
     for (int p = 0; p < filter_size; ++p) {
       int p_prime = width - filter_size / 2 + x + p;
-      if (filter_in_out[twoToOne(p_prime, q_prime, width, height)].pbp != 0) {
+      if (pbp[twoToOne(p_prime, q_prime, width, height)] != 0) {
-        filter_in_out[index].value +=
+        sum += precomputed[twoToOne(p, q, filter_size, filter_size)];
-            precomputed[twoToOne(p, q, filter_size, filter_size)];
       }
     }
   }
+
+  filter_out[index] = sum;
 }

src/blue_noise.hpp

@@ -13,6 +13,7 @@
 #include <cmath>
 #include <condition_variable>
 #include <cstdio>
+#include <functional>
 #include <iostream>
 #include <limits>
 #include <mutex>
@@ -21,6 +22,7 @@
 #include <stdexcept>
 #include <thread>
 #include <tuple>
+#include <unordered_set>
 #include <vector>
 
 #include "image.hpp"
@@ -46,12 +48,6 @@ struct QueueFamilyIndices {
 
 QueueFamilyIndices vulkan_find_queue_families(VkPhysicalDevice device);
 
-struct FloatAndIndex {
-  float value;
-  int pbp;
-  int idx;
-};
-
 std::optional<uint32_t> vulkan_find_memory_type(VkPhysicalDevice phys_dev,
                                                 uint32_t t_filter,
                                                 VkMemoryPropertyFlags props);
@@ -63,8 +59,7 @@ bool vulkan_create_buffer(VkDevice device, VkPhysicalDevice phys_dev,
 
 void vulkan_copy_buffer(VkDevice device, VkCommandPool command_pool,
                         VkQueue queue, VkBuffer src_buf, VkBuffer dst_buf,
-                        VkDeviceSize size, VkDeviceSize src_offset = 0,
+                        VkDeviceSize size, VkDeviceSize offset = 0);
-                        VkDeviceSize dst_offset = 0);
 void vulkan_copy_buffer_pieces(
     VkDevice device, VkCommandPool command_pool, VkQueue queue,
     VkBuffer src_buf, VkBuffer dst_buf,
@@ -79,28 +74,111 @@ void vulkan_invalidate_buffer(VkDevice device, VkDeviceMemory memory);
 std::vector<unsigned int> blue_noise_vulkan_impl(
     VkDevice device, VkPhysicalDevice phys_device,
     VkCommandBuffer command_buffer, VkCommandPool command_pool, VkQueue queue,
-    VkPipeline minmax_pipeline, VkPipelineLayout minmax_pipeline_layout,
+    VkBuffer pbp_buf, VkPipeline pipeline, VkPipelineLayout pipeline_layout,
-    std::array<VkDescriptorSet, 2> minmax_descriptor_sets, VkBuffer max_in_buf,
+    VkDescriptorSet descriptor_set, VkBuffer filter_out_buf, const int width,
-    VkBuffer min_in_buf, VkBuffer max_out_buf, VkBuffer min_out_buf,
+    const int height);
-    const int width, const int height, VkBuffer minmax_staging_buf,
-    VkDeviceMemory minmax_staging_buf_mem, void *minmax_mapped,
-    VkPipeline filter_in_out_pipeline,
-    VkPipelineLayout filter_in_out_pipeline_layout,
-    VkDescriptorSet filter_in_out_desc_set);
 
 std::vector<float> vulkan_buf_to_vec(float *mapped, unsigned int size);
 
-std::optional<std::pair<int, int>> vulkan_filter_and_minmax(
+inline bool vulkan_get_filter(
-    VkDevice device, VkCommandBuffer command_buffer, VkCommandPool command_pool,
+    VkDevice device, const VkDeviceSize phys_atom_size,
-    VkQueue queue, VkPipeline filter_in_out_pipeline,
+    VkCommandBuffer command_buffer, VkCommandPool command_pool, VkQueue queue,
-    VkPipelineLayout filter_in_out_pipeline_layout,
+    VkBuffer pbp_buf, VkPipeline pipeline, VkPipelineLayout pipeline_layout,
-    VkDescriptorSet filter_in_out_desc_set, VkPipeline minmax_pipeline,
+    VkDescriptorSet descriptor_set, VkBuffer filter_out_buf, const int size,
-    VkPipelineLayout minmax_pipeline_layout,
+    std::vector<bool> &pbp, bool reversed_pbp, const std::size_t global_size,
-    std::array<VkDescriptorSet, 2> minmax_desc_sets, VkBuffer max_in_buf,
+    int *pbp_mapped_int, VkBuffer staging_pbp_buffer,
-    VkBuffer min_in_buf, VkBuffer max_out_buf, VkBuffer min_out_buf,
+    VkDeviceMemory staging_pbp_buffer_mem,
-    const int size, const std::size_t global_size, std::vector<bool> &pbp,
+    VkDeviceMemory staging_filter_buffer_mem, VkBuffer staging_filter_buffer,
-    VkBuffer staging_buf, VkDeviceMemory staging_buf_mem, void *staging_mapped,
+    std::vector<std::size_t> *changed) {
-    VkDeviceSize phys_atom_size, bool reversed_pbp);
+  vkResetCommandBuffer(command_buffer, 0);
+
+  if (changed != nullptr && changed->size() > 0) {
+    if (reversed_pbp) {
+      for (auto idx : *changed) {
+        pbp_mapped_int[idx] = pbp[idx] ? 0 : 1;
+      }
+    } else {
+      for (auto idx : *changed) {
+        pbp_mapped_int[idx] = pbp[idx] ? 1 : 0;
+      }
+    }
+  } else {
+    if (reversed_pbp) {
+      for (unsigned int i = 0; i < pbp.size(); ++i) {
+        pbp_mapped_int[i] = pbp[i] ? 0 : 1;
+      }
+    } else {
+      for (unsigned int i = 0; i < pbp.size(); ++i) {
+        pbp_mapped_int[i] = pbp[i] ? 1 : 0;
+      }
+    }
+  }
+
+  // Copy pbp buffer.
+  if (changed != nullptr && changed->size() > 0) {
+    std::vector<std::tuple<VkDeviceSize, VkDeviceSize> > pieces;
+    for (auto idx : *changed) {
+      pieces.emplace_back(std::make_tuple(sizeof(int), idx * sizeof(int)));
+    }
+
+    vulkan_flush_buffer_pieces(device, phys_atom_size, staging_pbp_buffer_mem,
+                               pieces);
+
+    vulkan_copy_buffer_pieces(device, command_pool, queue, staging_pbp_buffer,
+                              pbp_buf, pieces);
+    changed->clear();
+  } else {
+    vulkan_flush_buffer(device, staging_pbp_buffer_mem);
+    vulkan_copy_buffer(device, command_pool, queue, staging_pbp_buffer, pbp_buf,
+                       size * sizeof(int));
+  }
+
+  VkCommandBufferBeginInfo begin_info{};
+  begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+
+  if (vkBeginCommandBuffer(command_buffer, &begin_info) != VK_SUCCESS) {
+    std::clog << "get_filter ERROR: Failed to begin recording compute "
+                 "command buffer!\n";
+    return false;
+  }
+
+  vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
+  vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE,
+                          pipeline_layout, 0, 1, &descriptor_set, 0, nullptr);
+  vkCmdDispatch(command_buffer, global_size, 1, 1);
+  if (vkEndCommandBuffer(command_buffer) != VK_SUCCESS) {
+    std::clog << "get_filter ERROR: Failed to record compute command buffer!\n";
+    return false;
+  }
+
+  {
+    VkSubmitInfo submit_info{};
+    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submit_info.commandBufferCount = 1;
+    submit_info.pCommandBuffers = &command_buffer;
+    submit_info.signalSemaphoreCount = 0;
+    submit_info.pSignalSemaphores = nullptr;
+
+    if (vkQueueSubmit(queue, 1, &submit_info, nullptr) != VK_SUCCESS) {
+      std::clog
+          << "get_filter ERROR: Failed to submit compute command buffer!\n";
+      return false;
+    }
+  }
+
+  if (vkDeviceWaitIdle(device) != VK_SUCCESS) {
+    std::clog << "get_filter ERROR: Failed to vkDeviceWaitIdle!\n";
+    return false;
+  }
+
+  // Copy back filter_out buffer.
+  vulkan_copy_buffer(device, command_pool, queue, filter_out_buf,
+                     staging_filter_buffer, size * sizeof(float));
+
+  vulkan_invalidate_buffer(device, staging_filter_buffer_mem);
+
+  return true;
+}
 
 #endif
 

src/blue_noise_minmax.glsl

@@ -1,54 +0,0 @@
-#version 450
-
-struct FloatAndIndex {
-  float value;
-  int pbp;
-  int idx;
-};
-
-layout(binding = 0) readonly buffer MaxIn { FloatAndIndex max_in[]; };
-layout(binding = 1) readonly buffer MinIn { FloatAndIndex min_in[]; };
-layout(binding = 2) writeonly buffer MaxOut { FloatAndIndex max_out[]; };
-layout(binding = 3) writeonly buffer MinOut { FloatAndIndex min_out[]; };
-
-layout(binding = 4) readonly buffer State { int size; };
-
-layout(local_size_x = 256) in;
-
-void main() {
-  uint index = gl_GlobalInvocationID.x;
-  if (index >= (size + 1) / 2) {
-    return;
-  }
-
-  if (index * 2 + 1 < size) {
-    if (max_in[index * 2].pbp != 0 && max_in[index * 2 + 1].pbp != 0) {
-      if (max_in[index * 2].value > max_in[index * 2 + 1].value) {
-        max_out[index] = max_in[index * 2];
-      } else {
-        max_out[index] = max_in[index * 2 + 1];
-      }
-    } else if (max_in[index * 2].pbp != 0 && max_in[index * 2 + 1].pbp == 0) {
-      max_out[index] = max_in[index * 2];
-    } else {
-      max_out[index] = max_in[index * 2 + 1];
-    }
-
-    if (min_in[index * 2].pbp == 0 && min_in[index * 2 + 1].pbp == 0) {
-      if (min_in[index * 2].value < min_in[index * 2 + 1].value) {
-        min_out[index] = min_in[index * 2];
-      } else {
-        min_out[index] = min_in[index * 2 + 1];
-      }
-    } else if (min_in[index * 2].pbp == 0 && min_in[index * 2 + 1].pbp != 0) {
-      min_out[index] = min_in[index * 2];
-    } else {
-      min_out[index] = min_in[index * 2 + 1];
-    }
-  } else {
-    max_out[index] = max_in[index * 2];
-    max_out[index + 1].pbp = 0;
-    min_out[index] = min_in[index * 2];
-    min_out[index + 1].pbp = 1;
-  }
-}