eevee_depth_of_field.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2021 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "eevee_depth_of_field_shared.hh"
 
#include "draw_pass.hh"
 
namespace blender::eevee {
 
using namespace draw;
 
class Instance;
 
/* -------------------------------------------------------------------- */
 
struct DepthOfFieldBuffer {
  Texture stabilize_history_tx_ = {"dof_taa"};
};
 
using DepthOfFieldScatterListBuf = draw::StorageArrayBuffer<ScatterRect, 16, true>;
using DepthOfFieldDataBuf = draw::UniformBuffer<DepthOfFieldData>;
 
class DepthOfField {
 
 private:
  class Instance &inst_;
 
  static constexpr GPUSamplerState no_filter = GPUSamplerState::default_sampler();
  static constexpr GPUSamplerState with_filter = {GPU_SAMPLER_FILTERING_LINEAR};

  gpu::Texture *input_color_tx_ = nullptr;
  gpu::Texture *output_color_tx_ = nullptr;

  TextureFromPool bokeh_gather_lut_tx_ = {"dof_bokeh_gather_lut"};
  TextureFromPool bokeh_resolve_lut_tx_ = {"dof_bokeh_resolve_lut"};
  TextureFromPool bokeh_scatter_lut_tx_ = {"dof_bokeh_scatter_lut"};
  PassSimple bokeh_lut_ps_ = {"BokehLut"};

  TextureFromPool setup_coc_tx_ = {"dof_setup_coc"};
  TextureFromPool setup_color_tx_ = {"dof_setup_color"};
  int3 dispatch_setup_size_ = int3(-1);
  PassSimple setup_ps_ = {"Setup"};

  Texture reduced_coc_tx_ = {"dof_reduced_coc"};
  Texture reduced_color_tx_ = {"dof_reduced_color"};

  TextureFromPool stabilize_output_tx_ = {"dof_taa"};
  gpu::Texture *stabilize_input_ = nullptr;
  bool32_t stabilize_valid_history_ = false;
  int3 dispatch_stabilize_size_ = int3(-1);
  PassSimple stabilize_ps_ = {"Stabilize"};

  TextureFromPool downsample_tx_ = {"dof_downsample"};
  int3 dispatch_downsample_size_ = int3(-1);
  PassSimple downsample_ps_ = {"Downsample"};

  DepthOfFieldScatterListBuf scatter_fg_list_buf_;
  DepthOfFieldScatterListBuf scatter_bg_list_buf_;
  DrawIndirectBuf scatter_fg_indirect_buf_;
  DrawIndirectBuf scatter_bg_indirect_buf_;
  int3 dispatch_reduce_size_ = int3(-1);
  PassSimple reduce_ps_ = {"Reduce"};

  SwapChain<TextureFromPool, 2> tiles_fg_tx_;
  SwapChain<TextureFromPool, 2> tiles_bg_tx_;
  int3 dispatch_tiles_flatten_size_ = int3(-1);
  PassSimple tiles_flatten_ps_ = {"TilesFlatten"};

  int tiles_dilate_ring_count_ = -1;
  int tiles_dilate_ring_width_mul_ = -1;
  int3 dispatch_tiles_dilate_size_ = int3(-1);
  PassSimple tiles_dilate_minmax_ps_ = {"TilesDilateMinmax"};
  PassSimple tiles_dilate_minabs_ps_ = {"TilesDilateMinabs"};

  SwapChain<TextureFromPool, 2> color_bg_tx_;
  SwapChain<TextureFromPool, 2> color_fg_tx_;
  SwapChain<TextureFromPool, 2> weight_bg_tx_;
  SwapChain<TextureFromPool, 2> weight_fg_tx_;
  TextureFromPool occlusion_tx_ = {"dof_occlusion"};
  int3 dispatch_gather_size_ = int3(-1);
  PassSimple gather_fg_ps_ = {"GatherFg"};
  PassSimple gather_bg_ps_ = {"GatherBg"};

  TextureFromPool hole_fill_color_tx_ = {"dof_color_hole_fill"};
  TextureFromPool hole_fill_weight_tx_ = {"dof_weight_hole_fill"};
  PassSimple hole_fill_ps_ = {"HoleFill"};

  int3 dispatch_filter_size_ = int3(-1);
  PassSimple filter_fg_ps_ = {"FilterFg"};
  PassSimple filter_bg_ps_ = {"FilterBg"};

  Framebuffer scatter_fg_fb_ = {"dof_scatter_fg"};
  Framebuffer scatter_bg_fb_ = {"dof_scatter_bg"};
  PassSimple scatter_fg_ps_ = {"ScatterFg"};
  PassSimple scatter_bg_ps_ = {"ScatterBg"};

  gpu::Texture *resolve_stable_color_tx_ = nullptr;
  int3 dispatch_resolve_size_ = int3(-1);
  PassSimple resolve_ps_ = {"Resolve"};
 
  DepthOfFieldDataBuf data_;

  float user_overblur_ = 0.0f;
  float fx_max_coc_ = 0.0f;
  bool do_jitter_ = false;
  bool use_bokeh_lut_ = false;

  float fx_radius_ = 0.0f;
  float jitter_radius_ = 0.0f;
  float focus_distance_ = 0.0f;
  int2 extent_ = int2(0);
 
  bool enabled_ = false;
 
 public:
  DepthOfField(Instance &inst) : inst_(inst) {};
  ~DepthOfField() {};
 
  void init();
 
  void sync();

  void jitter_apply(float4x4 &winmat, float4x4 &viewmat);

  void render(View &view,
              gpu::Texture **input_tx,
              gpu::Texture **output_tx,
              DepthOfFieldBuffer &dof_buffer);
 
  bool postfx_enabled() const
  {
    return fx_radius_ > 0.0f;
  }
 
  bool enabled() const
  {
    return enabled_;
  }
 
 private:
  void bokeh_lut_pass_sync();
  void setup_pass_sync();
  void stabilize_pass_sync();
  void downsample_pass_sync();
  void reduce_pass_sync();
  void tiles_flatten_pass_sync();
  void tiles_dilate_pass_sync();
  void gather_pass_sync();
  void filter_pass_sync();
  void scatter_pass_sync();
  void hole_fill_pass_sync();
  void resolve_pass_sync();

  void update_sample_table();
};

 
}  // namespace blender::eevee