voxel_pass.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../hiz_pyramid.hpp"
#include "../render_pass_base.hpp"
#include "../scene_descriptor_set.hpp"
#include "../shader_layout.hpp"
#include "../vulkan_pipeline.hpp"
 
#include <array>
#include <chrono>
#include <glm/glm.hpp>
#include <memory>
#include <optional>
#include <string_view>
#include <vector>
 
namespace renderer {
class VulkanCore;
class VoxelGpuStorage;

class VoxelPass : public IRenderPass {
public:
  VoxelPass(const VulkanCore& core, vk::Format scene_format, vk::Format depth_format, vk::Extent2D extent);
 
  [[nodiscard]]
  auto stage() const -> RenderStage override {
    return RenderStage::voxel_gbuffer;
  }

  [[nodiscard]]
  auto prepare(uint32_t frame_index) -> bool;

  void recordCellCull(vk::CommandBuffer cmd, uint32_t frame_index, vk::Extent2D scene_extent);

  void record(vk::CommandBuffer cmd, uint32_t frame_index, uint32_t image_index) override;

  [[nodiscard]]
  auto occlusionActive() const -> bool {
    return m_occlusion_active;
  }

  void recordOcclusion(vk::CommandBuffer cmd, uint32_t frame_index, vk::Extent2D scene_extent);

  void recordLate(vk::CommandBuffer cmd, uint32_t frame_index);

  [[nodiscard]]
  auto nearQuadDepthPass() const -> bool {
    return m_near_voxels > 0.0f && !m_mesh_shading;
  }

  void recordQuadDepth(vk::CommandBuffer cmd, uint32_t frame_index, bool late);

  void recordLighting(vk::CommandBuffer cmd, uint32_t frame_index, vk::Extent2D viewport);

  void onTargetsRecreated();
 
  [[nodiscard]]
  auto name() const -> std::string_view override {
    return "Voxels";
  }
 
  static constexpr uint32_t k_max_instances = 4096;
 
private:
  std::chrono::steady_clock::time_point m_last_limit_warning;

  struct PushConstants {
    uint32_t instance_index = 0;
    uint32_t bucket = 0;
    uint32_t mode = 0;
    uint32_t quad_capacity = 0;
  };

  static constexpr uint32_t k_draw_volume = 0;
  static constexpr uint32_t k_draw_cells = 1;

  struct CellCullPush {
    glm::mat4 view_projection {1.0f};
    glm::vec4 camera_near {0.0f};
    uint32_t total_cells = 0;
    uint32_t instance_count = 0;
    uint32_t phase = 0;
    uint32_t quad_capacity = 0;
    float near_voxels = 0.0f;
    uint32_t hiz_levels = 0;
    uint32_t hiz_width = 0;
    uint32_t hiz_height = 0;
  };

  struct HizView {
    glm::mat4 view_projection {1.0f};
  };

  static constexpr uint32_t k_cell_bucket_count = 17;
  static constexpr uint32_t k_late_list = k_cell_bucket_count;
  static constexpr uint32_t k_cell_draw_count = k_cell_bucket_count + 1;
  static constexpr uint32_t k_near_list = k_cell_draw_count;
  static constexpr uint32_t k_near_band_count = 4;
  static constexpr uint32_t k_retest_list = k_near_list + k_near_band_count;
  static constexpr uint32_t k_late_near_list = k_retest_list + 1;
  static constexpr uint32_t k_cell_list_count = k_late_near_list + 1;
  static constexpr uint32_t k_cell_offsets_word = k_cell_draw_count * 4;
  static constexpr uint32_t k_cell_cursors_word = k_cell_offsets_word + k_cell_list_count;
  static constexpr uint32_t k_near_dispatch_word = k_cell_cursors_word + k_cell_list_count;
  static constexpr uint32_t k_retest_dispatch_word = k_near_dispatch_word + 3;
  static constexpr uint32_t k_late_mesh_dispatch_word = k_retest_dispatch_word + 3;
  static constexpr uint32_t k_quad_draw_word = k_late_mesh_dispatch_word + 3;
  static constexpr uint32_t k_late_quad_draw_word = k_quad_draw_word + 4;
  static constexpr uint32_t k_near_task_word = k_late_quad_draw_word + 4;
  static constexpr uint32_t k_late_task_word = k_near_task_word + 3;
  static constexpr uint32_t k_occlusion_stats_word = k_late_task_word + 3;
  static constexpr uint32_t k_cell_args_words = k_occlusion_stats_word + 2;
  static constexpr uint32_t k_min_quad_capacity = 65536;
  static constexpr uint32_t k_max_coarse_dim = 1024;
  static constexpr uint32_t k_min_cell_capacity = 4096;

