path_tracer_rgen.h File Reference

#include "path_tracer.h"
#include "utils.glsl"
#include "global_textures.h"
#include "vertex_buffer.h"
#include "read_visbuf.glsl"
#include "asvgf.glsl"
#include "brdf.glsl"
#include "water.glsl"
#include "light_lists.h"

Go to the source code of this file.

Classes
struct	Ray

Macros
#define	RAY_GEN_DESCRIPTOR_SET_IDX   0
#define	GLOBAL_TEXTURES_DESC_SET_IDX   2
#define	VERTEX_BUFFER_DESC_SET_IDX   3
#define	VERTEX_READONLY   1
#define	DESATURATE_ENVIRONMENT_MAP   1
#define	RNG_PRIMARY_OFF_X   0
#define	RNG_PRIMARY_OFF_Y   1
#define	RNG_PRIMARY_APERTURE_X   2
#define	RNG_PRIMARY_APERTURE_Y   3
#define	RNG_NEE_LIGHT_SELECTION(bounce)   (4 + 0 + 9 * bounce)
#define	RNG_NEE_TRI_X(bounce)   (4 + 1 + 9 * bounce)
#define	RNG_NEE_TRI_Y(bounce)   (4 + 2 + 9 * bounce)
#define	RNG_NEE_LIGHT_TYPE(bounce)   (4 + 3 + 9 * bounce)
#define	RNG_BRDF_X(bounce)   (4 + 4 + 9 * bounce)
#define	RNG_BRDF_Y(bounce)   (4 + 5 + 9 * bounce)
#define	RNG_BRDF_FRESNEL(bounce)   (4 + 6 + 9 * bounce)
#define	RNG_SUNLIGHT_X(bounce)   (4 + 7 + 9 * bounce)
#define	RNG_SUNLIGHT_Y(bounce)   (4 + 8 + 9 * bounce)
#define	PRIMARY_RAY_CULL_MASK   (AS_FLAG_EVERYTHING & ~(AS_FLAG_VIEWER_MODELS | AS_FLAG_CUSTOM_SKY))
#define	REFLECTION_RAY_CULL_MASK   (AS_FLAG_OPAQUE | AS_FLAG_PARTICLES | AS_FLAG_EXPLOSIONS | AS_FLAG_SKY)
#define	BOUNCE_RAY_CULL_MASK   (AS_FLAG_OPAQUE | AS_FLAG_SKY | AS_FLAG_CUSTOM_SKY)
#define	SHADOW_RAY_CULL_MASK   (AS_FLAG_OPAQUE)
#define	NUM_RNG_PER_FRAME   (RNG_NEE_STATIC_DYNAMIC(1) + 1)
#define	BOUNCE_SPECULAR   1
#define	MAX_OUTPUT_VALUE   1000
#define	RT_PAYLOAD_SHADOW   0
#define	RT_PAYLOAD_BRDF   1

Functions
	layout (set=RAY_GEN_DESCRIPTOR_SET_IDX, binding=0) uniform accelerationStructureNV topLevelAS
	layout (location=RT_PAYLOAD_SHADOW) rayPayloadNV RayPayloadShadow ray_payload_shadow
vec3	env_map (vec3 direction, bool remove_sun)
ivec2	get_image_position ()
ivec2	get_image_size ()
bool	found_intersection (RayPayload rp)
bool	is_sky (RayPayload rp)
bool	is_dynamic_instance (RayPayload pay_load)
uint	get_primitive (RayPayload pay_load)
Triangle	get_hit_triangle (RayPayload rp)
vec3	get_hit_barycentric (RayPayload rp)
float	get_rng (uint idx)
bool	is_water (uint material)
bool	is_slime (uint material)
bool	is_lava (uint material)
bool	is_glass (uint material)
bool	is_transparent (uint material)
bool	is_chrome (uint material)
bool	is_screen (uint material)
bool	is_camera (uint material)
vec3	correct_albedo (vec3 albedo)
vec3	correct_emissive (uint material_id, vec3 emissive)
void	trace_ray (Ray ray, bool cull_back_faces, int instance_mask)
Ray	get_shadow_ray (vec3 p1, vec3 p2, float tmin)
float	trace_shadow_ray (Ray ray, int cull_mask)
vec3	trace_caustic_ray (Ray ray, int surface_medium)
vec3	rgbToNormal (vec3 rgb, out float len)
float	AdjustRoughnessToksvig (float roughness, float normalMapLen, float mip_level)
void	get_direct_illumination (vec3 position, vec3 normal, vec3 geo_normal, uint cluster_idx, uint material_id, int shadow_cull_mask, vec3 view_direction, float roughness, int surface_medium, bool enable_caustics, float surface_specular, float direct_specular_weight, bool enable_polygonal, bool enable_spherical, bool is_gradient, int bounce, out vec3 diffuse, out vec3 specular)
void	get_sunlight (uint cluster_idx, uint material_id, vec3 position, vec3 normal, vec3 geo_normal, vec3 view_direction, float roughness, int surface_medium, bool enable_caustics, out vec3 diffuse, out vec3 specular, int shadow_cull_mask)
vec3	clamp_output (vec3 c)
vec3	sample_emissive_texture (uint material_id, MaterialInfo minfo, vec2 tex_coord, vec2 tex_coord_x, vec2 tex_coord_y, float mip_level)
vec2	lava_uv_warp (vec2 uv)
vec3	get_emissive_shell (uint material_id)
bool	get_is_gradient (ivec2 ipos)
void	get_material (Triangle triangle, vec2 tex_coord, vec2 tex_coord_x, vec2 tex_coord_y, float mip_level, vec3 geo_normal, out vec3 albedo, out vec3 normal, out float metallic, out float specular, out float roughness, out vec3 emissive)
bool	get_camera_uv (vec2 tex_coord, out vec2 cameraUV)

