shadow_pass.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "../render_pass_base.hpp"
#include "../shader_layout.hpp"
#include "../shadow_constants.hpp"
#include "../voxel_change_history.hpp"
#include "../vulkan_common.hpp"
#include "../vulkan_pipeline.hpp"
 
#include <array>
#include <chrono>
#include <glm/glm.hpp>
#include <memory>
#include <optional>
#include <span>
#include <vector>
 
namespace renderer {
class VulkanCore;
class VoxelGpuStorage;
 
[[nodiscard]]
auto createShadowSampler(const VulkanCore& core, vk::Format format) -> vk::raii::Sampler;
 
class ShadowPass : public IRenderPass {
public:
  explicit ShadowPass(const VulkanCore& core);
 
  [[nodiscard]]
  auto name() const -> std::string_view override {
    return "ShadowPass";
  }
 
  void recordPre(vk::CommandBuffer cmd, uint32_t frame_index, uint32_t image_index) override;

  void record(vk::CommandBuffer cmd, uint32_t frame_index, uint32_t image_index) override { }
 
  [[nodiscard]]
  auto getCascadeMapView(uint32_t frame_index) const -> vk::ImageView;
 
  [[nodiscard]]
  auto getPunctualMapView(uint32_t frame_index) const -> vk::ImageView;
 
  [[nodiscard]]
  auto getShadowSampler() const -> vk::Sampler {
    return *m_sampler;
  }

  struct Stats {
    uint32_t draws = 0;
    uint32_t scopes = 0;
    uint32_t cached = 0;
    uint32_t composed = 0;
    uint32_t static_views = 0;
    uint32_t static_casters = 0;
    uint32_t static_edits = 0;
    uint32_t moving_volumes = 0;
    uint32_t spared = 0;
  };
 
  [[nodiscard]]
  auto getStats() const noexcept -> const Stats& {
    return m_stats;
  }
 
private:
  struct ShadowUBO {
    std::array<glm::mat4, shadows::k_max_shadow_views> view_projection {};
    std::array<glm::mat4, shadows::k_max_shadow_views> inverse_view_projection {};
  };

  struct ShadowPushConstants {
    uint32_t instance_base = 0;
    uint32_t view_index = 0;
  };

  struct VoxelShadowPush {
    uint32_t instance_index = 0;
    uint32_t view_index = 0;
    float constant_bias = 0.0f;
    uint32_t pad0 = 0;
  };
 
  struct VoxelPipelineSet {
    uint32_t view_mask = 1;

    std::array<std::array<VulkanPipeline, 2>, 2> pipelines;
  };
 
  static constexpr uint32_t k_max_voxel_casters = 4096;
  std::chrono::steady_clock::time_point m_last_caster_limit_warning;
 
  struct LayerGroup {
    uint32_t base_layer = 0;
    uint32_t layer_count = 1;

    uint32_t view_mask = 1;
 
    std::optional<vk::raii::ImageView> view;
 
    bool dirty = true;
 
    std::optional<uint64_t> signature;

    std::optional<uint64_t> caster_signature;

    std::optional<uint64_t> voxel_generation;

    uint64_t revision = 0;
  };
 
  struct ShadowMap {
    std::optional<vma::raii::Image> image;
    std::optional<vk::raii::ImageView> array_view;
    std::vector<LayerGroup> groups;
    sync::ImageState state;
    uint32_t resolution = 0;
    uint32_t layer_count = 0;
  };
 
  struct PipelineSet {
    uint32_t view_mask = 1;
    VulkanPipeline pipeline;
  };
 
  struct FrameTarget {
    ShadowMap cascades;
    ShadowMap punctual;
    FrameResources ubo;
  };

  struct StaticMaps {
    ShadowMap cascades;
    ShadowMap punctual;
  };
 
  void createResources(const VulkanCore& core);
 
  void createShadowMap(
      const VulkanCore& core, ShadowMap& map, uint32_t resolution, std::span<const uint32_t> group_layers,
      vk::ImageUsageFlags usage, std::string_view debug_name
  );
 
  [[nodiscard]]
  auto pipelineSetFor(uint32_t view_mask) const -> const PipelineSet*;
 
  void createVoxelResources(const VulkanCore& core);

  [[nodiscard]]
  auto prepareVoxels(uint32_t frame_index) -> uint32_t;
 
  [[nodiscard]]
  auto voxelPipelineSetFor(uint32_t view_mask) const -> const VoxelPipelineSet*;
 
  void recordMap(vk::CommandBuffer cmd, ShadowMap& map, ShadowMap& static_map, uint32_t frame_index, bool directional);
 
  [[nodiscard]]
  static auto selectShadowFormat(const VulkanCore& core) -> vk::Format;
 
  const VulkanCore* m_core = nullptr;
  vk::Format m_format = vk::Format::eUndefined;
 
  ShaderLayout m_shader_layout;

  std::array<PipelineSet, 2> m_pipeline_sets;
 
  Stats m_stats;
  std::vector<VoxelCaster> m_voxel_eligible;
 
  vk::raii::Sampler m_sampler = nullptr;
  std::vector<vk::raii::DescriptorSet> m_descriptor_sets;
  std::vector<FrameTarget> m_targets;
  StaticMaps m_static;
 
  ShaderLayout m_voxel_layout;
  std::array<VoxelPipelineSet, 2> m_voxel_pipeline_sets;
  std::vector<vk::raii::DescriptorSet> m_voxel_shadow_sets;
  std::vector<vk::raii::DescriptorSet> m_voxel_storage_sets;
  std::vector<vma::raii::Buffer> m_voxel_instance_buffers;
  std::vector<std::shared_ptr<const VoxelGpuStorage>> m_voxel_bound_storage;
  bool m_voxels_ready = false;

  float m_voxel_constant_bias = 0.0f;
 
  uint32_t m_voxel_instance_count = 0;
 
  std::vector<uint32_t> m_voxel_draw_order;
 
  std::vector<vk::ImageCopy> m_static_copies;
};
 
}