  struct CellBuffers {
    std::optional<vma::raii::Buffer> cells;
    std::optional<vma::raii::Buffer> classes;
    std::optional<vma::raii::Buffer> args;
    uint32_t capacity = 0;
    std::optional<vma::raii::Buffer> quads;
    uint32_t quad_capacity = 0;
    std::optional<vma::raii::Buffer> readback;
    bool measured = false;
    std::optional<vma::raii::Buffer> hiz_view;
  };

  struct LightingPushConstants {
    glm::mat4 inverse_view_projection {1.0f};
    glm::vec4 camera_radius {0.0f};
    glm::vec4 viewport {0.0f};
  };
 
  void createCells(const VulkanCore& core);
  void ensureCellCapacity(uint32_t frame_index, uint32_t cells);
  void ensureQuadCapacity(uint32_t frame_index, uint32_t quads);
  void afterCullWrites(vk::CommandBuffer cmd, uint32_t frame_index, sync::BarrierBatch& barriers);
  void recordNearQuads(vk::CommandBuffer cmd, uint32_t frame_index, bool late, bool depth_only);
  void recordReadback(vk::CommandBuffer cmd, uint32_t frame_index, sync::BarrierBatch& barriers);
  void updateOcclusionMode(uint32_t retest_cells, uint32_t listed_cells);
  void writeCellDescriptors(uint32_t frame_index);
  void writeHizDescriptors();
  void recordCellDraws(vk::CommandBuffer cmd, uint32_t frame_index);
 
  enum class Cull : uint8_t {
    back,
    front,
  };
 
  enum class Depth : uint8_t {
    conservative,
    exact,
  };
 
  struct Draw {
    uint32_t instance = 0;
    Cull cull = Cull::back;
    Depth depth = Depth::conservative;
  };
 
  void createInstanceBuffers(const VulkanCore& core);
  void createDescriptors(const VulkanCore& core, const ShaderReflection& reflection);
  void createLighting(const VulkanCore& core, vk::Format scene_format, vk::Extent2D extent);
 
  void bindStorage(uint32_t frame_index, const std::shared_ptr<const VoxelGpuStorage>& storage);
 
  const VulkanCore* m_core = nullptr;
  ShaderLayout m_shader_layout;

  std::array<std::array<VulkanPipeline, 2>, 2> m_pipelines;
 
  SceneDescriptorSets m_scene_sets;
 
  std::vector<vk::raii::DescriptorSet> m_storage_sets;
 
  std::vector<vma::raii::Buffer> m_instance_buffers;
 
  std::vector<std::shared_ptr<const VoxelGpuStorage>> m_bound_storage;
 
  std::vector<Draw> m_draws;
 
  ShaderLayout m_cell_layout;
  VulkanPipeline m_cell_pipeline;
  VulkanPipeline m_mesh_pipeline;
  VulkanPipeline m_quad_pipeline;
  VulkanPipeline m_quad_depth_pipeline;
  VulkanPipeline m_mesh_quad_pipeline;
  PFN_vkCmdDrawMeshTasksIndirectEXT m_draw_mesh_tasks_indirect = nullptr;
  bool m_mesh_shading = false;
  std::vector<vk::raii::DescriptorSet> m_cell_sets;
  std::vector<CellBuffers> m_cell_buffers;
 
  bool m_cells_active = false;
  bool m_occlusion_active = false;
 
  enum class OcclusionMode : uint8_t {
    engaged,
    idle,
  };
  OcclusionMode m_occlusion_mode = OcclusionMode::engaged;
  uint32_t m_occlusion_low_frames = 0;
  uint32_t m_occlusion_idle_frames = 0;
  uint64_t m_frame_count = 0;
  uint64_t m_pyramid_frame = 0;
  uint32_t m_total_cells = 0;
  CellCullPush m_cull_push;
  HiZPyramid m_hiz;
  float m_near_voxels = 0.0f;
 
  ShaderLayout m_lighting_layout;
  VulkanPipeline m_lighting_pipeline;
  SceneDescriptorSets m_lighting_scene_sets;
 
  vk::raii::Sampler m_point_sampler = nullptr;
  std::vector<vk::raii::DescriptorSet> m_gbuffer_sets;

  std::vector<std::array<vk::ImageView, 4>> m_bound_gbuffer;
};
 
}