Variables
uint	rng_seed

Macro Definition Documentation

BOUNCE_RAY_CULL_MASK

#define BOUNCE_RAY_CULL_MASK   (AS_FLAG_OPAQUE | AS_FLAG_SKY | AS_FLAG_CUSTOM_SKY)

Definition at line 58 of file path_tracer_rgen.h.

BOUNCE_SPECULAR

#define BOUNCE_SPECULAR   1

Definition at line 64 of file path_tracer_rgen.h.

DESATURATE_ENVIRONMENT_MAP

#define DESATURATE_ENVIRONMENT_MAP   1

Definition at line 39 of file path_tracer_rgen.h.

GLOBAL_TEXTURES_DESC_SET_IDX

#define GLOBAL_TEXTURES_DESC_SET_IDX   2

Definition at line 27 of file path_tracer_rgen.h.

MAX_OUTPUT_VALUE

#define MAX_OUTPUT_VALUE   1000

Definition at line 66 of file path_tracer_rgen.h.

NUM_RNG_PER_FRAME

#define NUM_RNG_PER_FRAME   (RNG_NEE_STATIC_DYNAMIC(1) + 1)

Definition at line 62 of file path_tracer_rgen.h.

PRIMARY_RAY_CULL_MASK

#define PRIMARY_RAY_CULL_MASK   (AS_FLAG_EVERYTHING & ~(AS_FLAG_VIEWER_MODELS | AS_FLAG_CUSTOM_SKY))

Definition at line 56 of file path_tracer_rgen.h.

RAY_GEN_DESCRIPTOR_SET_IDX

#define RAY_GEN_DESCRIPTOR_SET_IDX   0

Definition at line 23 of file path_tracer_rgen.h.

REFLECTION_RAY_CULL_MASK

#define REFLECTION_RAY_CULL_MASK   (AS_FLAG_OPAQUE | AS_FLAG_PARTICLES | AS_FLAG_EXPLOSIONS | AS_FLAG_SKY)

Definition at line 57 of file path_tracer_rgen.h.

RNG_BRDF_FRESNEL

#define RNG_BRDF_FRESNEL

(

bounce

)

(4 + 6 + 9 * bounce)

Definition at line 52 of file path_tracer_rgen.h.

RNG_BRDF_X

#define RNG_BRDF_X

(

bounce

)

(4 + 4 + 9 * bounce)

Definition at line 50 of file path_tracer_rgen.h.

RNG_BRDF_Y

#define RNG_BRDF_Y

(

bounce

)

(4 + 5 + 9 * bounce)

Definition at line 51 of file path_tracer_rgen.h.

RNG_NEE_LIGHT_SELECTION

#define RNG_NEE_LIGHT_SELECTION

(

bounce

)

(4 + 0 + 9 * bounce)

Definition at line 46 of file path_tracer_rgen.h.

RNG_NEE_LIGHT_TYPE

#define RNG_NEE_LIGHT_TYPE

(

bounce

)

(4 + 3 + 9 * bounce)

Definition at line 49 of file path_tracer_rgen.h.

RNG_NEE_TRI_X

#define RNG_NEE_TRI_X

(

bounce

)

(4 + 1 + 9 * bounce)

Definition at line 47 of file path_tracer_rgen.h.

RNG_NEE_TRI_Y

#define RNG_NEE_TRI_Y

(

bounce

)

(4 + 2 + 9 * bounce)

Definition at line 48 of file path_tracer_rgen.h.

RNG_PRIMARY_APERTURE_X

#define RNG_PRIMARY_APERTURE_X   2

Definition at line 43 of file path_tracer_rgen.h.

RNG_PRIMARY_APERTURE_Y

#define RNG_PRIMARY_APERTURE_Y   3

Definition at line 44 of file path_tracer_rgen.h.

RNG_PRIMARY_OFF_X

#define RNG_PRIMARY_OFF_X   0

Definition at line 41 of file path_tracer_rgen.h.

RNG_PRIMARY_OFF_Y

#define RNG_PRIMARY_OFF_Y   1

Definition at line 42 of file path_tracer_rgen.h.

RNG_SUNLIGHT_X

#define RNG_SUNLIGHT_X

(

bounce

)

(4 + 7 + 9 * bounce)

Definition at line 53 of file path_tracer_rgen.h.

RNG_SUNLIGHT_Y

#define RNG_SUNLIGHT_Y

(

bounce

)

(4 + 8 + 9 * bounce)

Definition at line 54 of file path_tracer_rgen.h.

RT_PAYLOAD_BRDF

#define RT_PAYLOAD_BRDF   1

Definition at line 69 of file path_tracer_rgen.h.

RT_PAYLOAD_SHADOW

#define RT_PAYLOAD_SHADOW   0

Definition at line 68 of file path_tracer_rgen.h.

SHADOW_RAY_CULL_MASK

#define SHADOW_RAY_CULL_MASK   (AS_FLAG_OPAQUE)

