eevee_light.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2021 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_bitmap.h"
#include "BLI_vector.hh"
#include "DNA_light_types.h"
 
#include "eevee_camera.hh"
#include "eevee_sampling.hh"
#include "eevee_shader.hh"
#include "eevee_shader_shared.hh"
#include "eevee_sync.hh"
 
namespace blender::eevee {
 
class Instance;
class ShadowModule;
 
/* -------------------------------------------------------------------- */
struct Light : public LightData, NonCopyable {
 public:
  bool initialized = false;
  bool used = false;
 
  ShadowDirectional *directional = nullptr;
  ShadowPunctual *punctual = nullptr;
 
 public:
  Light()
  {
    /* Avoid valgrind warning. */
    this->type = LIGHT_SUN;
  }
 
  /* Only used for debugging. */
#ifndef NDEBUG
  Light(Light &&other)
  {
    *static_cast<LightData *>(this) = other;
    this->initialized = other.initialized;
    this->used = other.used;
    this->directional = other.directional;
    this->punctual = other.punctual;
    other.directional = nullptr;
    other.punctual = nullptr;
  }
 
  ~Light()
  {
    BLI_assert(directional == nullptr);
    BLI_assert(punctual == nullptr);
  }
#endif
 
  void sync(ShadowModule &shadows,
            float4x4 object_to_world,
            char visibility_flag,
            const ::Light *la,
            const LightLinking *light_linking,
            float threshold);
 
  void shadow_ensure(ShadowModule &shadows);
  void shadow_discard_safe(ShadowModule &shadows);
 
  void debug_draw();
 
 private:
  float shadow_lod_min_get(const ::Light *la);
  float shadow_shape_size_get(const ::Light *la);
  float attenuation_radius_get(const ::Light *la, float light_threshold, float light_power);
  void shape_parameters_set(const ::Light *la,
                            const float3 &scale,
                            const float3 &z_axis,
                            float threshold,
                            bool do_jitter);
  float shape_radiance_get();
  float point_radiance_get();
};
 
/* -------------------------------------------------------------------- */
class LightModule {
  friend ShadowModule;
 
 private:
  /* Keep tile count reasonable for memory usage and 2D culling performance. */
  static constexpr uint max_memory_threshold = 32 * 1024 * 1024; /* 32 MiB */
  static constexpr uint max_word_count_threshold = max_memory_threshold / sizeof(uint);
  static constexpr uint max_tile_count_threshold = 8192;
 
  Instance &inst_;
 
  Map<ObjectKey, Light> light_map_;
  ObjectKey world_sunlight_key;
  LightDataBuf light_buf_ = {"Lights_no_cull"};
  float light_threshold_ = 0.01f;
  bool use_scene_lights_ = false;
  bool use_sun_lights_ = false;
  int sun_lights_len_ = 0;
  int local_lights_len_ = 0;
  int lights_len_ = 0;
 
  LightDataBuf culling_light_buf_ = {"Lights_culled"};
  LightCullingDataBuf culling_data_buf_ = {"LightCull_data"};
  LightCullingZdistBuf culling_zdist_buf_ = {"LightCull_zdist"};
  LightCullingKeyBuf culling_key_buf_ = {"LightCull_key"};
  LightCullingZbinBuf culling_zbin_buf_ = {"LightCull_zbin"};
  LightCullingTileBuf culling_tile_buf_ = {"LightCull_tile"};
  PassSimple culling_ps_ = {"LightCulling"};
  uint total_word_count_ = 0;
  bool view_is_flipped_ = false;
 
  PassSimple update_ps_ = {"LightUpdate"};
 
  PassSimple debug_draw_ps_ = {"LightCulling.Debug"};
 
 public:
  LightModule(Instance &inst) : inst_(inst){};
  ~LightModule();
 
  void begin_sync();
  void sync_light(const Object *ob, ObjectHandle &handle);
  void end_sync();
 
  void set_view(View &view, const int2 extent);
 
  void debug_draw(View &view, GPUFrameBuffer *view_fb);
 
  template<typename PassType> void bind_resources(PassType &pass)
  {
    pass.bind_ssbo(LIGHT_CULL_BUF_SLOT, &culling_data_buf_);
    pass.bind_ssbo(LIGHT_BUF_SLOT, &culling_light_buf_);
    pass.bind_ssbo(LIGHT_ZBIN_BUF_SLOT, &culling_zbin_buf_);
    pass.bind_ssbo(LIGHT_TILE_BUF_SLOT, &culling_tile_buf_);
  }
 
 private:
  void culling_pass_sync();
  void update_pass_sync();
  void debug_pass_sync();
};
 
}  // namespace blender::eevee