Clément Foucault
3cc2dc40b3
This was happening because the raytrace was not even being performed due to the tracing line being too small after frustum clipping.
273 lines
9.3 KiB
GLSL
273 lines
9.3 KiB
GLSL
|
|
#pragma BLENDER_REQUIRE(common_view_lib.glsl)
|
|
#pragma BLENDER_REQUIRE(common_math_lib.glsl)
|
|
#pragma BLENDER_REQUIRE(common_uniforms_lib.glsl)
|
|
|
|
uniform sampler2D maxzBuffer;
|
|
uniform sampler2DArray planarDepth;
|
|
|
|
#define MAX_STEP 256
|
|
|
|
float sample_depth(vec2 uv, int index, float lod)
|
|
{
|
|
#ifdef PLANAR_PROBE_RAYTRACE
|
|
if (index > -1) {
|
|
return textureLod(planarDepth, vec3(uv, index), 0.0).r;
|
|
}
|
|
else {
|
|
#endif
|
|
lod = clamp(floor(lod), 0.0, 8.0);
|
|
/* Correct UVs for mipmaping mis-alignment */
|
|
uv *= mipRatio[int(lod) + hizMipOffset];
|
|
return textureLod(maxzBuffer, uv, lod).r;
|
|
#ifdef PLANAR_PROBE_RAYTRACE
|
|
}
|
|
#endif
|
|
}
|
|
|
|
vec4 sample_depth_grouped(vec4 uv1, vec4 uv2, int index, float lod)
|
|
{
|
|
vec4 depths;
|
|
#ifdef PLANAR_PROBE_RAYTRACE
|
|
if (index > -1) {
|
|
depths.x = textureLod(planarDepth, vec3(uv1.xy, index), 0.0).r;
|
|
depths.y = textureLod(planarDepth, vec3(uv1.zw, index), 0.0).r;
|
|
depths.z = textureLod(planarDepth, vec3(uv2.xy, index), 0.0).r;
|
|
depths.w = textureLod(planarDepth, vec3(uv2.zw, index), 0.0).r;
|
|
}
|
|
else {
|
|
#endif
|
|
depths.x = textureLod(maxzBuffer, uv1.xy, lod).r;
|
|
depths.y = textureLod(maxzBuffer, uv1.zw, lod).r;
|
|
depths.z = textureLod(maxzBuffer, uv2.xy, lod).r;
|
|
depths.w = textureLod(maxzBuffer, uv2.zw, lod).r;
|
|
#ifdef PLANAR_PROBE_RAYTRACE
|
|
}
|
|
#endif
|
|
return depths;
|
|
}
|
|
|
|
float refine_isect(float prev_delta, float curr_delta)
|
|
{
|
|
/**
|
|
* Simplification of 2D intersection :
|
|
* r0 = (0.0, prev_ss_ray.z);
|
|
* r1 = (1.0, curr_ss_ray.z);
|
|
* d0 = (0.0, prev_hit_depth_sample);
|
|
* d1 = (1.0, curr_hit_depth_sample);
|
|
* vec2 r = r1 - r0;
|
|
* vec2 d = d1 - d0;
|
|
* vec2 isect = ((d * cross(r1, r0)) - (r * cross(d1, d0))) / cross(r,d);
|
|
*
|
|
* We only want isect.x to know how much stride we need. So it simplifies :
|
|
*
|
|
* isect_x = (cross(r1, r0) - cross(d1, d0)) / cross(r,d);
|
|
* isect_x = (prev_ss_ray.z - prev_hit_depth_sample.z) / cross(r,d);
|
|
*/
|
|
return saturate(prev_delta / (prev_delta - curr_delta));
|
|
}
|
|
|
|
void prepare_raycast(vec3 ray_origin,
|
|
vec3 ray_dir,
|
|
float thickness,
|
|
int index,
|
|
out vec4 ss_step,
|
|
out vec4 ss_ray,
|
|
out float max_time)
|
|
{
|
|
/* Negate the ray direction if it goes towards the camera.
|
|
* This way we don't need to care if the projected point
|
|
* is behind the near plane. */
|
|
float z_sign = -sign(ray_dir.z);
|
|
vec3 ray_end = ray_origin + z_sign * ray_dir;
|
|
|
|
/* Project into screen space. */
|
|
vec4 ss_start, ss_end;
|
|
ss_start.xyz = project_point(ProjectionMatrix, ray_origin);
|
|
ss_end.xyz = project_point(ProjectionMatrix, ray_end);
|
|
|
|
/* We interpolate the ray Z + thickness values to check if depth is within threshold. */
|
|
ray_origin.z -= thickness;
|
|
ray_end.z -= thickness;
|
|
ss_start.w = project_point(ProjectionMatrix, ray_origin).z;
|
|
ss_end.w = project_point(ProjectionMatrix, ray_end).z;
|
|
|
|
/* XXX This is a hack. A better method is welcome! */
|
|
/* We take the delta between the offsetted depth and the depth and subtract it from the ray
|
|
* depth. This will change the world space thickness appearance a bit but we can have negative
|
|
* values without worries. We cannot do this in viewspace because of the perspective division. */
|
|
ss_start.w = 2.0 * ss_start.z - ss_start.w;
|
|
ss_end.w = 2.0 * ss_end.z - ss_end.w;
|
|
|
|
ss_step = ss_end - ss_start;
|
|
max_time = length(ss_step.xyz);
|
|
ss_step = z_sign * ss_step / length(ss_step.xyz);
|
|
|
|
/* If the line is degenerate, make it cover at least one pixel
|
|
* to not have to handle zero-pixel extent as a special case later */
|
|
if (dot(ss_step.xy, ss_step.xy) < 0.00001) {
|
|
ss_step.xy = vec2(0.0, 0.0001);
|
|
}
|
|
|
|
/* Make ss_step cover one pixel. */
|
|
ss_step /= max(abs(ss_step.x), abs(ss_step.y));
|
|
ss_step *= (abs(ss_step.x) > abs(ss_step.y)) ? ssrPixelSize.x : ssrPixelSize.y;
|
|
|
|
/* Clip to segment's end. */
|
|
max_time /= length(ss_step.xyz);
|
|
/* Clipping to frustum sides. */
|
|
max_time = min(max_time, line_unit_box_intersect_dist(ss_start.xyz, ss_step.xyz));
|
|
/* Avoid no iteration. */
|
|
max_time = max(max_time, 1.0);
|
|
|
|
/* Convert to texture coords. Z component included
|
|
* since this is how it's stored in the depth buffer.
|
|
* 4th component how far we are on the ray */
|
|
#ifdef PLANAR_PROBE_RAYTRACE
|
|
/* Planar Reflections have X mirrored. */
|
|
vec2 m = (index > -1) ? vec2(-0.5, 0.5) : vec2(0.5);
|
|
#else
|
|
const vec2 m = vec2(0.5);
|
|
#endif
|
|
ss_ray = ss_start * m.xyyy + 0.5;
|
|
ss_step *= m.xyyy;
|
|
|
|
/* take the center of the texel. */
|
|
// ss_ray.xy += sign(ss_ray.xy) * m * ssrPixelSize * (1.0 + hizMipOffset);
|
|
}
|
|
|
|
/* See times_and_deltas. */
|
|
#define curr_time times_and_deltas.x
|
|
#define prev_time times_and_deltas.y
|
|
#define curr_delta times_and_deltas.z
|
|
#define prev_delta times_and_deltas.w
|
|
|
|
// #define GROUPED_FETCHES /* is still slower, need to see where is the bottleneck. */
|
|
/* Return the hit position, and negate the z component (making it positive) if not hit occurred. */
|
|
/* __ray_dir__ is the ray direction premultiplied by its maximum length */
|
|
vec3 raycast(int index,
|
|
vec3 ray_origin,
|
|
vec3 ray_dir,
|
|
float thickness,
|
|
float ray_jitter,
|
|
float trace_quality,
|
|
float roughness,
|
|
const bool discard_backface)
|
|
{
|
|
vec4 ss_step, ss_start;
|
|
float max_time;
|
|
prepare_raycast(ray_origin, ray_dir, thickness, index, ss_step, ss_start, max_time);
|
|
|
|
float max_trace_time = max(0.01, max_time - 0.01);
|
|
|
|
#ifdef GROUPED_FETCHES
|
|
ray_jitter *= 0.25;
|
|
#endif
|
|
|
|
/* x : current_time, y: previous_time, z: current_delta, w: previous_delta */
|
|
vec4 times_and_deltas = vec4(0.0);
|
|
|
|
float ray_time = 0.0;
|
|
float depth_sample = sample_depth(ss_start.xy, index, 0.0);
|
|
curr_delta = depth_sample - ss_start.z;
|
|
|
|
float lod_fac = saturate(fast_sqrt(roughness) * 2.0 - 0.4);
|
|
bool hit = false;
|
|
float iter;
|
|
for (iter = 1.0; !hit && (ray_time < max_time) && (iter < MAX_STEP); iter++) {
|
|
/* Minimum stride of 2 because we are using half res minmax zbuffer. */
|
|
/* WORKAROUND: Factor is a bit higher than 2 to avoid some banding. To investigate. */
|
|
float stride = max(1.0, iter * trace_quality) * (2.0 + 0.05);
|
|
float lod = log2(stride * 0.5 * trace_quality) * lod_fac;
|
|
ray_time += stride;
|
|
|
|
/* Save previous values. */
|
|
times_and_deltas.xyzw = times_and_deltas.yxwz;
|
|
|
|
#ifdef GROUPED_FETCHES
|
|
stride *= 4.0;
|
|
vec4 jit_stride = mix(vec4(2.0), vec4(stride), vec4(0.0, 0.25, 0.5, 0.75) + ray_jitter);
|
|
|
|
vec4 times = min(vec4(ray_time) + jit_stride, vec4(max_trace_time));
|
|
|
|
vec4 uv1 = ss_start.xyxy + ss_step.xyxy * times.xxyy;
|
|
vec4 uv2 = ss_start.xyxy + ss_step.xyxy * times.zzww;
|
|
|
|
vec4 depth_samples = sample_depth_grouped(uv1, uv2, index, lod);
|
|
|
|
vec4 ray_z = ss_start.zzzz + ss_step.zzzz * times.xyzw;
|
|
vec4 ray_w = ss_start.wwww + ss_step.wwww * vec4(prev_time, times.xyz);
|
|
|
|
vec4 deltas = depth_samples - ray_z;
|
|
/* Same as component wise (curr_delta <= 0.0) && (prev_w <= depth_sample). */
|
|
bvec4 test = equal(step(deltas, vec4(0.0)) * step(ray_w, depth_samples), vec4(1.0));
|
|
hit = any(test);
|
|
|
|
if (hit) {
|
|
vec2 m = vec2(1.0, 0.0); /* Mask */
|
|
|
|
vec4 ret_times_and_deltas = times.wzzz * m.xxyy + deltas.wwwz * m.yyxx;
|
|
ret_times_and_deltas = (test.z) ? times.zyyy * m.xxyy + deltas.zzzy * m.yyxx :
|
|
ret_times_and_deltas;
|
|
ret_times_and_deltas = (test.y) ? times.yxxx * m.xxyy + deltas.yyyx * m.yyxx :
|
|
ret_times_and_deltas;
|
|
times_and_deltas = (test.x) ? times.xxxx * m.xyyy + deltas.xxxx * m.yyxy +
|
|
times_and_deltas.yyww * m.yxyx :
|
|
ret_times_and_deltas;
|
|
|
|
depth_sample = depth_samples.w;
|
|
depth_sample = (test.z) ? depth_samples.z : depth_sample;
|
|
depth_sample = (test.y) ? depth_samples.y : depth_sample;
|
|
depth_sample = (test.x) ? depth_samples.x : depth_sample;
|
|
}
|
|
else {
|
|
curr_time = times.w;
|
|
curr_delta = deltas.w;
|
|
}
|
|
#else
|
|
float jit_stride = mix(2.0, stride, ray_jitter);
|
|
|
|
curr_time = min(ray_time + jit_stride, max_trace_time);
|
|
vec4 ss_ray = ss_start + ss_step * curr_time;
|
|
|
|
depth_sample = sample_depth(ss_ray.xy, index, lod);
|
|
|
|
float prev_w = ss_start.w + ss_step.w * prev_time;
|
|
curr_delta = depth_sample - ss_ray.z;
|
|
hit = (curr_delta <= 0.0) && (prev_w <= depth_sample);
|
|
#endif
|
|
}
|
|
|
|
/* Discard backface hits. Only do this if the ray traveled enough to avoid loosing intricate
|
|
* contact reflections. This is only used for SSReflections. */
|
|
if (discard_backface && prev_delta < 0.0 && curr_time > 4.1) {
|
|
hit = false;
|
|
}
|
|
|
|
/* Reject hit if background. */
|
|
hit = hit && (depth_sample != 1.0);
|
|
|
|
curr_time = (hit) ? mix(prev_time, curr_time, refine_isect(prev_delta, curr_delta)) : curr_time;
|
|
ray_time = (hit) ? curr_time : ray_time;
|
|
|
|
/* Clip to frustum. */
|
|
ray_time = max(0.001, min(ray_time, max_time - 1.5));
|
|
|
|
vec4 ss_ray = ss_start + ss_step * ray_time;
|
|
|
|
/* Tag Z if ray failed. */
|
|
ss_ray.z *= (hit) ? 1.0 : -1.0;
|
|
return ss_ray.xyz;
|
|
}
|
|
|
|
float screen_border_mask(vec2 hit_co)
|
|
{
|
|
const float margin = 0.003;
|
|
float atten = ssrBorderFac + margin; /* Screen percentage */
|
|
hit_co = smoothstep(0.0, atten, hit_co) * (1.0 - smoothstep(1.0 - atten, 1.0, hit_co));
|
|
|
|
float screenfade = hit_co.x * hit_co.y;
|
|
|
|
return screenfade;
|
|
}
|