51 state.ray_step_mul = -1.0f /
float(sample_count);
52 state.ray_step_bias = 1.0f + step_offset *
state.ray_step_mul;
77 bool is_behind_occluder = samp.
occluder.
y > 1e-6f;
94 float delta_time =
state.ray_time -
state.occluder_history.x;
95 float extrapolated_occluder_y =
abs(
state.occluder_history.y) +
96 state.occluder_slope * delta_time;
99 state.hit = extrapolated_occluder_y < 0.0f;
106 const float min_slope =
tan(
M_PI * 0.25f);
107 state.occluder_slope =
max(min_slope,
abs(delta.
y / delta.
x));
120template<
typename ShadowRayType>
127 for (
int i = 0; (i <= sample_count) && (i <= SHADOW_MAX_STEP) && (
state.hit ==
false); i++) {
155 LightData
light,
float2 random_2d,
float3 lP,
float texel_radius,
float soft_shadow_scale)
159 float dist_to_near_plane = -lP.
z - clip_near;
161 float max_tracing_distance = texel_radius *
float(SHADOW_PAGE_RES << SHADOW_TILEMAP_LOD);
162 float max_tracing_angle_cos =
cos_from_tan(max_tracing_distance / dist_to_near_plane);
164 float shadow_angle_cos =
max(
light.sun.shadow_angle_cos, max_tracing_angle_cos);
174 direction *=
max(texel_radius, dist_to_near_plane / direction.
z);
198 float3 occluder_pos =
float3(ray_pos.xy, -depth - clip_near);
235 float soft_shadow_scale)
237 if (
light.type == LIGHT_RECT) {
238 random_2d = random_2d * 2.0f - 1.0f;
243 random_2d *= soft_shadow_scale;
246 float shape_radius =
light.spot.local.shadow_radius;
249 shape_radius =
max(0.00002f, shape_radius);
251 float3 point_on_light_shape;
252 if (is_area_light(
light.type)) {
253 random_2d *=
light.area.size *
light.area.shadow_scale;
255 point_on_light_shape =
float3(random_2d, 0.0f);
264 if (is_sphere_light(
light.type)) {
267 random_2d *= shape_radius;
269 point_on_light_shape = right * random_2d.
x + up * random_2d.
y;
274 point_on_light_shape =
float3(1e-6f);
277 float3 direction = point_on_light_shape - lP;
279 float3 shadow_position =
light.local.local.shadow_position;
289 ray.
origin = lP - shadow_position;
290 ray.
direction = direction + shadow_position * soft_shadow_scale;
306 float radial_occluder_depth = srd.
read_depth(coord);
307 float3 occluder_pos = receiver_pos * (radial_occluder_depth /
length(receiver_pos));
315 samp.
skip_sample = (radial_occluder_depth == -1.0f);
345 float3 cone_sample =
float3(disk_sample, distance_to_center * cone_height);
362 const bool is_directional,
369 if (is_directional) {
371 lP -=
light.position();
372 LightSunData sun =
light.sun;
385 scale =
exp2(
float(sun.clipmap_lod_min));
392 lP -=
light.local.local.shadow_position;
407 constexpr float texel_radius =
M_SQRT2 / SHADOW_MAP_MAX_RES;
408 return texel_radius *
scale;
425 const float max_angular_quantization_error = 0.534f;
426 const float max_error_cos_inv = 1.0f /
cos(max_angular_quantization_error);
429 const float max_error_adjacent_polygon = 0.195f;
430 float biased_offset = slope_offset * max_error_cos_inv + max_error_adjacent_polygon;
432 return biased_offset * texel_radius;
437 float shadow_terminator_normal_offset,
438 float shadow_terminator_geometry_offset)
440 const float offset_cutoff = shadow_terminator_geometry_offset;
442 if (shadow_terminator_geometry_offset == 0.0) {
448 return offset_amount * shadow_terminator_normal_offset;
457 const bool is_directional,
458 const bool is_transmission,
459 bool is_translucent_with_thickness,
465 float terminator_normal_offset,
466 float terminator_geometry_offset,
467 float soft_shadow_scale,
477 random_pcf_2d = random_shadow_3d.xy;
485 float distance_to_shadow;
489 if (is_directional) {
493 L =
light.position() +
light.local.local.shadow_position -
P;
497 bool is_facing_light = (
dot(Ng,
L) > 0.0f);
499 float3 N_bias = (is_transmission && !is_facing_light) ?
reflect(Ng,
L) : Ng;
505 if (is_transmission && !is_facing_light) {
527 lNg = (is_transmission) ? -lNg : lNg;
529 lNg = (is_transmission && is_translucent_with_thickness) ?
float3(0.0f) : lNg;
531 float surface_hit = 0.0f;
532 for (
int ray_index = 0; ray_index < ray_count && ray_index < SHADOW_MAX_RAY; ray_index++) {
534 random_shadow_3d.xy);
537 if (is_directional) {
539 light, random_ray_2d, lP, texel_radius, soft_shadow_scale);
544 light, random_ray_2d, lP, soft_shadow_scale);
548 surface_hit +=
float(has_hit);
551 return saturate(1.0f - surface_hit /
float(ray_count));
ccl_device_inline float cos_theta(const float3 w)
ccl_device_inline float sin_theta(const float3 w)
void make_orthonormal_basis(float3 N, float3 &T, float3 &B)
#define UTIL_BLUE_NOISE_LAYER
float light_sphere_disk_radius(float sphere_radius, float distance_to_sphere)
float3 light_world_to_local_point(LightData light, float3 point)
float3 light_world_to_local_direction(LightData light, float3 L)
bool clip_ray(float3 &start, float3 &end, const float3 direction, const float max_distance, const float4 frustum_planes[6])
float2 sample_disk(float2 rand)
float3 sample_uniform_cone(float2 rand, float cos_angle)
float2 sample_circle(float rand)
ShadowCoordinates shadow_punctual_coordinates(LightData light, float3 lP, int face_id)
int shadow_punctual_face_index_get(float3 lL)
float shadow_punctual_pixel_ratio(LightData light, float3 lP, bool is_perspective, float distance_to_camera, float film_pixel_radius)
ShadowCoordinates shadow_directional_coordinates(LightData light, float3 lP)
float3 shadow_punctual_local_position_to_face_local(int face_id, float3 lL)
VecBase< float, D > intBitsToFloat(VecOp< int, D >) RET
VecBase< T, D > reflect(VecOp< T, D >, VecOp< T, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
constexpr T inversesqrt(T) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
constexpr T clamp(T, U, U) RET
float length(VecOp< float, D >) RET
float cos_from_tan(float t)
float sin_from_cos(float c)
float3x3 scale(float3x3 mat, float2 scale)
float3x3 from_up_axis(float3 up)
float3 spherical_interpolate(float3 a, float3 b, float t)
VecT normalize_and_get_length(VecT vector, float &out_length)
float length_squared(VecT a)
float reduce_max(float2 a)
VecT safe_normalize(VecT vector)
float3 offset_ray(float3 P, float3 Ng)
float orderedIntBitsToFloat(int int_value)
ShadowMapTracingState shadow_map_trace_init(int sample_count, float step_offset)
static constexpr float SHADOW_TRACING_INVALID_HISTORY
void shadow_map_trace_hit_check(ShadowMapTracingState &state, ShadowTracingSample samp, bool is_last_sample)
ShadowRayPunctual shadow_ray_generate_punctual(LightData light, float2 random_2d, float3 lP, float soft_shadow_scale)
ShadowTracingSample shadow_map_trace_sample(ShadowRenderData &srd, ShadowMapTracingState state, ShadowRayDirectional &ray)
float3 shadow_pcf_offset(float3 L, float3 Ng, float2 random)
float shadow_normal_offset(float3 Ng, float3 L, float texel_radius)
ShadowRayDirectional shadow_ray_generate_directional(LightData light, float2 random_2d, float3 lP, float texel_radius, float soft_shadow_scale)
float shadow_eval(ShadowRenderData &srd, LightData light, const bool is_directional, const bool is_transmission, bool is_translucent_with_thickness, float2 frag_co, Thickness thickness, float3 P, float3 Ng, float3 N, float terminator_normal_offset, float terminator_geometry_offset, float soft_shadow_scale, int ray_count, int ray_step_count)
float shadow_terminator_offset(float3 N, float3 L, float shadow_terminator_normal_offset, float shadow_terminator_geometry_offset)
bool shadow_map_trace(ShadowRenderData &srd, ShadowRayType ray, int sample_count, float step_offset)
float shadow_texel_radius_at_position(const Uniform &uni, const draw::View &views, LightData light, const bool is_directional, float3 P)
float2 hammersley_2d(T i, T sample_count)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
float4 fetch(float2 texel, float layer) const
bool is_perspective() const
float z_distance(float3 P) const
ViewMatrices get(uint view_id) const
float3 rng_3D_get(const eSamplingDimension dim) const
float2 rng_2D_get(const eSamplingDimension dim) const
float read_depth(ShadowCoordinates coord) const
ShadowRenderConstants constants