Definition at line 59 of file path_tracer_rgen.h.

VERTEX_BUFFER_DESC_SET_IDX

#define VERTEX_BUFFER_DESC_SET_IDX   3

Definition at line 30 of file path_tracer_rgen.h.

VERTEX_READONLY

#define VERTEX_READONLY   1

Definition at line 31 of file path_tracer_rgen.h.

Function Documentation

AdjustRoughnessToksvig()

float AdjustRoughnessToksvig	(	float	roughness,
		float	normalMapLen,
		float	mip_level
	)

Definition at line 365 of file path_tracer_rgen.h.

{
    float effect = global_ubo.pt_toksvig * clamp(mip_level, 0, 1);
    float shininess = RoughnessSquareToSpecPower(roughness) * effect; // not squaring the roughness here - looks better this way
    float ft = normalMapLen / mix(shininess, 1.0f, normalMapLen);
    ft = max(ft, 0.01f);
    return SpecPowerToRoughnessSquare(ft * shininess / effect);
}

Referenced by get_material().

clamp_output()

vec3 clamp_output

(

vec3

c

)

Definition at line 624 of file path_tracer_rgen.h.

{
    if(any(isnan(c)) || any(isinf(c)))
        return vec3(0);
    else 
        return clamp(c, vec3(0), vec3(MAX_OUTPUT_VALUE));
}

correct_albedo()

vec3 correct_albedo

(

vec3

albedo

)

Definition at line 237 of file path_tracer_rgen.h.

{
    return max(vec3(0), pow(albedo, vec3(ALBEDO_TRANSFORM_POWER)) * ALBEDO_TRANSFORM_SCALE + vec3(ALBEDO_TRANSFORM_BIAS));
}

Referenced by get_material(), and trace_caustic_ray().

correct_emissive()

vec3 correct_emissive	(	uint	material_id,
		vec3	emissive
	)

Definition at line 243 of file path_tracer_rgen.h.

{
    return max(vec3(0), emissive.rgb + vec3(EMISSIVE_TRANSFORM_BIAS));
}

Referenced by sample_emissive_texture().

env_map()

vec3 env_map	(	vec3	direction,
		bool	remove_sun
	)

Definition at line 81 of file path_tracer_rgen.h.

{
    direction = (global_ubo.environment_rotation_matrix * vec4(direction, 0)).xyz;
 
    vec3 envmap = vec3(0);
    if (global_ubo.environment_type == ENVIRONMENT_DYNAMIC)
    {
        envmap = textureLod(TEX_PHYSICAL_SKY, direction.xzy, 0).rgb;
 
        if(remove_sun)
        {
            // roughly remove the sun from the env map
            envmap = min(envmap, vec3((1 - dot(direction, global_ubo.sun_direction_envmap)) * 200));
        }
    }
    else if (global_ubo.environment_type == ENVIRONMENT_STATIC)
    {
        envmap = textureLod(TEX_ENVMAP, direction.xzy, 0).rgb;
#if DESATURATE_ENVIRONMENT_MAP
        float avg = (envmap.x + envmap.y + envmap.z) / 3.0;
        envmap = mix(envmap, avg.xxx, 0.1) * 0.5;
#endif
    }
    return envmap;
}

Referenced by sample_polygonal_lights().

found_intersection()

bool found_intersection

(

RayPayload

rp

)

Definition at line 134 of file path_tracer_rgen.h.

{
    return rp.instance_prim != ~0u;
}

Referenced by trace_caustic_ray().

get_camera_uv()

bool get_camera_uv	(	vec2	tex_coord,
		out vec2	cameraUV
	)

Definition at line 805 of file path_tracer_rgen.h.

{
    const vec2 minUV = vec2(11.0 / 256.0, 14.0 / 256.0);
    const vec2 maxUV = vec2(245.0 / 256.0, 148.0 / 256.0);
    
    tex_coord = fract(tex_coord);
    cameraUV = (tex_coord - minUV) / (maxUV - minUV);
 
    //vec2 resolution = vec2(7, 4) * 50;
    //cameraUV = (floor(cameraUV * resolution) + vec2(0.5)) / resolution;
 
    return all(greaterThan(cameraUV, vec2(0))) && all(lessThan(cameraUV, vec2(1)));
}

get_direct_illumination()

void get_direct_illumination	(	vec3	position,
		vec3	normal,
		vec3	geo_normal,
		uint	cluster_idx,
		uint	material_id,
		int	shadow_cull_mask,
		vec3	view_direction,
		float	roughness,
		int	surface_medium,
		bool	enable_caustics,
		float	surface_specular,
		float	direct_specular_weight,
		bool	enable_polygonal,
		bool	enable_spherical,
		bool	is_gradient,
		int	bounce,
		out vec3	diffuse,
		out vec3	specular
	)

Definition at line 375 of file path_tracer_rgen.h.

