eevee_raytrace.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "DNA_scene_types.h"
 
#include "DRW_render.hh"
 
#include "eevee_shader_shared.hh"
 
namespace blender::eevee {
 
class Instance;
 
/* -------------------------------------------------------------------- */
struct RayTraceBuffer {
  struct DenoiseBuffer {
    /* Persistent history buffers. */
    Texture radiance_history_tx = {"radiance_tx"};
    Texture variance_history_tx = {"variance_tx"};
    /* Map of tiles that were processed inside the history buffer. */
    Texture tilemask_history_tx = {"tilemask_tx"};
    float4x4 history_persmat;
    bool valid_history = false;
    TextureFromPool denoised_spatial_tx = {"denoised_spatial_tx"};
    TextureFromPool denoised_temporal_tx = {"denoised_temporal_tx"};
    TextureFromPool denoised_bilateral_tx = {"denoised_bilateral_tx"};
  };
  DenoiseBuffer closures[3];
 
  Texture radiance_feedback_tx = {"radiance_feedback_tx"};
  float4x4 history_persmat;
 
  GPUTexture *feedback_ensure(bool is_dummy, int2 extent)
  {
    eGPUTextureUsage usage_rw = GPU_TEXTURE_USAGE_SHADER_READ | GPU_TEXTURE_USAGE_SHADER_WRITE;
    if (radiance_feedback_tx.ensure_2d(GPU_RGBA16F, is_dummy ? int2(1) : extent, usage_rw)) {
      radiance_feedback_tx.clear(float4(0.0f));
    }
    return radiance_feedback_tx;
  }
};
 
class RayTraceResultTexture {
 private:
  TextureFromPool *result_ = nullptr;
  GPUTexture *tx_ = nullptr;
  Texture *history_ = nullptr;
 
 public:
  RayTraceResultTexture() = default;
  RayTraceResultTexture(TextureFromPool &result) : result_(result.ptr()), tx_(result){};
  RayTraceResultTexture(TextureFromPool &result, Texture &history)
      : result_(result.ptr()), tx_(result), history_(history.ptr()){};
 
  operator GPUTexture *() const
  {
    BLI_assert(tx_ != nullptr);
    return tx_;
  }
 
  GPUTexture **operator&()
  {
    return &tx_;
  }
 
  void release()
  {
    if (history_) {
      /* Swap after last use. */
      TextureFromPool::swap(*result_, *history_);
    }
    /* NOTE: This releases the previous history. */
    result_->release();
  }
};
 
struct RayTraceResult {
  RayTraceResultTexture closures[3];
 
  void release()
  {
    for (int i = 0; i < 3; i++) {
      closures[i].release();
    }
  }
};
 
/* -------------------------------------------------------------------- */
class RayTraceModule {
 private:
  Instance &inst_;
 
  draw::PassSimple tile_classify_ps_ = {"TileClassify"};
  draw::PassSimple tile_compact_ps_ = {"TileCompact"};
  draw::PassSimple generate_ps_ = {"RayGenerate"};
  draw::PassSimple trace_planar_ps_ = {"Trace.Planar"};
  draw::PassSimple trace_screen_ps_ = {"Trace.Screen"};
  draw::PassSimple trace_fallback_ps_ = {"Trace.Fallback"};
  draw::PassSimple denoise_spatial_ps_ = {"DenoiseSpatial"};
  draw::PassSimple denoise_temporal_ps_ = {"DenoiseTemporal"};
  draw::PassSimple denoise_bilateral_ps_ = {"DenoiseBilateral"};
  draw::PassSimple horizon_schedule_ps_ = {"HorizonScan.Schedule"};
  draw::PassSimple horizon_setup_ps_ = {"HorizonScan.Setup"};
  draw::PassSimple horizon_scan_ps_ = {"HorizonScan.Trace"};
  draw::PassSimple horizon_denoise_ps_ = {"HorizonScan.Denoise"};
  draw::PassSimple horizon_resolve_ps_ = {"HorizonScan.Resolve"};
 
