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_gpu_wrapper.hh"
#include "DRW_render.hh"
 
#include "eevee_raytrace_shared.hh"
 
namespace blender::eevee {
 
class Instance;
 
using RayTraceTileBuf = draw::StorageArrayBuffer<uint, 1024, true>;
 
/* -------------------------------------------------------------------- */

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;
 
  gpu::Texture *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::TextureFormat::SFLOAT_16_16_16_16, is_dummy ? int2(1) : extent, usage_rw))
    {
      radiance_feedback_tx.clear(float4(0.0f));
    }
    return radiance_feedback_tx;
  }
};

class RayTraceResultTexture {
 private:
  TextureFromPool *result_ = nullptr;
  gpu::Texture *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 gpu::Texture *() const
  {
    BLI_assert(tx_ != nullptr);
    return tx_;
  }
 
  gpu::Texture **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_"};
  gpu::Texture *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_"};
  gpu::Texture *denoised_spatial_tx_ = nullptr;
  gpu::Texture *denoised_temporal_tx_ = nullptr;
  gpu::Texture *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_"};
  gpu::Texture *radiance_history_tx_ = nullptr;
  gpu::Texture *variance_history_tx_ = nullptr;
  gpu::Texture *tilemask_history_tx_ = nullptr;
  gpu::Texture *screen_radiance_front_tx_ = nullptr;
  gpu::Texture *screen_radiance_back_tx_ = nullptr;
 
  Texture radiance_dummy_black_tx_ = {"radiance_dummy_black_tx"};
  TextureFromPool dummy_result_tx_ = {"dummy_result_tx"};
  gpu::Texture *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_ = false;
 
  bool use_raytracing_ = false;
 
  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,
                        gpu::Texture *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, gpu::FrameBuffer *view_fb);
 
  bool use_raytracing() const
  {
    return use_raytracing_;
  }
 
  bool use_fast_gi() const
  {
    return use_raytracing() && ray_tracing_options_.trace_max_roughness < 1.0f;
  }
 
 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