{
    diffuse = vec3(0);
    specular = vec3(0);
 
    vec3 pos_on_light_polygonal;
    vec3 pos_on_light_spherical;
 
    vec3 contrib_polygonal = vec3(0);
    vec3 contrib_spherical = vec3(0);
 
    float alpha = square(roughness);
    float phong_exp = RoughnessSquareToSpecPower(alpha);
    float phong_scale = min(100, 1 / (M_PI * square(alpha)));
    float phong_weight = clamp(surface_specular * direct_specular_weight, 0, 0.9);
 
    int polygonal_light_index = -1;
    float polygonal_light_area = 0;
 
    vec3 rng = vec3(
        get_rng(RNG_NEE_LIGHT_SELECTION(bounce)),
        get_rng(RNG_NEE_TRI_X(bounce)),
        get_rng(RNG_NEE_TRI_Y(bounce)));
 
    /* polygonal light illumination */
    if(enable_polygonal) 
    {
        sample_polygonal_lights(
            cluster_idx,
            position, 
            normal, 
            geo_normal, 
            view_direction, 
            phong_exp, 
            phong_scale,
            phong_weight, 
            is_gradient, 
            pos_on_light_polygonal, 
            contrib_polygonal,
            polygonal_light_index,
            polygonal_light_area,
            rng);
    }
 
    bool is_polygonal = true;
    float vis = 1;
 
    /* spherical light illumination */
    if(enable_spherical) 
    {
        // Limit the solid angle of sphere lights for indirect lighting 
        // in order to kill some fireflies in locations with many sphere lights.
        // Example: green wall-lamp corridor in the "train" map.
        float max_solid_angle = (bounce == 0) ? 2 * M_PI : 0.02;
    
        sample_spherical_lights(
            position,
            normal,
            geo_normal,
            max_solid_angle,
            pos_on_light_spherical,
            contrib_spherical,
            rng);
    }
 
    float spec_polygonal = phong(normal, normalize(pos_on_light_polygonal - position), view_direction, phong_exp) * phong_scale;
    float spec_spherical = phong(normal, normalize(pos_on_light_spherical - position), view_direction, phong_exp) * phong_scale;
 
    float l_polygonal  = luminance(abs(contrib_polygonal)) * mix(1, spec_polygonal, phong_weight);
    float l_spherical = luminance(abs(contrib_spherical)) * mix(1, spec_spherical, phong_weight);
    float l_sum = l_polygonal + l_spherical;
 
    bool null_light = (l_sum == 0);
 
    float w = null_light ? 0.5 : l_polygonal / (l_polygonal + l_spherical);
 
    float rng2 = get_rng(RNG_NEE_LIGHT_TYPE(bounce));
    is_polygonal = (rng2 < w);
    vis = is_polygonal ? (1 / w) : (1 / (1 - w));
    vec3 pos_on_light = null_light ? position : (is_polygonal ? pos_on_light_polygonal : pos_on_light_spherical);
    vec3 contrib = is_polygonal ? contrib_polygonal : contrib_spherical;
 
    Ray shadow_ray = get_shadow_ray(position - view_direction * 0.001, pos_on_light, 0);
    
    vis *= trace_shadow_ray(shadow_ray, null_light ? 0 : shadow_cull_mask);
#ifdef ENABLE_SHADOW_CAUSTICS
    if(enable_caustics)
    {
        contrib *= trace_caustic_ray(shadow_ray, surface_medium);
    }
#endif
 
    /* 
        Accumulate light shadowing statistics to guide importance sampling on the next frame.
        Inspired by paper called "Adaptive Shadow Testing for Ray Tracing" by G. Ward, EUROGRAPHICS 1994.
 
        The algorithm counts the shadowed and unshadowed rays towards each light, per cluster,
        per surface orientation in each cluster. Orientation helps improve accuracy in cases 
        when a single cluster has different parts which have the same light mostly shadowed and 
        mostly unshadowed.
 
        On the next frame, the light CDF is built using the counts from this frame, or the frame
        before that in case of gradient rays. See light_lists.h for more info.
 
        Only applies to polygonal polygon lights (i.e. no model or beam lights) because the spherical
        polygon lights do not have polygonal indices, and it would be difficult to map them 
        between frames.
    */
    if(global_ubo.pt_light_stats != 0 
        && is_polygonal 
        && !null_light
        && polygonal_light_index >= 0 
        && polygonal_light_index < global_ubo.num_static_lights)
    {
        uint addr = get_light_stats_addr(cluster_idx, polygonal_light_index, get_primary_direction(normal));
 
        // Offset 0 is unshadowed rays,
        // Offset 1 is shadowed rays
        if(vis == 0) addr += 1;
 
        // Increment the ray counter
        atomicAdd(light_stats_bufers[global_ubo.current_frame_idx % NUM_LIGHT_STATS_BUFFERS].stats[addr], 1);
    }
 
    if(null_light)
        return;
 
    diffuse = vis * contrib;
 
    if(is_polygonal && direct_specular_weight > 0)
    {
        // MIS with direct specular and indirect specular.
        // Only applied to sky lights, for two reasons:
        //  1) Non-sky lights are trimmed to match the light texture, and indirect rays don't see that;
        //  2) Non-sky lights are usually away from walls, so the direct sampling issue is not as pronounced.
        direct_specular_weight *= 1.0 - smoothstep(
            global_ubo.pt_direct_area_threshold,
            global_ubo.pt_direct_area_threshold * 2, 
            polygonal_light_area);
    }
 
    if(vis > 0 && direct_specular_weight > 0)
    {
        specular = diffuse * (GGX(view_direction, normalize(pos_on_light - position), normal, roughness, 0.0) * direct_specular_weight);
    }
 
    vec3 L = pos_on_light - position;
    L = normalize(L);
 
    float NdotL = max(0, dot(normal, L));
 
    diffuse *= NdotL / M_PI;
}

get_emissive_shell()