  int3 tile_classify_dispatch_size_ = int3(1);
  int3 tile_compact_dispatch_size_ = int3(1);
  int3 horizon_schedule_dispatch_size_ = int3(1);
  int3 tracing_dispatch_size_ = int3(1);
  int3 horizon_tracing_dispatch_size_ = int3(1);
  Texture tile_raytrace_denoise_tx_ = {"tile_raytrace_denoise_tx_"};
  Texture tile_raytrace_tracing_tx_ = {"tile_raytrace_tracing_tx_"};
  Texture tile_horizon_denoise_tx_ = {"tile_horizon_denoise_tx_"};
  Texture tile_horizon_tracing_tx_ = {"tile_horizon_tracing_tx_"};
  DispatchIndirectBuf raytrace_tracing_dispatch_buf_ = {"raytrace_tracing_dispatch_buf_"};
  DispatchIndirectBuf raytrace_denoise_dispatch_buf_ = {"raytrace_denoise_dispatch_buf_"};
  DispatchIndirectBuf horizon_tracing_dispatch_buf_ = {"horizon_tracing_dispatch_buf_"};
  DispatchIndirectBuf horizon_denoise_dispatch_buf_ = {"horizon_denoise_dispatch_buf_"};
  GPUTexture *horizon_scan_output_tx_[3] = {nullptr};
  RayTraceTileBuf raytrace_tracing_tiles_buf_ = {"raytrace_tracing_tiles_buf_"};
  RayTraceTileBuf raytrace_denoise_tiles_buf_ = {"raytrace_denoise_tiles_buf_"};
  RayTraceTileBuf horizon_tracing_tiles_buf_ = {"horizon_tracing_tiles_buf_"};
  RayTraceTileBuf horizon_denoise_tiles_buf_ = {"horizon_denoise_tiles_buf_"};
  TextureFromPool ray_data_tx_ = {"ray_data_tx"};
  TextureFromPool ray_time_tx_ = {"ray_data_tx"};
  TextureFromPool ray_radiance_tx_ = {"ray_radiance_tx"};
  TextureFromPool horizon_radiance_tx_[4] = {{"horizon_radiance_tx_"}};
  TextureFromPool horizon_radiance_denoised_tx_[4] = {{"horizon_radiance_denoised_tx_"}};
  TextureFromPool downsampled_in_radiance_tx_ = {"downsampled_in_radiance_tx_"};
  TextureFromPool downsampled_in_normal_tx_ = {"downsampled_in_normal_tx_"};
  GPUTexture *denoised_spatial_tx_ = nullptr;
  GPUTexture *denoised_temporal_tx_ = nullptr;
  GPUTexture *denoised_bilateral_tx_ = nullptr;
  TextureFromPool hit_depth_tx_ = {"hit_depth_tx_"};
  TextureFromPool hit_variance_tx_ = {"hit_variance_tx_"};
  TextureFromPool denoise_variance_tx_ = {"denoise_variance_tx_"};
  GPUTexture *radiance_history_tx_ = nullptr;
  GPUTexture *variance_history_tx_ = nullptr;
  GPUTexture *tilemask_history_tx_ = nullptr;
  GPUTexture *screen_radiance_front_tx_ = nullptr;
  GPUTexture *screen_radiance_back_tx_ = nullptr;
 
  Texture radiance_dummy_black_tx_ = {"radiance_dummy_black_tx"};
  TextureFromPool dummy_result_tx_ = {"dummy_result_tx"};
  GPUTexture *renderbuf_depth_view_ = nullptr;
 
  RaytraceEEVEE ray_tracing_options_;
  int fast_gi_ray_count_ = 0;
  int fast_gi_step_count_ = 0;
  bool fast_gi_ao_only_ = 0;
 
  RaytraceEEVEE_Method tracing_method_ = RAYTRACE_EEVEE_METHOD_PROBE;
 
  RayTraceData &data_;
 
 public:
  RayTraceModule(Instance &inst, RayTraceData &data) : inst_(inst), data_(data){};
 
  void init();
 
  void sync();
 
  RayTraceResult render(RayTraceBuffer &rt_buffer,
                        GPUTexture *screen_radiance_back_tx,
                        eClosureBits active_closures,
                        /* TODO(fclem): Maybe wrap these two in some other class. */
                        View &main_view,
                        View &render_view);
 
  RayTraceResult alloc_only(RayTraceBuffer &rt_buffer);
 
  RayTraceResult alloc_dummy(RayTraceBuffer &rt_buffer);
 
  void debug_pass_sync();
  void debug_draw(View &view, GPUFrameBuffer *view_fb);
 
 private:
  RayTraceResultTexture trace(int closure_index,
                              bool active_layer,
                              RaytraceEEVEE options,
                              RayTraceBuffer &rt_buffer,
                              /* TODO(fclem): Maybe wrap these two in some other class. */
                              View &main_view,
                              View &render_view);
};
 
}  // namespace blender::eevee