eevee_lightprobe_sphere.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_world_types.h"
 
#include "draw_pass.hh"
 
#include "eevee_lightprobe.hh"
#include "eevee_lightprobe_shared.hh"
 
namespace blender::eevee {
 
using namespace draw;
 
class Instance;
class CaptureView;
 
/* -------------------------------------------------------------------- */
 
using SphereProbeDataBuf = draw::UniformArrayBuffer<SphereProbeData, SPHERE_PROBE_MAX>;
using SphereProbeDisplayDataBuf = draw::StorageArrayBuffer<SphereProbeDisplayData>;
 
class SphereProbeModule {
  friend LightProbeModule;
  /* Capture View requires access to the probe texture for frame-buffer configuration. */
  friend class CaptureView;
  /* Instance requires access to #update_probes_this_sample_ */
  friend class Instance;
 
 private:
  Instance &instance_;
  SphereProbeDataBuf data_buf_;

  Texture probes_tx_ = {"Probes"};

  PassSimple remap_ps_ = {"Probe.CubemapToOctahedral"};
  PassSimple sum_sh_ps_ = {"Probe.SumSphericalHarmonics"};
  PassSimple sum_sun_ps_ = {"Probe.SumSunlight"};
  PassSimple select_ps_ = {"Probe.Select"};
  PassSimple convolve_ps_ = {"Probe.Convolve"};
  gpu::Texture *convolve_input_ = nullptr;
  gpu::Texture *convolve_output_ = nullptr;
  int convolve_lod_ = 0;
  /* True if we extract spherical harmonic during `remap_ps_`. */
  bool extract_sh_ = false;
 
  int3 dispatch_probe_pack_ = int3(1);
  int3 dispatch_probe_convolve_ = int3(1);
  int3 dispatch_probe_select_ = int3(1);

  Texture cubemap_tx_ = {"Probe.Cubemap"};
  int probe_index_ = 0;
  SphereProbeUvArea probe_sampling_coord_;
  SphereProbePixelArea probe_write_coord_;
  SphereProbePixelArea probe_read_coord_;
  SphereProbeUvArea world_sampling_coord_;
  int lightprobe_sphere_count_ = 0;

  StorageArrayBuffer<SphereProbeHarmonic, SPHERE_PROBE_MAX_HARMONIC, true>
      tmp_spherical_harmonics_ = {"tmp_spherical_harmonics_"};
  StorageBuffer<SphereProbeHarmonic, true> spherical_harmonics_ = {"spherical_harmonics_"};

  StorageArrayBuffer<SphereProbeSunLight, SPHERE_PROBE_MAX_HARMONIC, true> tmp_sunlight_ = {
      "tmp_sunlight_"};

  bool update_probes_next_sample_ = false;
  bool update_probes_this_sample_ = false;
  bool do_world_irradiance_update = true;

  bool do_display_draw_ = false;
  SphereProbeDisplayDataBuf display_data_buf_;
  PassSimple viewport_display_ps_ = {"ProbeSphereModule.Viewport Display"};
 
 public:
  SphereProbeModule(Instance &instance) : instance_(instance) {};
 
  void init();
  void begin_sync();
  void end_sync();
 
  void viewport_draw(View &view, gpu::FrameBuffer *view_fb);
 
  template<typename PassType> void bind_resources(PassType &pass)
  {
    pass.bind_texture(SPHERE_PROBE_TEX_SLOT, &probes_tx_);
    pass.bind_ubo(SPHERE_PROBE_BUF_SLOT, &data_buf_);
  }

  void set_view(View &view);

  int probe_render_extent() const;
 
  StorageBuffer<SphereProbeHarmonic, true> &spherical_harmonics_buf()
  {
    return spherical_harmonics_;
  }
 
 private:
  /* Return the subdivision level for the requested probe resolution.
   * Result is safely clamped to max resolution. */
  int subdivision_level_get(const eLightProbeResolution probe_resolution)
  {
    return max_ii(SPHERE_PROBE_ATLAS_MAX_SUBDIV - int(probe_resolution), 0);
  }

  bool ensure_atlas();

  void ensure_cubemap_render_target(int resolution);
 
  struct UpdateInfo {
    float3 probe_pos;
    int cube_target_extent;
 
    float2 clipping_distances;
 
    SphereProbeAtlasCoord atlas_coord;
 
    bool do_render;
  };
 
  UpdateInfo update_info_from_probe(SphereProbe &probe);

  std::optional<UpdateInfo> world_update_info_pop();
  std::optional<UpdateInfo> probe_update_info_pop();

  void remap_to_octahedral_projection(const SphereProbeAtlasCoord &atlas_coord,
                                      bool extract_spherical_harmonics);
 
  void sync_display(Vector<SphereProbe *> &probe_active);
};

 
}  // namespace blender::eevee