vec3 get_emissive_shell

(

uint

material_id

)

Definition at line 669 of file path_tracer_rgen.h.

{
    vec3 c = vec3(0);
 
    if((material_id & (MATERIAL_FLAG_SHELL_RED | MATERIAL_FLAG_SHELL_GREEN | MATERIAL_FLAG_SHELL_BLUE)) != 0)
    { 
        if((material_id & MATERIAL_FLAG_SHELL_RED) != 0) c.r += 1;
        if((material_id & MATERIAL_FLAG_SHELL_GREEN) != 0) c.g += 1;
        if((material_id & MATERIAL_FLAG_SHELL_BLUE) != 0) c.b += 1;
 
        if((material_id & MATERIAL_FLAG_WEAPON) != 0) c *= 0.2;
    }
 
    if(tonemap_buffer.adapted_luminance > 0)
            c.rgb *= tonemap_buffer.adapted_luminance * 100;
 
    return c;
}

Referenced by get_material().

get_hit_barycentric()

vec3 get_hit_barycentric

(

RayPayload

rp

)

Definition at line 168 of file path_tracer_rgen.h.

{
    vec3 bary;
    bary.yz = rp.barycentric;
    bary.x  = 1.0 - bary.y - bary.z;
    return bary;
}

Referenced by trace_caustic_ray().

get_hit_triangle()

Triangle get_hit_triangle

(

RayPayload

rp

)

Definition at line 158 of file path_tracer_rgen.h.

{
    uint prim = get_primitive(rp);
 
    return is_dynamic_instance(rp)
        ?  get_instanced_triangle(prim)
        :  get_bsp_triangle(prim);
}

Referenced by trace_caustic_ray().

get_image_position()

ivec2 get_image_position

(

)

Definition at line 110 of file path_tracer_rgen.h.

{
    ivec2 pos;
 
    bool is_even_checkerboard = push_constants.gpu_index == 0 || push_constants.gpu_index < 0 && gl_LaunchIDNV.z == 0;
    if(global_ubo.pt_swap_checkerboard != 0)
        is_even_checkerboard = !is_even_checkerboard;
 
    if (is_even_checkerboard) {
        pos.x = int(gl_LaunchIDNV.x * 2) + int(gl_LaunchIDNV.y & 1);
    } else {
        pos.x = int(gl_LaunchIDNV.x * 2 + 1) - int(gl_LaunchIDNV.y & 1);
    }
 
    pos.y = int(gl_LaunchIDNV.y);
    return pos;
}

get_image_size()

ivec2 get_image_size

(

)

Definition at line 128 of file path_tracer_rgen.h.

{
    return ivec2(global_ubo.width, global_ubo.height);
}

get_is_gradient()

bool get_is_gradient

(

ivec2

ipos

)

Definition at line 688 of file path_tracer_rgen.h.

{
    if(global_ubo.flt_enable != 0)
    {
        uint u = texelFetch(TEX_ASVGF_GRAD_SMPL_POS_A, ipos / GRAD_DWN, 0).r;
 
        ivec2 grad_strata_pos = ivec2(
                u >> (STRATUM_OFFSET_SHIFT * 0),
                u >> (STRATUM_OFFSET_SHIFT * 1)) & STRATUM_OFFSET_MASK;
 
        return (u > 0 && all(equal(grad_strata_pos, ipos % GRAD_DWN)));
    }
    
    return false;
}

get_material()

void get_material	(	Triangle	triangle,
		vec2	tex_coord,
		vec2	tex_coord_x,
		vec2	tex_coord_y,
		float	mip_level,
		vec3	geo_normal,
		out vec3	albedo,
		out vec3	normal,
		out float	metallic,
		out float	specular,
		out float	roughness,
		out vec3	emissive
	)

Definition at line 706 of file path_tracer_rgen.h.

