51 if (
any(
equal(local_texel,
int2(write_co.extent - 1)))) {
69 int half_size = write_co.extent >> 1;
70 int padded_size = write_co.extent - 2;
72 wrapped_texel.
x = (local_texel.
x >= half_size) ? (padded_size - local_texel.
x) : local_texel.
x;
73 wrapped_texel.
y = (local_texel.
y >= half_size) ? (padded_size - local_texel.
y) : local_texel.
y;
100 if (wrapped_texel.
x == half_size - 1) {
101 texel_clipped_solid_angle *= 2.0f;
103 if (wrapped_texel.
y == half_size - 1) {
104 texel_clipped_solid_angle *= 2.0f;
106 return texel_clipped_solid_angle;
110[[
compute,
local_size(SPHERE_PROBE_REMAP_GROUP_SIZE, SPHERE_PROBE_REMAP_GROUP_SIZE)]]
118 const uint work_group_index = num_groups.x * group_id.y + group_id.x;
119 constexpr uint group_size = uint(SPHERE_PROBE_REMAP_GROUP_SIZE * SPHERE_PROBE_REMAP_GROUP_SIZE);
125 int2 local_texel =
int2(global_id.xy);
129 float4 radiance_and_transmittance =
texture(srt.cubemap_tx, direction);
130 float3 radiance = radiance_and_transmittance.xyz;
132 float opacity = 1.0f - radiance_and_transmittance.a;
135 bool is_world =
all(
equal(srt.probe_coord_packed, srt.world_coord_packed));
136 if (!is_world && opacity != 1.0f) {
138 float2 world_uv = biased_uv * world_coord.scale + world_coord.offset;
140 radiance.rgb =
mix(world_radiance.rgb, radiance.rgb, opacity);
143 float sun_threshold = uni.uniform_buf.clamp.sun_threshold;
145 float3 radiance_sun = radiance - radiance_clamped;
146 radiance = radiance_clamped;
151 float clamp_indirect =
min(65504.0f, uni.uniform_buf.clamp.surface_indirect);
154 int3 texel =
int3(local_texel + write_coord.offset, write_coord.layer);
160 if (srt.extract_sun) {
162 srt.local_radiance[local_index] = radiance_sun.xyzz *
sample_weight;
169 for (uint i = 0; i < 10; i++) [[
unroll]] {
171 uint stride = group_size >> (i + 1u);
172 if (local_index < stride) {
173 srt.local_radiance[local_index] += srt.local_radiance[local_index + stride];
178 if (local_index == 0u) {
179 srt.out_sun[work_group_index].radiance = srt.local_radiance[0].xyz;
184 auto &local_direction = srt.local_radiance;
194 for (uint i = 0; i < 10; i++) [[
unroll]] {
196 uint stride = group_size >> (i + 1u);
197 if (local_index < stride) {
198 local_direction[local_index] += local_direction[local_index + stride];
203 if (local_index == 0u) {
204 srt.out_sun[work_group_index].direction = local_direction[0];
209 if (srt.extract_sh) {
211 srt.local_radiance[local_index] = radiance.xyzz *
sample_weight;
218 for (uint i = 0; i < 10; i++) [[
unroll]] {
220 uint stride = group_size >> (i + 1u);
221 if (local_index < stride) {
222 srt.local_radiance[local_index] += srt.local_radiance[local_index + stride];
227 if (local_index == 0u) {
233 int2 max_group_texel = local_texel +
int2(SPHERE_PROBE_REMAP_GROUP_SIZE);
242 srt.out_sh[work_group_index].L0_M0 = sh.
L0.M0;
243 srt.out_sh[work_group_index].L1_Mn1 = sh.
L1.Mn1;
244 srt.out_sh[work_group_index].L1_M0 = sh.
L1.M0;
245 srt.out_sh[work_group_index].L1_Mp1 = sh.
L1.Mp1;
257#ifdef ALWAYS_SAMPLE_CUBEMAP
259 return curr_mip_roughness;
262 constexpr float exponent = 3.0f;
264 float m_prev =
pow(prev_mip_roughness, exponent);
265 float m_curr =
pow(curr_mip_roughness, exponent);
269 float m_target = m_curr - m_prev;
271 return pow(m_target, 1.0f / exponent);
278 float m =
square(linear_roughness);
280 float cutoff_value =
mix(0.01f, 0.14f, m);
282 float half_angle_cos = 1.0f + (
log(cutoff_value) *
square(m)) / 2.0f;
298 out_direction =
normalize(out_direction);
302 float m =
square(linear_roughness);
313 return exp(2.0f * (NH - 1.0f) /
square(m));
340 int2 out_local_texel =
int2(global_id.xy);
359 out_direction =
normalize(out_direction);
363 int2 out_texel = out_texel_area.offset + out_local_texel;
365 float weight_accum = 0.0f;
369 for (
int i = 0; i < sample_count; i++) {
375#ifdef ALWAYS_SAMPLE_CUBEMAP
376 radiance =
texture(srt.cubemap_tx, in_direction);
379 float weight =
sample_weight(out_direction, in_direction, mip_roughness_clamped);
380 radiance_accum += radiance * weight;
381 weight_accum += weight;
385#ifdef USE_PIXEL_CHECKERBOARD
386 int2 a = out_texel % 2;
390 imageStore(srt.out_atlas_mip_img,
int3(out_texel, out_texel_area.layer), out_radiance);
406 constexpr uint group_size = uint(SPHERE_PROBE_SH_GROUP_SIZE);
415 uint valid_data_len = uint(srt.probe_remap_dispatch_size.x * srt.probe_remap_dispatch_size.y);
416 constexpr uint iter_count = uint(SPHERE_PROBE_MAX_HARMONIC) / group_size;
417 for (uint i = 0; i < iter_count; i++) {
418 uint
index = SPHERE_PROBE_SH_GROUP_SIZE * i + local_index;
419 if (
index >= valid_data_len) {
423 sh_sample.
L0.M0 = srt.in_sh[
index].L0_M0;
424 sh_sample.
L1.Mn1 = srt.in_sh[
index].L1_Mn1;
425 sh_sample.
L1.M0 = srt.in_sh[
index].L1_M0;
426 sh_sample.
L1.Mp1 = srt.in_sh[
index].L1_Mp1;
431 srt.local_sh_coefs[local_index][0] = sh.
L0.M0;
432 srt.local_sh_coefs[local_index][1] = sh.
L1.Mn1;
433 srt.local_sh_coefs[local_index][2] = sh.
L1.M0;
434 srt.local_sh_coefs[local_index][3] = sh.
L1.Mp1;
437 uint stride = group_size / 2;
438 for (
int i = 0; i < 10; i++) {
440 if (local_index < stride) {
441 for (
int i = 0; i < 4; i++) {
442 srt.local_sh_coefs[local_index][i] += srt.local_sh_coefs[local_index + stride][i];
449 if (local_index == 0u) {
450 srt.out_sh.L0_M0 = srt.local_sh_coefs[0][0];
451 srt.out_sh.L1_Mn1 = srt.local_sh_coefs[0][1];
452 srt.out_sh.L1_M0 = srt.local_sh_coefs[0][2];
453 srt.out_sh.L1_Mp1 = srt.local_sh_coefs[0][3];
471 constexpr uint group_size = uint(SPHERE_PROBE_SH_GROUP_SIZE);
473 SphereProbeSunLight sun;
474 sun.radiance =
float3(0.0f);
475 sun.direction =
float4(0.0f);
478 uint valid_data_len = uint(srt.probe_remap_dispatch_size.x * srt.probe_remap_dispatch_size.y);
479 constexpr uint iter_count = uint(SPHERE_PROBE_MAX_HARMONIC) / group_size;
480 for (uint i = 0; i < iter_count; i++) {
481 uint
index = SPHERE_PROBE_SH_GROUP_SIZE * i + local_index;
482 if (
index >= valid_data_len) {
485 sun.radiance += srt.in_sun[
index].radiance;
486 sun.direction += srt.in_sun[
index].direction;
490 srt.local_radiance[local_index] = sun.radiance;
491 srt.local_direction[local_index] = sun.direction;
494 uint stride = group_size / 2;
495 for (
int i = 0; i < 10; i++) {
497 if (local_index < stride) {
498 srt.local_radiance[local_index] += srt.local_radiance[local_index + stride];
499 srt.local_direction[local_index] += srt.local_direction[local_index + stride];
505 if (local_index == 0u) {
506 srt.sunlight_buf[srt.sun_id].color = srt.local_radiance[0];
512 srt.local_direction[0].xyz / srt.local_direction[0].w,
len);
516 srt.sunlight_buf[srt.sun_id].object_to_world.x =
float4(tx[0], 0.0f);
517 srt.sunlight_buf[srt.sun_id].object_to_world.y =
float4(tx[1], 0.0f);
518 srt.sunlight_buf[srt.sun_id].object_to_world.z =
float4(tx[2], 0.0f);
521 float sun_angle_cos = 2.0f *
len - 1.0f;
523 float sun_angle_tan =
sqrt(-1.0f + 1.0f /
square(sun_angle_cos));
525 float sun_radius =
clamp(sun_angle_tan, 0.001f, 20.0f);
528 float shape_power =
M_1_PI * (1.0f + 1.0f /
square(sun_radius));
529 float point_power = 1.0f;
531 srt.sunlight_buf[srt.sun_id].shape_power = shape_power;
532 srt.sunlight_buf[srt.sun_id].point_power = point_power;
533 srt.sunlight_buf[srt.sun_id].power_factor[LIGHT_DIFFUSE] = 1.0f;
534 srt.sunlight_buf[srt.sun_id].power_factor[LIGHT_SPECULAR] = 1.0f;
535 srt.sunlight_buf[srt.sun_id].power_factor[LIGHT_TRANSMISSION] = 1.0f;
536 srt.sunlight_buf[srt.sun_id].power_factor[LIGHT_VOLUME] = 1.0f;
#define SPHERE_PROBE_FORMAT
#define BSDF_ROUGHNESS_THRESHOLD
PipelineCompute eevee_lightprobe_sphere_irradiance(eevee::lightprobe::sphere::irradiance_sum)
PipelineCompute eevee_lightprobe_sphere_remap(eevee::lightprobe::sphere::remap_cubemap_to_octahedral)
PipelineCompute eevee_lightprobe_sphere_convolve(eevee::lightprobe::sphere::mip_convolve)
PipelineCompute eevee_lightprobe_sphere_sunlight(eevee::lightprobe::sphere::sun_extraction)
float3 sample_uniform_cone(float2 rand, float cos_angle)
#define local_invocation_index
#define storage(slot, qualifiers)
#define image(slot, qualifiers, format)
#define specialization_constant(default_value)
#define global_invocation_id
VecBase< bool, D > greaterThanEqual(VecOp< T, D >, VecOp< T, D >) RET
bool any(VecOp< bool, D >) RET
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
bool all(VecOp< bool, D >) RET
MatBase< R, C > transpose(MatBase< C, R >) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
VecBase< bool, D > equal(VecOp< T, D >, VecOp< T, D >) RET
constexpr T clamp(T, U, U) RET
float length(VecOp< float, D >) RET
ImageBase< float, 2, true > image2DArray
IMG_TEMPLATE void imageStore(T &, IntCoord, DataVec)
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
TEX_TEMPLATE DataVec textureLod(T, FltCoord, float) RET
SamplerBase< float, 2, false, true > sampler2DArray
SamplerBase< float, 2, true > samplerCube
float3x3 from_up_axis(float3 up)
VecT safe_normalize_and_get_length(VecT vector, float &out_length)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
float3 brightness_clamp_max(float3 color, float limit)
float quad_solid_angle(float3 A, float3 B, float3 C, float3 D)
void remap_cubemap_to_octahedral(Remap &srt, const Uniform &uni, const uint3 global_id, const uint3 group_id, const uint3 num_groups, const uint local_index)
void sun_extraction(SunExtraction &srt, const uint local_index)
void irradiance_sum(IrradianceSum &srt, const uint local_index)
float lod_to_roughness(float lod)
float roughness_from_relative_mip(float prev_mip_roughness, float curr_mip_roughness)
float sample_weight(float3 out_direction, float3 in_direction, float linear_roughness)
float3 texel_to_direction(float2 local_texel, SphereProbePixelArea texel_area, float2 &sampling_uv)
float triangle_solid_angle(float3 A, float3 B, float3 C)
float2 miplvl_scale_bias(float mip_lvl, SphereProbeUvArea uv_area, float2 uv)
void mip_convolve(Convolve &srt, const uint3 global_id)
float3x3 tangent_basis(float3 N)
float octahedral_texel_solid_angle(int2 local_texel, SphereProbePixelArea write_co)
void direction_to_uv(float3 L, float lod_min, float lod_max, SphereProbeUvArea uv_area, float2 &altas_uv_min, float2 &altas_uv_max)
float cone_cosine_from_roughness(float linear_roughness)
SphereProbePixelArea reinterpret_as_write_coord(int4 packed_coord)
SphereProbeUvArea reinterpret_as_atlas_coord(int4 packed_coord)
float2 hammersley_2d(T i, T sample_count)
SphericalHarmonicL1< float4 > add(SphericalHarmonicL1< float4 > a, SphericalHarmonicL1< float4 > b)
spherical_harmonics::BandL1< T > L1
spherical_harmonics::BandL0< T > L0
void encode_signal_sample(float3 direction, T amplitude)
const int4 write_coord_packed
image2DArray out_atlas_mip_img
const int4 read_coord_packed
sampler2DArray in_atlas_mip_tx
const int4 probe_coord_packed
float4 local_sh_coefs[SPHERE_PROBE_SH_GROUP_SIZE][4]
const int3 probe_remap_dispatch_size
SphereProbeHarmonic & out_sh
const SphereProbeHarmonic(& in_sh)[]
const int4 probe_coord_packed
float4 local_radiance[SPHERE_PROBE_REMAP_GROUP_SIZE *SPHERE_PROBE_REMAP_GROUP_SIZE]
SphereProbeHarmonic(& out_sh)[]
const int4 write_coord_packed
const int4 world_coord_packed
SphereProbeSunLight(& out_sun)[]