eevee_lightprobe.hh

Go to the documentation of this file.

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

 
#pragma once
 
#include "BLI_bit_vector.hh"
#include "BLI_map.hh"
 
#include "DNA_world_types.h"
 
#include "draw_view.hh"
 
#include "eevee_defines.hh"
#include "eevee_lightprobe_shared.hh"
#include "eevee_sync.hh"
 
namespace blender::eevee {
 
using namespace draw;
 
class Instance;
class VolumeProbeModule;
 
/* -------------------------------------------------------------------- */
 
struct SphereProbeAtlasCoord {
  int atlas_layer = -1;
  int subdivision_lvl = -1;
  int area_index = -1;

  void free()
  {
    atlas_layer = -1;
  }
 
  /* Return the area extent in pixel. */
  int area_extent(int mip_lvl = 0) const
  {
    return SPHERE_PROBE_ATLAS_RES >> (subdivision_lvl + mip_lvl);
  }
 
  /* Coordinate of the area in [0..area_count_per_dimension[ range. */
  int2 area_location() const
  {
    const int area_count_per_dimension = 1 << subdivision_lvl;
    return int2(area_index % area_count_per_dimension, area_index / area_count_per_dimension);
  }
 
  /* Coordinate of the bottom left corner of the area in [0..SPHERE_PROBE_ATLAS_RES[ range. */
  int2 area_offset(int mip_lvl = 0) const
  {
    return area_location() * area_extent(mip_lvl);
  }
 
  SphereProbeUvArea as_sampling_coord() const
  {
    SphereProbeUvArea coord;
    coord.scale = float(area_extent()) / SPHERE_PROBE_ATLAS_RES;
    coord.offset = float2(area_offset()) / SPHERE_PROBE_ATLAS_RES;
    coord.layer = atlas_layer;
    return coord;
  }
 
  SphereProbePixelArea as_write_coord(int mip_lvl) const
  {
    SphereProbePixelArea coord;
    coord.extent = area_extent(mip_lvl);
    coord.offset = area_offset(mip_lvl);
    coord.layer = atlas_layer;
    return coord;
  }

  class LocationFinder {
    BitVector<> areas_occupancy_;
    int subdivision_level_;
    /* Area count for the given subdivision level. */
    int areas_per_dimension_;
    int areas_per_layer_;
 
   public:
    LocationFinder(int allocated_layer_count, int subdivision_level);
 
    /* Mark space to be occupied by the given probe_data. */
    void mark_space_used(const SphereProbeAtlasCoord &coord);
 
    SphereProbeAtlasCoord first_free_spot() const;
 
    void print_debug() const;
  };
};

 
struct LightProbe {
  bool used = false;
  bool initialized = false;
  /* NOTE: Might be not needed if depsgraph updates work as intended. */
  bool updated = false;
  bool viewport_display = false;
  float viewport_display_size = 0.0f;
};
 
struct VolumeProbe : public LightProbe, VolumeProbeData {
  float4x4 object_to_world;
  float4x4 world_to_object;
  const LightProbeObjectCache *cache = nullptr;
  Vector<IrradianceBrickPacked> bricks;
  bool do_update;
  int grid_index;
  float surfel_density;
  float validity_threshold;
  float dilation_threshold;
  float dilation_radius;
  float intensity;
};
 
struct SphereProbe : public LightProbe, SphereProbeData {
  float volume;
  bool do_render = true;
  bool use_for_render = false;
  float2 clipping_distances;
  SphereProbeAtlasCoord atlas_coord;
};
 
struct PlanarProbe : public LightProbe, PlanarProbeData {
  /* Copy of object matrices. */
  float4x4 plane_to_world;
  float4x4 world_to_plane;
  /* Offset to the clipping plane in the normal direction. */
  float clipping_offset;
  /* Index in the resource array. */
  int resource_index;
 
 public:
  void set_view(const draw::View &view, int layer_id);

  float4 reflection_clip_plane_get()
  {
    return float4(-normal, math::dot(normal, plane_to_world.location()) - clipping_offset);
  }
 
 private:
  float4x4 reflection_matrix_get()
  {
    return plane_to_world * math::from_scale<float4x4>(float3(1, 1, -1)) * world_to_plane;
  }
};
 
class LightProbeModule {
  friend class IrradianceBake;
  friend class VolumeProbeModule;
  friend class PlanarProbeModule;
  friend class SphereProbeModule;
  friend class BackgroundPipeline;
 
 private:
  Instance &inst_;

  Map<ObjectKey, VolumeProbe> volume_map_;
  Map<ObjectKey, SphereProbe> sphere_map_;
  Map<ObjectKey, PlanarProbe> planar_map_;
  /* World probe is stored separately. */
  SphereProbe world_sphere_;
  bool volume_update_;
  bool sphere_update_;
  bool planar_update_;
  bool auto_bake_enabled_;
 
  eLightProbeResolution sphere_object_resolution_ = LIGHT_PROBE_RESOLUTION_128;
 
 public:
  LightProbeModule(Instance &inst);
  ~LightProbeModule() {};
 
  void init();
 
  void begin_sync();
  void sync_probe(const Object *ob, ObjectHandle &handle);
  void sync_world(const ::World *world, bool has_update);
  void end_sync();
 
 private:
  void sync_sphere(const Object *ob, ObjectHandle &handle);
  void sync_volume(const Object *ob, ObjectHandle &handle);
  void sync_planar(const Object *ob, ObjectHandle &handle);

  int sphere_layer_count() const;

  SphereProbeAtlasCoord find_empty_atlas_region(int subdivision_level) const;
};
 
}  // namespace blender::eevee