{
    if((triangle.material_id & MATERIAL_FLAG_FLOWING) != 0)
    {
        tex_coord.x -= global_ubo.time * 0.5;
    }
 
    if((triangle.material_id & MATERIAL_FLAG_WARP) != 0)
    {
        tex_coord = lava_uv_warp(tex_coord);
    }
 
 
    MaterialInfo minfo = get_material_info(triangle.material_id);
    
 
    vec4 image1;
    if (mip_level >= 0)
        image1 = global_textureLod(minfo.diffuse_texture, tex_coord, mip_level);
    else
        image1 = global_textureGrad(minfo.diffuse_texture, tex_coord, tex_coord_x, tex_coord_y);
 
    if((triangle.material_id & MATERIAL_FLAG_CORRECT_ALBEDO) != 0)
        albedo = correct_albedo(image1.rgb);
    else
        albedo = image1.rgb;
 
    normal = geo_normal;
    metallic = 0;
    specular = 0;
    roughness = 1;
 
    if (minfo.normals_texture != 0)// && dot(triangle.tangent, triangle.tangent) > 0)
    {
        vec4 image2;
        if (mip_level >= 0)
            image2 = global_textureLod(minfo.normals_texture, tex_coord, mip_level);
        else
            image2 = global_textureGrad(minfo.normals_texture, tex_coord, tex_coord_x, tex_coord_y);
 
        float normalMapLen;
        vec3 local_normal = rgbToNormal(image2.rgb, normalMapLen);
 
        if(dot(triangle.tangent, triangle.tangent) > 0)
        {
            vec3 tangent = triangle.tangent,
                 bitangent = cross(geo_normal, tangent);
 
            if((triangle.material_id & MATERIAL_FLAG_HANDEDNESS) != 0)
                bitangent = -bitangent;
            
            normal = tangent * local_normal.x + bitangent * local_normal.y + geo_normal * local_normal.z;
        
            float bump_scale = global_ubo.pt_bump_scale * minfo.bump_scale;
            if(is_glass(triangle.material_id))
                bump_scale *= 0.2;
 
            normal = normalize(mix(geo_normal, normal, bump_scale));
        }
 
        metallic = clamp(image2.a * minfo.specular_scale, 0, 1);
        
        if(minfo.roughness_override >= 0)
            roughness = max(image1.a, minfo.roughness_override);
        else
            roughness = image1.a;
 
        roughness = clamp(roughness, 0, 1);
 
        float effective_mip = mip_level;
 
        if (effective_mip < 0)
        {
            ivec2 texSize = global_textureSize(minfo.normals_texture, 0);
            vec2 tx = tex_coord_x * texSize;
            vec2 ty = tex_coord_y * texSize;
            float d = max(dot(tx, tx), dot(ty, ty));
            effective_mip = 0.5 * log2(d);
        }
 
        bool is_mirror = (roughness < MAX_MIRROR_ROUGHNESS) && (is_chrome(triangle.material_id) || is_screen(triangle.material_id));
 
        if (normalMapLen > 0 && global_ubo.pt_toksvig > 0 && effective_mip > 0 && !is_mirror)
        {
            roughness = AdjustRoughnessToksvig(roughness, normalMapLen, effective_mip);
        }
    } 
 
    if(global_ubo.pt_roughness_override >= 0) roughness = global_ubo.pt_roughness_override;
    if(global_ubo.pt_metallic_override >= 0) metallic = global_ubo.pt_metallic_override;
 
    specular = mix(0.05, 1.0, metallic);
 
    emissive = sample_emissive_texture(triangle.material_id, minfo, tex_coord, tex_coord_x, tex_coord_y, mip_level);
 
    emissive += get_emissive_shell(triangle.material_id) * albedo * (1 - metallic * 0.9);
}

get_primitive()

uint get_primitive

(

RayPayload

pay_load

)

Definition at line 152 of file path_tracer_rgen.h.

{
    return pay_load.instance_prim & PRIM_ID_MASK;
}

Referenced by get_hit_triangle().

get_rng()

float get_rng

(

uint

idx

)

Definition at line 177 of file path_tracer_rgen.h.

{
    uvec3 p = uvec3(rng_seed, rng_seed >> 10, rng_seed >> 20);
    p.z = (p.z + idx);
    p &= uvec3(BLUE_NOISE_RES - 1, BLUE_NOISE_RES - 1, NUM_BLUE_NOISE_TEX - 1);
 
    return min(texelFetch(TEX_BLUE_NOISE, ivec3(p), 0).r, 0.9999999999999);
    //return fract(vec2(get_rng_uint(idx)) / vec2(0xffffffffu));
}

Referenced by get_direct_illumination(), and get_sunlight().

get_shadow_ray()

Ray get_shadow_ray	(	vec3	p1,
		vec3	p2,
		float	tmin
	)

Definition at line 264 of file path_tracer_rgen.h.

{
    vec3 l = p2 - p1;
    float dist = length(l);
    l /= dist;
 
    Ray ray;
    ray.origin = p1 + l * tmin;
    ray.t_min = 0;
    ray.t_max = dist - tmin - 0.01;
    ray.direction = l;
 
    return ray;
}

Referenced by get_direct_illumination(), and get_sunlight().

get_sunlight()

void get_sunlight	(	uint	cluster_idx,
		uint	material_id,
		vec3	position,
		vec3	normal,
		vec3	geo_normal,
		vec3	view_direction,
		float	roughness,
		int	surface_medium,
		bool	enable_caustics,
		out vec3	diffuse,
		out vec3	specular,
		int	shadow_cull_mask
	)

Definition at line 548 of file path_tracer_rgen.h.

{
    diffuse = vec3(0);
    specular = vec3(0);
 
    if(global_ubo.sun_visible == 0)
        return;
 
    bool visible = (cluster_idx == ~0u) || (get_sky_visibility(cluster_idx >> 5) & (1 << (cluster_idx & 31))) != 0;
 
    if(!visible)
        return;
 
    vec2 rng3 = vec2(get_rng(RNG_SUNLIGHT_X(0)), get_rng(RNG_SUNLIGHT_Y(0)));
    vec2 disk = sample_disk(rng3);
    disk.xy *= global_ubo.sun_tan_half_angle;
 
    vec3 direction = normalize(global_ubo.sun_direction + global_ubo.sun_tangent * disk.x + global_ubo.sun_bitangent * disk.y);
 
    float NdotL = dot(direction, normal);
    float GNdotL = dot(direction, geo_normal);
 
    if(NdotL <= 0 || GNdotL <= 0)
        return;
 
    Ray shadow_ray = get_shadow_ray(position - view_direction * 0.001, position + direction * 10000, 0);
 
    float vis = trace_shadow_ray(shadow_ray, shadow_cull_mask);
 
    if(vis == 0)
        return;
 
#ifdef ENABLE_SUN_SHAPE
    // Fetch the sun color from the environment map. 
    // This allows us to get properly shaped shadows from the sun that is partially occluded
    // by clouds or landscape.
 
    vec3 envmap_direction = (global_ubo.environment_rotation_matrix * vec4(direction, 0)).xyz;
    
    vec3 envmap = textureLod(TEX_PHYSICAL_SKY, envmap_direction.xzy, 0).rgb;
 
    diffuse = (global_ubo.sun_solid_angle * global_ubo.pt_env_scale) * envmap;
#else
    // Fetch the average sun color from the resolved UBO - it's faster.
 
    diffuse = sun_color_ubo.sun_color;
#endif
 
#ifdef ENABLE_SHADOW_CAUSTICS
    if(enable_caustics)
    {
        diffuse *= trace_caustic_ray(shadow_ray, surface_medium);
    }
#endif
 
    if(global_ubo.pt_sun_specular > 0)
    {
        float NoH_offset = 0.5 * square(global_ubo.sun_tan_half_angle);
        specular = diffuse * GGX(view_direction, global_ubo.sun_direction, normal, roughness, NoH_offset);
    }
 
    diffuse *= NdotL / M_PI;
}

