Any Plans to add some Reflection nodes/ functionality?

[Ruthoranium]

Hello, didn't know where to ask this. But will there be any reflections added?
or is it already possible that I just don't know how to do yet 😮

[pragma37]

Hi! Not yet.
There's an utility function to sample HDRI maps that you could use, but that's about it.

Screen-space reflections and GI are high on my to-do list, though.

[Kolupsy]

this is so awesome, I cant stop toggling between the setup without ssgi and with haha. The difference! Some other fancy words that I have heard: reprojecting the result to improve consistency with a moving camera and denoising the result either with a blur or a more fancy filter

[Kolupsy]

its crazy

[Psi25]

Will there be some sort of denoiser?

[Dereuz24]

Here's a test I did some time ago.

ssgi.zip

Here are the only 2 (I think) custom functions it uses:

bool screen_trace(vec3 direction, float step_size, float step_progression, float precission, out vec2 uv, out vec4 debug)
{
    #if (defined(PIXEL_SHADER) && defined(IS_SCREEN_SHADER)) || defined(__INTELLISENSE__)
    {
        const int steps = 25;
        uv = screen_uv();

        vec3 position = POSITION;

        vec3 ndc_position = project_point(PROJECTION * CAMERA, position);
        vec3 ndc_offset = project_point(PROJECTION * CAMERA, position + direction * (float(steps) * step_size));
        vec3 ndc_direction = normalize(ndc_offset - ndc_position);

        vec3 ndc_vector = ndc_direction;
        vec2 screen_direction = normalize(ndc_direction.xy);
        ndc_vector = ndc_direction / dot(ndc_direction, vec3(screen_direction, 0));

        debug = vec4(1);

        for(int i = 1; i <= steps; i++)
        {
            vec3 ndc_position_step = ndc_position + ndc_vector * (step_size * float(i));

            bool out_of_bounds = any(greaterThan(abs(ndc_position_step), vec3(1)));
            if(out_of_bounds)
            {
                debug.rgb *= vec3(1,0,0);
                return false;
            }

            uv = ndc_position_step.xy * 0.5 + 0.5;
            vec4 normal_depth = texture(IN_NORMAL_DEPTH, uv);
            normal_depth = texelFetch(IN_NORMAL_DEPTH, ivec2(uv * RESOLUTION), 0);
            float sampled_depth = normal_depth.w;
            sampled_depth = sampled_depth * 2.0 - 1.0;

            if(sampled_depth < ndc_position_step.z)
            {
                debug.rgb *= vec3(0,1,0);
                
                if (dot(direction, normal_depth.xyz) >= 0)
                {
                    return false;
                }

                //*
                float search_direction = -1.0;

                float delta = 10000;

                const int binary_search_steps = 25;
                for(int j = 0; j < binary_search_steps; j++)
                {
                    step_size /= 2.0;

                    ndc_position_step += ndc_vector * step_size * search_direction;

                    uv = ndc_position_step.xy * 0.5 + 0.5;

                    float sampled_depth = texture(IN_NORMAL_DEPTH, uv).w;
                    sampled_depth = texelFetch(IN_NORMAL_DEPTH, ivec2(uv * RESOLUTION), 0).w;
                    sampled_depth = sampled_depth * 2.0 - 1.0;

                    delta = distance(ndc_position_step, vec3(ndc_position_step.xy, sampled_depth));
                    
                    vec3 step_camera_space = screen_to_camera(ndc_position_step.xy * 0.5 + 0.5, ndc_position_step.z * 0.5 + 0.5);
                    vec3 sampled_camera_space = screen_to_camera(ndc_position_step.xy * 0.5 + 0.5, sampled_depth * 0.5 + 0.5);
                    delta = distance(step_camera_space, sampled_camera_space);
                    
                    if(sampled_depth > ndc_position_step.z)
                    {
                        search_direction = 1.0;
                    }
                    else
                    {
                        search_direction = -1.0;
                    }
                }
                //*/

                return delta < precission;

                return true;
            }
        }
    }
    #endif

    return false;
}

/*  META
    @normal: default=NORMAL;
*/
vec3 random_normal_offset(vec3 normal, float angle, float seed)
{
    //vec3 random_vec = random_per_pixel(seed).xyz;
    vec3 random_vec = random_per_sample(seed).xyz;
    random_vec.xyz = random_vec.xyz * 2.0 - 1.0;

    vec3 tangent = normalize(random_vec - normal * dot(random_vec, normal));
    vec3 bitangent = cross(normal, tangent);
    mat3 TBN = mat3(tangent, bitangent, normal);

    //angle = random_per_pixel(seed).w * angle;
    angle = random_per_sample(seed).w * angle;
    return TBN * vec3(0, sin(angle), cos(angle));
}

IIRC, this was the main resource I followed: https://web.archive.org/web/20220102062137/http://casual-effects.blogspot.com/2014/08/screen-space-ray-tracing.html

How can I use this on a per object basis and not run it through the entire scene render layer? Is there a way to set it up like a node per object instead? Or how should I go to set it up so it's only visible in a couple meshes and not the others

[pragma37]

The easiest way would be to have a Custom Output in the Mesh material node that you can later use as a mask in the screen tracing material.