eevee_lightprobe_shared.hh

Go to the documentation of this file.

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

 
#pragma once
 
#include "GPU_shader_shared_utils.hh"
 
#include "eevee_camera_shared.hh"
 
#ifndef GPU_SHADER
namespace blender::eevee {
#endif
 
/* -------------------------------------------------------------------- */
 
struct ReflectionProbeLowFreqLight {
  packed_float3 direction;
  float ambient;
};
BLI_STATIC_ASSERT_ALIGN(ReflectionProbeLowFreqLight, 16)
 
enum LightProbeShape : uint32_t {
  SHAPE_ELIPSOID = 0u,
  SHAPE_CUBOID = 1u,
};
 
/* Sampling coordinates using UV space. */
struct SphereProbeUvArea {
  /* Offset in UV space to the start of the sampling space of the octahedron map. */
  float2 offset;
  /* Scaling of the squared UV space of the octahedron map. */
  float scale;
  /* Layer of the atlas where the octahedron map is stored. */
  float layer;
};
BLI_STATIC_ASSERT_ALIGN(SphereProbeUvArea, 16)
 
/* Pixel read/write coordinates using pixel space. */
struct SphereProbePixelArea {
  /* Offset in pixel space to the start of the writing space of the octahedron map.
   * Note that the writing space is not the same as the sampling space as we have borders. */
  int2 offset;
  /* Size of the area in pixel that is covered by this probe mip-map. */
  int extent;
  /* Layer of the atlas where the octahedron map is stored. */
  int layer;
};
BLI_STATIC_ASSERT_ALIGN(SphereProbePixelArea, 16)
 

struct SphereProbeData {
  float3x4 world_to_probe_transposed;
 
  packed_float3 location;
  float parallax_distance;
  LightProbeShape parallax_shape;
  LightProbeShape influence_shape;
  float influence_scale;
  float influence_bias;
 
  SphereProbeUvArea atlas_coord;

  ReflectionProbeLowFreqLight low_freq_light;
};
BLI_STATIC_ASSERT_ALIGN(SphereProbeData, 16)
 

struct SphereProbeDisplayData {
  int probe_index;
  float display_size;
  float _pad0;
  float _pad1;
};
BLI_STATIC_ASSERT_ALIGN(SphereProbeDisplayData, 16)
 
/* Used for sphere probe spherical harmonics extraction. Output one for each thread-group
 * and do a sum afterward. Reduces bandwidth usage. */
struct SphereProbeHarmonic {
  float4 L0_M0;
  float4 L1_Mn1;
  float4 L1_M0;
  float4 L1_Mp1;
};
BLI_STATIC_ASSERT_ALIGN(SphereProbeHarmonic, 16)
 
struct SphereProbeSunLight {
  float4 direction;
  packed_float3 radiance;
  float _pad0;
};
BLI_STATIC_ASSERT_ALIGN(SphereProbeSunLight, 16)
 

 
/* -------------------------------------------------------------------- */
 
struct PlanarProbeData {
  float4x4 viewmat;
  float4x4 winmat;
  float4x4 wininv;
  float3x4 world_to_object_transposed;
  packed_float3 normal;
  int layer_id;
};
BLI_STATIC_ASSERT_ALIGN(PlanarProbeData, 16)
 

struct PlanarProbeDisplayData {
  float4x4 plane_to_world;
  int probe_index;
  float _pad0;
  float _pad1;
  float _pad2;
};
BLI_STATIC_ASSERT_ALIGN(PlanarProbeDisplayData, 16)
 

 
/* -------------------------------------------------------------------- */
 
struct VolumeProbeData {
  float3x4 world_to_grid_transposed;
  packed_int3 grid_size_padded;
  int brick_offset;
  float normal_bias;
  float view_bias;
  float facing_bias;
  int _pad1;
};
BLI_STATIC_ASSERT_ALIGN(VolumeProbeData, 16)
 
struct IrradianceBrick {
  /* Offset in pixel to the start of the data inside the atlas texture. */
  uint2 atlas_coord;
};

#define IrradianceBrickPacked uint
 
static inline IrradianceBrickPacked irradiance_brick_pack(IrradianceBrick brick)
{
  uint2 data = (uint2(brick.atlas_coord) & 0xFFFFu) << uint2(0u, 16u);
  IrradianceBrickPacked brick_packed = data.x | data.y;
  return brick_packed;
}
 
static inline IrradianceBrick irradiance_brick_unpack(IrradianceBrickPacked brick_packed)
{
  IrradianceBrick brick;
  brick.atlas_coord = (uint2(brick_packed) >> uint2(0u, 16u)) & uint2(0xFFFFu);
  return brick;
}

 
/* -------------------------------------------------------------------- */
 
struct SurfelRadiance {
  /* Actually stores radiance and world (sky) visibility. Stored normalized. */
  float4 front;
  float4 back;
  /* Accumulated weights per face. */
  float front_weight;
  float back_weight;
  float _pad0;
  float _pad1;
};
BLI_STATIC_ASSERT_ALIGN(SurfelRadiance, 16)
 
struct Surfel {
  packed_float3 position;
  int prev;
  packed_float3 normal;
  int next;
  packed_float3 albedo_front;
  float ray_distance;
  packed_float3 albedo_back;
  int cluster_id;
  bool32_t double_sided;
  uint receiver_light_set;
  int list_id;
  int index_in_sorted_list;
  SurfelRadiance radiance_direct;
  SurfelRadiance radiance_indirect[2];
};
BLI_STATIC_ASSERT_ALIGN(Surfel, 16)
 
struct CaptureInfoData {
  packed_int3 irradiance_grid_size;
  bool32_t do_surfel_output;
  bool32_t do_surfel_count;
  uint surfel_len;
  float sample_count;
  float sample_index;
  float4x4 irradiance_grid_local_to_world;
  float4x4 irradiance_grid_world_to_local;
  float4x4 irradiance_grid_world_to_local_rotation;
  int scene_bound_x_min;
  int scene_bound_y_min;
  int scene_bound_z_min;
  int scene_bound_x_max;
  int scene_bound_y_max;
  int scene_bound_z_max;
  /* Max intensity a ray can have. */
  float clamp_direct;
  float clamp_indirect;
  float _pad1;
  float _pad2;
  float min_distance_to_surface;
  float max_virtual_offset;
  float surfel_radius;
  bool32_t capture_world_direct;
  bool32_t capture_world_indirect;
  bool32_t capture_visibility_direct;
  bool32_t capture_visibility_indirect;
  bool32_t capture_indirect;
  bool32_t capture_emission;
  int _pad0;
  /* World light probe atlas coordinate. */
  SphereProbeUvArea world_atlas_coord;
};
BLI_STATIC_ASSERT_ALIGN(CaptureInfoData, 16)
 
struct SurfelListInfoData {
  int2 ray_grid_size;
  int list_max;
 
  int list_prefix_sum;
};
BLI_STATIC_ASSERT_ALIGN(SurfelListInfoData, 16)
 

 
#ifndef GPU_SHADER
}  // namespace blender::eevee
#endif