is_camera()

bool is_camera

(

uint

material

)

Definition at line 231 of file path_tracer_rgen.h.

{
    return (material & MATERIAL_KIND_MASK) == MATERIAL_KIND_CAMERA;
}

is_chrome()

bool is_chrome

(

uint

material

)

Definition at line 218 of file path_tracer_rgen.h.

{
    uint kind = material & MATERIAL_KIND_MASK;
    return kind == MATERIAL_KIND_CHROME || kind == MATERIAL_KIND_CHROME_MODEL;
}

Referenced by get_material().

is_dynamic_instance()

bool is_dynamic_instance

(

RayPayload

pay_load

)

Definition at line 146 of file path_tracer_rgen.h.

{
    return (pay_load.instance_prim & INSTANCE_DYNAMIC_FLAG) > 0;
}

Referenced by get_hit_triangle().

is_glass()

bool is_glass

(

uint

material

)

Definition at line 206 of file path_tracer_rgen.h.

{
    return (material & MATERIAL_KIND_MASK) == MATERIAL_KIND_GLASS;
}

Referenced by get_material(), and trace_caustic_ray().

is_lava()

bool is_lava

(

uint

material

)

Definition at line 200 of file path_tracer_rgen.h.

{
    return (material & MATERIAL_KIND_MASK) == MATERIAL_KIND_LAVA;
}

Referenced by collect_sky_and_lava_ligth_polys().

is_screen()

bool is_screen

(

uint

material

)

Definition at line 225 of file path_tracer_rgen.h.

{
    return (material & MATERIAL_KIND_MASK) == MATERIAL_KIND_SCREEN;
}

Referenced by get_material().

is_sky()

bool is_sky

(

RayPayload

rp

)

Definition at line 140 of file path_tracer_rgen.h.

{
    return (rp.instance_prim & INSTANCE_SKY_FLAG) != 0;
}

Referenced by collect_sky_and_lava_ligth_polys(), and create_poly().

is_slime()

bool is_slime

(

uint

material

)

Definition at line 194 of file path_tracer_rgen.h.

{
    return (material & MATERIAL_KIND_MASK) == MATERIAL_KIND_SLIME;
}

Referenced by trace_caustic_ray().

is_transparent()

bool is_transparent

(

uint

material

)

Definition at line 212 of file path_tracer_rgen.h.

{
    return (material & MATERIAL_KIND_MASK) == MATERIAL_KIND_TRANSPARENT;
}

is_water()

bool is_water

(

uint

material

)

Definition at line 188 of file path_tracer_rgen.h.

{
    return (material & MATERIAL_KIND_MASK) == MATERIAL_KIND_WATER;
}

Referenced by trace_caustic_ray().

lava_uv_warp()

vec2 lava_uv_warp

(

vec2

uv

)

Definition at line 652 of file path_tracer_rgen.h.

{
    // Lava UV warp that (hopefully) matches the warp in the original Quake 2.
    // Relevant bits of the original rasterizer:
 
    // #define AMP     8*0x10000
    // #define SPEED   20
    // #define CYCLE   128
    // sintable[i] = AMP + sin(i * M_PI * 2 / CYCLE) * AMP; 
    // #define TURB_SIZE               64  // base turbulent texture size
    // #define TURB_MASK               (TURB_SIZE - 1)
    // turb_s = ((s + turb[(t >> 16) & (CYCLE - 1)]) >> 16) & TURB_MASK;
    // turb_t = ((t + turb[(s >> 16) & (CYCLE - 1)]) >> 16) & TURB_MASK;
    
    return uv.xy + sin(fract(uv.yx * 0.5 + global_ubo.time * 20 / 128) * 2 * M_PI) * 0.125;
}

Referenced by get_material().

layout() [1/2]

layout

(

location

= RT_PAYLOAD_SHADOW

)

layout() [2/2]

layout	(	set	= RAY_GEN_DESCRIPTOR_SET_IDX,
		binding	= 0
	)

rgbToNormal()

vec3 rgbToNormal	(	vec3	rgb,
		out float	len
	)

Definition at line 355 of file path_tracer_rgen.h.

{
    vec3 n = vec3(rgb.xy * 2 - 1, rgb.z);
 
    len = length(n);
    return len > 0 ? n / len : vec3(0);
}

Referenced by get_material().

sample_emissive_texture()

