27 if (!is_directional) {
28 float light_radius =
light.local.local.shape_radius;
36 float r_sqr =
square(light_radius);
39 power = 2.0f / (d_sqr + r_sqr + d *
sqrt(d_sqr + r_sqr));
41 if (
light.type == LIGHT_RECT ||
light.type == LIGHT_ELLIPSE) {
49#define VOLUMETRIC_SHADOW_MAX_STEP 128.0f
54 const bool is_directional,
135 float clamp_indirect = uni.
uniform_buf.clamp.volume_indirect;
166 float visibility = attenuation;
233 float offset = sampling.rng_1D_get(SAMPLING_VOLUME_W);
236 uni.uniform_buf.volumes.inv_tex_size;
243 float phase_weight =
imageLoadFast(props.in_phase_weight_img, froxel).r;
245 float s_anisotropy = phase /
max(1.0f, phase_weight);
255 .anisotropy = s_anisotropy,
258 float2 pixel = ((
float2(froxel.xy) + 0.5f) * uni.uniform_buf.volumes.inv_tex_size.xy) *
259 uni.uniform_buf.volumes.main_view_extent;
266 float3 indirect_radiance = srt.volume_lightprobe_eval(sampling,
P,
V, s_anisotropy).xyz;
268 direct_radiance *= s_scattering;
269 indirect_radiance *= s_scattering;
271 float clamp_direct = uni.uniform_buf.clamp.volume_direct;
272 float clamp_indirect = uni.uniform_buf.clamp.volume_indirect;
276 direct_radiance *= uni.uniform_buf.clamp.direct_scale;
277 indirect_radiance *= uni.uniform_buf.clamp.indirect_scale;
279 scattering += direct_radiance + indirect_radiance;
281 if (uni.uniform_buf.volumes.history_opacity > 0.0f) {
284 if (uvw_history.
x != -1.0f) {
285 float3 scattering_history =
texture(srt.scattering_history_tx, uvw_history).rgb;
286 float3 extinction_history =
texture(srt.extinction_history_tx, uvw_history).rgb;
287 scattering =
mix(scattering, scattering_history, uni.uniform_buf.volumes.history_opacity);
288 extinction =
mix(extinction, extinction_history, uni.uniform_buf.volumes.history_opacity);
294 scattering =
float3(0.0f);
295 extinction =
float3(0.0f);
332 uni.uniform_buf.volumes.inv_tex_size;
338 float orig_ray_len = 1.0f;
339 if (uses_radial_depth) {
345 prev_ray_len =
length(view_cell);
346 orig_ray_len = prev_ray_len / view_cell.
z;
349 prev_ray_len = view_cell.
z;
352 for (
int i = 0; i <= uni.uniform_buf.volumes.tex_size.z; i++) {
359 if (uses_radial_depth) {
361 uni, view, (
float(i) + 1.0f) * uni.uniform_buf.volumes.inv_tex_size.z);
362 step_len =
abs(ray_len - prev_ray_len);
363 prev_ray_len = ray_len;
367 uni, view, (
float(i) + 1.0f) * uni.uniform_buf.volumes.inv_tex_size.z);
368 float ray_len = orig_ray_len * cell_depth;
371 step_len =
abs(ray_len - prev_ray_len);
372 prev_ray_len = ray_len;
374 float3 froxel_transmittance =
exp(-extinction * step_len);
380 float3 froxel_opacity = 1.0f - froxel_transmittance;
381 float3 froxel_step_opacity = froxel_opacity *
safe_rcp(extinction);
388 froxel_step_opacity =
mix(froxel_step_opacity,
float3(step_len), is_invalid_extinction);
391 froxel_scattering = froxel_scattering * froxel_step_opacity;
394 scattering += transmittance * froxel_scattering;
395 transmittance *= froxel_transmittance;
426 float2 uvs = frag_co.xy * uni.uniform_buf.volumes.main_view_extent_inv;
434 render_passes.store_color(
441 .light_closure_count_transmit = 1});
445 .light_closure_count_transmit = 1});
448 .light_closure_count_transmit = 1});
452 .light_closure_count_transmit = 1});
float line_unit_box_intersect_dist_safe(float3 line_origin, float3 line_direction)
#define VOLUME_GROUP_SIZE
#define VOLUME_INTEGRATION_GROUP_SIZE
#define LIGHT_ATTENUATION_THRESHOLD
float light_attenuation_volume(LightData light, const bool is_directional, LightVector lv)
#define VOLUMETRIC_SHADOW_MAX_STEP
SphericalHarmonicL1< float4 > volume_phase_function_as_sh_L1(float3 V, float g)
float volume_z_to_view_z(const eevee::Uniform &uni, const ViewMatrices view, float z)
float3 volume_view_to_jitter(const eevee::Uniform &uni, const ViewMatrices view, float3 vP)
float3 volume_jitter_to_view(const eevee::Uniform &uni, const ViewMatrices view, float3 coord)
float volume_phase_function(float3 V, float3 L, float g)
float volume_froxel_jitter(int2 froxel, float offset)
float3 volume_history_uvw_get(const eevee::Uniform &uni, const ViewMatrices view, int3 froxel)
bool volume_uses_radial_depth(const eevee::Uniform &uni)
#define image(slot, qualifiers, format)
#define compilation_constant
#define global_invocation_id
VecBase< bool, D > greaterThanEqual(VecOp< T, D >, VecOp< T, D >) RET
bool any(VecOp< bool, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
float distance(float, float) RET
VecBase< bool, D > equal(VecOp< T, D >, VecOp< T, D >) RET
float length(VecOp< float, D >) RET
ImageBase< float, 3 > image3D
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
TEX_TEMPLATE DataVec texelFetch(T, IntCoord, int) RET
SamplerBase< float, 3 > sampler3D
void fullscreen_vertex(int vertex_id, float4 &out_position)
float reduce_max(float2 a)
ccl_device_inline float2 power(const float2 v, const float e)
float3 brightness_clamp_max(float3 color, float limit)
template void foreach_visible< volume::LightEvalCtx, volume::Scatter >(const LightRenderData &, float2, float, volume::LightEvalCtx &, volume::Scatter &)
float power_get(LightData light, LightingType type)
void foreach_visible(const LightRenderData &srt, float2 pixel, float linear_view_z, CallbackT &cb, ResourceT &res)
void resolve_frag(const Uniform &uni, const UnifiedVolumeData &volumes, RenderPassOutput &render_passes, const HiZ &hiz, const float4 frag_co, FragOut &out_frag)
PipelineGraphic resolve(resolve_vert, resolve_frag, LightEvalConstants{.light_closure_count_reflect=1,.light_closure_count_transmit=1})
void resolve_vert(const int vert_id, float4 &out_position)
PipelineCompute scatter_with_lights(scatter_main, ScatterConstants{.use_volume_light=true}, LightEvalConstants{.light_closure_count_reflect=1,.light_closure_count_transmit=1})
void scatter_main(Scatter &srt, const Uniform &uni, const draw::View &views, const Sampling &sampling, UnifiedVolumeProperties &props, const uint3 global_id)
float3 volume_light(LightData light, const bool is_directional, LightVector lv)
PipelineCompute integration(integration_main, LightEvalConstants{.light_closure_count_reflect=1,.light_closure_count_transmit=1})
PipelineCompute scatter(scatter_main, ScatterConstants{.use_volume_light=false}, LightEvalConstants{.light_closure_count_reflect=1,.light_closure_count_transmit=1})
void integration_main(Integrate &srt, const draw::View &views, const Uniform &uni, const uint3 global_id)
float3 volume_shadow(const Uniform &uni, const ViewMatrices &view, LightData, const bool is_directional, float3 P, LightVector lv, sampler3D extinction_tx)
SphericalHarmonicL1< float4 > clamp_energy(SphericalHarmonicL1< float4 > sh, float clamp_value)
float4 dot(SphericalHarmonicL1< float4 > a, SphericalHarmonicL1< float4 > b)
static LightVector get_shape_closest(LightData light, const bool is_directional, float3 P)
bool is_perspective() const
float3 point_world_to_view(float3 P) const
float3 point_ndc_to_world(float3 ssP) const
float3 point_world_to_ndc(float3 P) const
float3 point_view_to_world(float3 vP) const
float3 world_incident_vector(float3 P) const
ViewMatrices get(uint view_id) const
SphericalHarmonicL1< float4 > sample_probe_no_bias(const Sampling &sampling, float3 P) const
float shadow_sample(const bool is_directional, LightData light, float3 P) const
image3D out_scattering_img
sampler3D in_scattering_tx
sampler3D in_extinction_tx
image3D out_transmittance_img
void eval_directional(Scatter &srd, uint, LightData light)
void eval_local(Scatter &srd, uint, LightData light)
float3 light_eval_single(Scatter &srt, LightData light, const bool is_directional)
const bool use_volume_light
LightprobeVolumeRenderData lightprobe_volume_data
image3D out_extinction_img
ShadowRenderData shadow_data
float3 volume_lightprobe_eval(const Sampling &sampling, float3 P, float3 V, float s_anisotropy)
image3D out_scattering_img
LightRenderData light_data
sampler3D extinction_history_tx
ScatterConstants constants
sampler3D scattering_history_tx
CCL_NAMESPACE_BEGIN struct Window V