vec3 sample_emissive_texture	(	uint	material_id,
		MaterialInfo	minfo,
		vec2	tex_coord,
		vec2	tex_coord_x,
		vec2	tex_coord_y,
		float	mip_level
	)

Definition at line 633 of file path_tracer_rgen.h.

{
    if (minfo.emissive_texture != 0)
    {
        vec4 image3;
        if (mip_level >= 0)
            image3 = global_textureLod(minfo.emissive_texture, tex_coord, mip_level);
        else
            image3 = global_textureGrad(minfo.emissive_texture, tex_coord, tex_coord_x, tex_coord_y);
 
        vec3 corrected = correct_emissive(material_id, image3.rgb);
 
        return corrected * minfo.emissive_scale;
    }
 
    return vec3(0);
}

Referenced by get_material().

trace_caustic_ray()

vec3 trace_caustic_ray	(	Ray	ray,
		int	surface_medium
	)

Definition at line 294 of file path_tracer_rgen.h.

{
    ray_payload_brdf.hit_distance = -1;
 
    traceNV(topLevelAS, gl_RayFlagsCullBackFacingTrianglesNV, AS_FLAG_TRANSPARENT,
        SBT_RCHIT_OPAQUE, 0, SBT_RMISS_PATH_TRACER,
            ray.origin, ray.t_min, ray.direction, ray.t_max, RT_PAYLOAD_BRDF);
 
    float extinction_distance = ray.t_max - ray.t_min;
    vec3 throughput = vec3(1);
 
    if(found_intersection(ray_payload_brdf))
    {
        Triangle triangle = get_hit_triangle(ray_payload_brdf);
        
        vec3 geo_normal = triangle.normals[0];
        bool is_vertical = abs(geo_normal.z) < 0.1;
 
        if((is_water(triangle.material_id) || is_slime(triangle.material_id)) && !is_vertical)
        {
            vec3 position = ray.origin + ray.direction * ray_payload_brdf.hit_distance;
            vec3 w = get_water_normal(triangle.material_id, geo_normal, triangle.tangent, position, true);
 
            float caustic = clamp((1 - pow(clamp(1 - length(w.xz), 0, 1), 2)) * 100, 0, 8);
            caustic = mix(1, caustic, clamp(ray_payload_brdf.hit_distance * 0.02, 0, 1));
            throughput = vec3(caustic);
 
            if(surface_medium != MEDIUM_NONE)
            {
                extinction_distance = ray_payload_brdf.hit_distance;
            }
            else
            {
                if(is_water(triangle.material_id))
                    surface_medium = MEDIUM_WATER;
                else
                    surface_medium = MEDIUM_SLIME;
 
                extinction_distance = max(0, ray.t_max - ray_payload_brdf.hit_distance);
            }
        }
        else if(is_glass(triangle.material_id) || is_water(triangle.material_id) && is_vertical)
        {
            vec3 bary = get_hit_barycentric(ray_payload_brdf);
            vec2 tex_coord = triangle.tex_coords * bary;
 
            MaterialInfo minfo = get_material_info(triangle.material_id);
 
            vec3 albedo = global_textureLod(minfo.diffuse_texture, tex_coord, 2).rgb;
 
            if((triangle.material_id & MATERIAL_FLAG_CORRECT_ALBEDO) != 0)
                albedo = correct_albedo(albedo);
 
            throughput = albedo;
        }
    }
 
    //return vec3(caustic);
    return extinction(surface_medium, extinction_distance) * throughput;
}

Referenced by get_direct_illumination(), and get_sunlight().

trace_ray()

void trace_ray	(	Ray	ray,
		bool	cull_back_faces,
		int	instance_mask
	)

Definition at line 249 of file path_tracer_rgen.h.

{
    uint rayFlags = 0;
    if(cull_back_faces)
        rayFlags |=gl_RayFlagsCullBackFacingTrianglesNV;
    
    ray_payload_brdf.transparency = uvec2(0);
    ray_payload_brdf.hit_distance = 0;
    ray_payload_brdf.max_transparent_distance = 0;
 
    traceNV( topLevelAS, rayFlags, instance_mask,
            SBT_RCHIT_OPAQUE /*sbtRecordOffset*/, 0 /*sbtRecordStride*/, SBT_RMISS_PATH_TRACER /*missIndex*/,
            ray.origin, ray.t_min, ray.direction, ray.t_max, RT_PAYLOAD_BRDF);
}

trace_shadow_ray()

float trace_shadow_ray	(	Ray	ray,
		int	cull_mask
	)

Definition at line 280 of file path_tracer_rgen.h.

{
    const uint rayFlags = gl_RayFlagsOpaqueNV | gl_RayFlagsTerminateOnFirstHitNV;
 
    ray_payload_shadow.missed = 0;
 
    traceNV( topLevelAS, rayFlags, cull_mask,
            SBT_RCHIT_EMPTY /*sbtRecordOffset*/, 0 /*sbtRecordStride*/, SBT_RMISS_SHADOW /*missIndex*/,
            ray.origin, ray.t_min, ray.direction, ray.t_max, RT_PAYLOAD_SHADOW);
 
    return float(ray_payload_shadow.missed);
}

Referenced by get_direct_illumination(), and get_sunlight().

Variable Documentation

rng_seed

uint rng_seed

Definition at line 73 of file path_tracer_rgen.h.

Referenced by get_rng().