diff options
13 files changed, 618 insertions, 575 deletions
diff --git a/source/blender/draw/CMakeLists.txt b/source/blender/draw/CMakeLists.txt index 31deb59b7fc..765e6a2fda2 100644 --- a/source/blender/draw/CMakeLists.txt +++ b/source/blender/draw/CMakeLists.txt @@ -120,6 +120,8 @@ data_to_c_simple(engines/eevee/shaders/default_world_frag.glsl SRC) data_to_c_simple(engines/eevee/shaders/background_vert.glsl SRC) data_to_c_simple(engines/eevee/shaders/ambient_occlusion_lib.glsl SRC) data_to_c_simple(engines/eevee/shaders/effect_minmaxz_frag.glsl SRC) +data_to_c_simple(engines/eevee/shaders/lamps_lib.glsl SRC) +data_to_c_simple(engines/eevee/shaders/lightprobe_lib.glsl SRC) data_to_c_simple(engines/eevee/shaders/lightprobe_filter_glossy_frag.glsl SRC) data_to_c_simple(engines/eevee/shaders/lightprobe_filter_diffuse_frag.glsl SRC) data_to_c_simple(engines/eevee/shaders/lightprobe_geom.glsl SRC) diff --git a/source/blender/draw/engines/eevee/eevee_lightprobes.c b/source/blender/draw/engines/eevee/eevee_lightprobes.c index b85116adc81..d7b7a6b6ffd 100644 --- a/source/blender/draw/engines/eevee/eevee_lightprobes.c +++ b/source/blender/draw/engines/eevee/eevee_lightprobes.c @@ -87,6 +87,7 @@ extern char datatoc_lightprobe_cube_display_vert_glsl[]; extern char datatoc_lightprobe_grid_display_frag_glsl[]; extern char datatoc_lightprobe_grid_display_vert_glsl[]; extern char datatoc_irradiance_lib_glsl[]; +extern char datatoc_lightprobe_lib_glsl[]; extern char datatoc_octahedron_lib_glsl[]; extern char datatoc_bsdf_common_lib_glsl[]; extern char datatoc_bsdf_sampling_lib_glsl[]; @@ -217,7 +218,9 @@ void EEVEE_lightprobes_init(EEVEE_SceneLayerData *sldata, EEVEE_Data *UNUSED(ved ds_frag = BLI_dynstr_new(); BLI_dynstr_append(ds_frag, datatoc_octahedron_lib_glsl); + BLI_dynstr_append(ds_frag, datatoc_bsdf_common_lib_glsl); BLI_dynstr_append(ds_frag, datatoc_irradiance_lib_glsl); + BLI_dynstr_append(ds_frag, datatoc_lightprobe_lib_glsl); BLI_dynstr_append(ds_frag, datatoc_lightprobe_grid_display_frag_glsl); shader_str = BLI_dynstr_get_cstring(ds_frag); BLI_dynstr_free(ds_frag); @@ -237,6 +240,8 @@ void EEVEE_lightprobes_init(EEVEE_SceneLayerData *sldata, EEVEE_Data *UNUSED(ved ds_frag = BLI_dynstr_new(); BLI_dynstr_append(ds_frag, datatoc_octahedron_lib_glsl); + BLI_dynstr_append(ds_frag, datatoc_bsdf_common_lib_glsl); + BLI_dynstr_append(ds_frag, datatoc_lightprobe_lib_glsl); BLI_dynstr_append(ds_frag, datatoc_lightprobe_cube_display_frag_glsl); shader_str = BLI_dynstr_get_cstring(ds_frag); BLI_dynstr_free(ds_frag); @@ -247,7 +252,9 @@ void EEVEE_lightprobes_init(EEVEE_SceneLayerData *sldata, EEVEE_Data *UNUSED(ved MEM_freeN(shader_str); ds_frag = BLI_dynstr_new(); + BLI_dynstr_append(ds_frag, datatoc_octahedron_lib_glsl); BLI_dynstr_append(ds_frag, datatoc_bsdf_common_lib_glsl); + BLI_dynstr_append(ds_frag, datatoc_lightprobe_lib_glsl); BLI_dynstr_append(ds_frag, datatoc_lightprobe_planar_display_frag_glsl); shader_str = BLI_dynstr_get_cstring(ds_frag); BLI_dynstr_free(ds_frag); @@ -377,7 +384,7 @@ void EEVEE_lightprobes_cache_init(EEVEE_SceneLayerData *sldata, EEVEE_Data *veda DRW_shgroup_uniform_float(grp, "invSampleCount", &sldata->probes->invsamples_ct, 1); DRW_shgroup_uniform_float(grp, "roughnessSquared", &sldata->probes->roughness, 1); DRW_shgroup_uniform_float(grp, "lodFactor", &sldata->probes->lodfactor, 1); - DRW_shgroup_uniform_float(grp, "lodMax", &sldata->probes->lodmax, 1); + DRW_shgroup_uniform_float(grp, "lodMax", &sldata->probes->lod_rt_max, 1); DRW_shgroup_uniform_float(grp, "texelSize", &sldata->probes->texel_size, 1); DRW_shgroup_uniform_float(grp, "paddingSize", &sldata->probes->padding_size, 1); DRW_shgroup_uniform_int(grp, "Layer", &sldata->probes->layer, 1); @@ -398,7 +405,7 @@ void EEVEE_lightprobes_cache_init(EEVEE_SceneLayerData *sldata, EEVEE_Data *veda DRW_shgroup_uniform_float(grp, "sampleCount", &sldata->probes->samples_ct, 1); DRW_shgroup_uniform_float(grp, "invSampleCount", &sldata->probes->invsamples_ct, 1); DRW_shgroup_uniform_float(grp, "lodFactor", &sldata->probes->lodfactor, 1); - DRW_shgroup_uniform_float(grp, "lodMax", &sldata->probes->lodmax, 1); + DRW_shgroup_uniform_float(grp, "lodMax", &sldata->probes->lod_rt_max, 1); DRW_shgroup_uniform_texture(grp, "texHammersley", e_data.hammersley); #endif DRW_shgroup_uniform_texture(grp, "probeHdr", sldata->probe_rt); @@ -416,7 +423,7 @@ void EEVEE_lightprobes_cache_init(EEVEE_SceneLayerData *sldata, EEVEE_Data *veda DRW_shgroup_attrib_float(grp, "probe_id", 1); /* XXX this works because we are still uploading 4bytes and using the right stride */ DRW_shgroup_attrib_float(grp, "probe_location", 3); DRW_shgroup_attrib_float(grp, "sphere_size", 1); - DRW_shgroup_uniform_float(grp, "lodMax", &sldata->probes->lodmax, 1); + DRW_shgroup_uniform_float(grp, "lodCubeMax", &sldata->probes->lod_cube_max, 1); DRW_shgroup_uniform_buffer(grp, "probeCubes", &sldata->probe_pool); } @@ -870,7 +877,7 @@ static void glossy_filter_probe(EEVEE_SceneLayerData *sldata, EEVEE_PassList *ps pinfo->invsamples_ct = 1.0f / pinfo->samples_ct; pinfo->lodfactor = bias + 0.5f * log((float)(PROBE_RT_SIZE * PROBE_RT_SIZE) * pinfo->invsamples_ct) / log(2); - pinfo->lodmax = floorf(log2f(PROBE_RT_SIZE)) - 2.0f; + pinfo->lod_rt_max = floorf(log2f(PROBE_RT_SIZE)) - 2.0f; DRW_framebuffer_texture_attach(sldata->probe_filter_fb, sldata->probe_pool, 0, i); DRW_framebuffer_viewport_size(sldata->probe_filter_fb, 0, 0, mipsize, mipsize); @@ -881,7 +888,7 @@ static void glossy_filter_probe(EEVEE_SceneLayerData *sldata, EEVEE_PassList *ps CLAMP_MIN(mipsize, 1); } /* For shading, save max level of the octahedron map */ - pinfo->lodmax = (float)(maxlevel - min_lod_level) - 1.0f; + pinfo->lod_cube_max = (float)(maxlevel - min_lod_level) - 1.0f; /* reattach to have a valid framebuffer. */ DRW_framebuffer_texture_attach(sldata->probe_filter_fb, sldata->probe_pool, 0, 0); @@ -892,9 +899,6 @@ static void diffuse_filter_probe(EEVEE_SceneLayerData *sldata, EEVEE_PassList *p { EEVEE_LightProbesInfo *pinfo = sldata->probes; - /* TODO do things properly */ - float lodmax = pinfo->lodmax; - /* 4 - Compute spherical harmonics */ /* Tweaking parameters to balance perf. vs precision */ DRW_framebuffer_bind(sldata->probe_filter_fb); @@ -924,10 +928,10 @@ static void diffuse_filter_probe(EEVEE_SceneLayerData *sldata, EEVEE_PassList *p const float bias = 0.0f; pinfo->invsamples_ct = 1.0f / pinfo->samples_ct; pinfo->lodfactor = bias + 0.5f * log((float)(PROBE_RT_SIZE * PROBE_RT_SIZE) * pinfo->invsamples_ct) / log(2); - pinfo->lodmax = floorf(log2f(PROBE_RT_SIZE)) - 2.0f; + pinfo->lod_rt_max = floorf(log2f(PROBE_RT_SIZE)) - 2.0f; #else pinfo->shres = 32; /* Less texture fetches & reduce branches */ - pinfo->lodmax = 2.0f; /* Improve cache reuse */ + pinfo->lod_rt_max = 2.0f; /* Improve cache reuse */ #endif DRW_framebuffer_viewport_size(sldata->probe_filter_fb, x, y, size[0], size[1]); @@ -936,9 +940,6 @@ static void diffuse_filter_probe(EEVEE_SceneLayerData *sldata, EEVEE_PassList *p /* reattach to have a valid framebuffer. */ DRW_framebuffer_texture_detach(sldata->irradiance_rt); DRW_framebuffer_texture_attach(sldata->probe_filter_fb, sldata->probe_pool, 0, 0); - - /* restore */ - pinfo->lodmax = lodmax; } /* Render the scene to the probe_rt texture. */ @@ -1294,7 +1295,10 @@ update_planar: /* If there is at least one planar probe */ if (pinfo->num_planar > 0) { - DRW_framebuffer_recursive_downsample(vedata->fbl->minmaxz_fb, txl->planar_pool, 5, &downsample_planar, vedata); + const int max_lod = 5; + DRW_framebuffer_recursive_downsample(vedata->fbl->minmaxz_fb, txl->planar_pool, max_lod, &downsample_planar, vedata); + /* For shading, save max level of the planar map */ + pinfo->lod_planar_max = (float)(max_lod); } } diff --git a/source/blender/draw/engines/eevee/eevee_materials.c b/source/blender/draw/engines/eevee/eevee_materials.c index 5393c8d305e..3b25277c8ae 100644 --- a/source/blender/draw/engines/eevee/eevee_materials.c +++ b/source/blender/draw/engines/eevee/eevee_materials.c @@ -77,6 +77,8 @@ static struct { float viewvecs[2][4]; } e_data = {NULL}; /* Engine data */ +extern char datatoc_lamps_lib_glsl[]; +extern char datatoc_lightprobe_lib_glsl[]; extern char datatoc_ambient_occlusion_lib_glsl[]; extern char datatoc_prepass_frag_glsl[]; extern char datatoc_prepass_vert_glsl[]; @@ -211,7 +213,8 @@ static void add_standard_uniforms(DRWShadingGroup *shgrp, EEVEE_SceneLayerData * DRW_shgroup_uniform_int(shgrp, "grid_count", &sldata->probes->num_render_grid, 1); DRW_shgroup_uniform_int(shgrp, "planar_count", &sldata->probes->num_planar, 1); DRW_shgroup_uniform_bool(shgrp, "specToggle", &sldata->probes->specular_toggle, 1); - DRW_shgroup_uniform_float(shgrp, "lodMax", &sldata->probes->lodmax, 1); + DRW_shgroup_uniform_float(shgrp, "lodCubeMax", &sldata->probes->lod_cube_max, 1); + DRW_shgroup_uniform_float(shgrp, "lodPlanarMax", &sldata->probes->lod_planar_max, 1); DRW_shgroup_uniform_texture(shgrp, "utilTex", e_data.util_tex); DRW_shgroup_uniform_buffer(shgrp, "probeCubes", &sldata->probe_pool); DRW_shgroup_uniform_buffer(shgrp, "probePlanars", &vedata->txl->planar_pool); @@ -252,8 +255,10 @@ void EEVEE_materials_init(void) BLI_dynstr_append(ds_frag, datatoc_ambient_occlusion_lib_glsl); BLI_dynstr_append(ds_frag, datatoc_octahedron_lib_glsl); BLI_dynstr_append(ds_frag, datatoc_irradiance_lib_glsl); + BLI_dynstr_append(ds_frag, datatoc_lightprobe_lib_glsl); BLI_dynstr_append(ds_frag, datatoc_ltc_lib_glsl); BLI_dynstr_append(ds_frag, datatoc_bsdf_direct_lib_glsl); + BLI_dynstr_append(ds_frag, datatoc_lamps_lib_glsl); BLI_dynstr_append(ds_frag, datatoc_lit_surface_frag_glsl); e_data.frag_shader_lib = BLI_dynstr_get_cstring(ds_frag); BLI_dynstr_free(ds_frag); diff --git a/source/blender/draw/engines/eevee/eevee_private.h b/source/blender/draw/engines/eevee/eevee_private.h index 14b0d270dc9..0c4de70be1b 100644 --- a/source/blender/draw/engines/eevee/eevee_private.h +++ b/source/blender/draw/engines/eevee/eevee_private.h @@ -250,7 +250,7 @@ typedef struct EEVEE_LightProbesInfo { float invsamples_ct; float roughness; float lodfactor; - float lodmax; + float lod_rt_max, lod_cube_max, lod_planar_max; int shres; int shnbr; bool specular_toggle; diff --git a/source/blender/draw/engines/eevee/shaders/ambient_occlusion_lib.glsl b/source/blender/draw/engines/eevee/shaders/ambient_occlusion_lib.glsl index 5a7e893deb6..5fcc24d1a73 100644 --- a/source/blender/draw/engines/eevee/shaders/ambient_occlusion_lib.glsl +++ b/source/blender/draw/engines/eevee/shaders/ambient_occlusion_lib.glsl @@ -213,4 +213,29 @@ float gtao_multibounce(float visibility, vec3 albedo) float x = visibility; return max(x, ((x * a + b) * x + c) * x); -}
\ No newline at end of file +} + +/* Use the right occlusion */ +float occlusion_compute(vec3 N, vec3 vpos, float user_occlusion, vec2 randuv, out vec3 bent_normal) +{ +#ifdef USE_AO /* Screen Space Occlusion */ + + float computed_occlusion; + vec3 vnor = mat3(ViewMatrix) * N; + +#ifdef USE_BENT_NORMAL + gtao(vnor, vpos, randuv, computed_occlusion, bent_normal); + bent_normal = mat3(ViewMatrixInverse) * bent_normal; +#else + gtao(vnor, vpos, randuv, computed_occlusion); + bent_normal = N; +#endif + return min(computed_occlusion, user_occlusion); + +#else /* No added Occlusion. */ + + bent_normal = N; + return user_occlusion; + +#endif +} diff --git a/source/blender/draw/engines/eevee/shaders/bsdf_common_lib.glsl b/source/blender/draw/engines/eevee/shaders/bsdf_common_lib.glsl index 3327c5c4427..bd3fedf76ed 100644 --- a/source/blender/draw/engines/eevee/shaders/bsdf_common_lib.glsl +++ b/source/blender/draw/engines/eevee/shaders/bsdf_common_lib.glsl @@ -9,61 +9,14 @@ #define LUT_SIZE 64 uniform mat4 ProjectionMatrix; +uniform mat4 ViewMatrixInverse; +uniform mat4 ViewMatrix; uniform vec4 viewvecs[2]; -/* ------- Structures -------- */ - -struct ProbeData { - vec4 position_type; - vec4 attenuation_fac_type; - mat4 influencemat; - mat4 parallaxmat; -}; +#define cameraForward normalize(ViewMatrixInverse[2].xyz) +#define cameraPos ViewMatrixInverse[3].xyz -#define PROBE_PARALLAX_BOX 1.0 -#define PROBE_ATTENUATION_BOX 1.0 - -#define p_position position_type.xyz -#define p_parallax_type position_type.w -#define p_atten_fac attenuation_fac_type.x -#define p_atten_type attenuation_fac_type.y - -struct PlanarData { - vec4 plane_equation; - vec4 clip_vec_x_fade_scale; - vec4 clip_vec_y_fade_bias; - vec4 clip_edges; - vec4 facing_scale_bias; - mat4 reflectionmat; /* transform world space into reflection texture space */ -}; - -#define pl_plane_eq plane_equation -#define pl_normal plane_equation.xyz -#define pl_facing_scale facing_scale_bias.x -#define pl_facing_bias facing_scale_bias.y -#define pl_fade_scale clip_vec_x_fade_scale.w -#define pl_fade_bias clip_vec_y_fade_bias.w -#define pl_clip_pos_x clip_vec_x_fade_scale.xyz -#define pl_clip_pos_y clip_vec_y_fade_bias.xyz -#define pl_clip_edges clip_edges - -struct GridData { - mat4 localmat; - ivec4 resolution_offset; - vec4 ws_corner_atten_scale; /* world space corner position */ - vec4 ws_increment_x_atten_bias; /* world space vector between 2 opposite cells */ - vec4 ws_increment_y; - vec4 ws_increment_z; -}; - -#define g_corner ws_corner_atten_scale.xyz -#define g_atten_scale ws_corner_atten_scale.w -#define g_atten_bias ws_increment_x_atten_bias.w -#define g_increment_x ws_increment_x_atten_bias.xyz -#define g_increment_y ws_increment_y.xyz -#define g_increment_z ws_increment_z.xyz -#define g_resolution resolution_offset.xyz -#define g_offset resolution_offset.w +/* ------- Structures -------- */ struct LightData { vec4 position_influence; /* w : InfluenceRadius */ @@ -126,14 +79,15 @@ struct ShadowCascadeData { struct ShadingData { vec3 V; /* View vector */ vec3 N; /* World Normal of the fragment */ - vec3 W; /* World Position of the fragment */ - vec3 l_vector; /* Current Light vector */ }; +#define cameraVec ((ProjectionMatrix[3][3] == 0.0) ? normalize(cameraPos - worldPosition) : cameraForward) + /* ------- Convenience functions --------- */ vec3 mul(mat3 m, vec3 v) { return m * v; } mat3 mul(mat3 m1, mat3 m2) { return m1 * m2; } +vec3 transform_point(mat4 m, vec3 v) { return (m * vec4(v, 1.0)).xyz; } float min_v3(vec3 v) { return min(v.x, min(v.y, v.z)); } @@ -288,8 +242,9 @@ vec3 get_view_space_from_depth(vec2 uvcoords, float depth) } } -vec3 get_specular_dominant_dir(vec3 N, vec3 R, float roughness) +vec3 get_specular_dominant_dir(vec3 N, vec3 V, float roughness) { + vec3 R = -reflect(V, N); float smoothness = 1.0 - roughness; float fac = smoothness * (sqrt(smoothness) + roughness); return normalize(mix(N, R, fac)); @@ -362,3 +317,8 @@ float bsdf_ggx(vec3 N, vec3 L, vec3 V, float roughness) /* bsdf = D * G / (4.0 * NL * NV); /* Reference function */ return NL * a2 / (D * G); /* NL to Fit cycles Equation : line. 345 in bsdf_microfacet.h */ } + +void accumulate_light(vec3 light, float fac, inout vec4 accum) +{ + accum += vec4(light, 1.0) * min(fac, (1.0 - accum.a)); +}
\ No newline at end of file diff --git a/source/blender/draw/engines/eevee/shaders/bsdf_direct_lib.glsl b/source/blender/draw/engines/eevee/shaders/bsdf_direct_lib.glsl index a1a5fab03af..a68b44838f1 100644 --- a/source/blender/draw/engines/eevee/shaders/bsdf_direct_lib.glsl +++ b/source/blender/draw/engines/eevee/shaders/bsdf_direct_lib.glsl @@ -11,10 +11,10 @@ /* ------------ Diffuse ------------- */ -float direct_diffuse_point(LightData ld, ShadingData sd) +float direct_diffuse_point(ShadingData sd, vec4 l_vector) { - float dist = length(sd.l_vector); - vec3 L = sd.l_vector / dist; + float dist = l_vector.w; + vec3 L = l_vector.xyz / dist; float bsdf = max(0.0, dot(sd.N, L)); bsdf /= dist * dist; return bsdf; @@ -29,12 +29,12 @@ float direct_diffuse_sun(LightData ld, ShadingData sd) } /* From Frostbite PBR Course - * Analitical irradiance from a sphere with correct horizon handling + * Analytical irradiance from a sphere with correct horizon handling * http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf */ -float direct_diffuse_sphere(LightData ld, ShadingData sd) +float direct_diffuse_sphere(LightData ld, ShadingData sd, vec4 l_vector) { - float dist = length(sd.l_vector); - vec3 L = sd.l_vector / dist; + float dist = l_vector.w; + vec3 L = l_vector.xyz / dist; float radius = max(ld.l_sizex, 0.0001); float costheta = clamp(dot(sd.N, L), -0.999, 0.999); float h = min(ld.l_radius / dist , 0.9999); @@ -61,13 +61,13 @@ float direct_diffuse_sphere(LightData ld, ShadingData sd) /* From Frostbite PBR Course * http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf */ -float direct_diffuse_rectangle(LightData ld, ShadingData sd) +float direct_diffuse_rectangle(LightData ld, ShadingData sd, vec4 l_vector) { vec3 corners[4]; - corners[0] = sd.l_vector + ld.l_right * -ld.l_sizex + ld.l_up * ld.l_sizey; - corners[1] = sd.l_vector + ld.l_right * -ld.l_sizex + ld.l_up * -ld.l_sizey; - corners[2] = sd.l_vector + ld.l_right * ld.l_sizex + ld.l_up * -ld.l_sizey; - corners[3] = sd.l_vector + ld.l_right * ld.l_sizex + ld.l_up * ld.l_sizey; + corners[0] = l_vector.xyz + ld.l_right * -ld.l_sizex + ld.l_up * ld.l_sizey; + corners[1] = l_vector.xyz + ld.l_right * -ld.l_sizex + ld.l_up * -ld.l_sizey; + corners[2] = l_vector.xyz + ld.l_right * ld.l_sizex + ld.l_up * -ld.l_sizey; + corners[3] = l_vector.xyz + ld.l_right * ld.l_sizex + ld.l_up * ld.l_sizey; float bsdf = ltc_evaluate(sd.N, sd.V, mat3(1.0), corners); bsdf *= M_1_2PI; @@ -83,10 +83,10 @@ float direct_diffuse_unit_disc(vec3 N, vec3 L) #endif /* ----------- GGx ------------ */ -vec3 direct_ggx_point(ShadingData sd, float roughness, vec3 f0) +vec3 direct_ggx_point(ShadingData sd, vec4 l_vector, float roughness, vec3 f0) { - float dist = length(sd.l_vector); - vec3 L = sd.l_vector / dist; + float dist = l_vector.w; + vec3 L = l_vector.xyz / dist; float bsdf = bsdf_ggx(sd.N, L, sd.V, roughness); bsdf /= dist * dist; @@ -102,13 +102,13 @@ vec3 direct_ggx_sun(LightData ld, ShadingData sd, float roughness, vec3 f0) return F_schlick(f0, VH) * bsdf; } -vec3 direct_ggx_sphere(LightData ld, ShadingData sd, float roughness, vec3 f0) +vec3 direct_ggx_sphere(LightData ld, ShadingData sd, vec4 l_vector, float roughness, vec3 f0) { - vec3 L = normalize(sd.l_vector); - vec3 spec_dir = get_specular_dominant_dir(sd.N, reflect(-sd.V, sd.N), roughness); - vec3 P = line_aligned_plane_intersect(vec3(0.0), spec_dir, sd.l_vector); + vec3 L = l_vector.xyz / l_vector.w; + vec3 spec_dir = get_specular_dominant_dir(sd.N, sd.V, roughness); + vec3 P = line_aligned_plane_intersect(vec3(0.0), spec_dir, l_vector.xyz); - vec3 Px = normalize(P - sd.l_vector) * ld.l_radius; + vec3 Px = normalize(P - l_vector.xyz) * ld.l_radius; vec3 Py = cross(Px, L); vec2 uv = lut_coords(dot(sd.N, sd.V), sqrt(roughness)); @@ -123,21 +123,21 @@ vec3 direct_ggx_sphere(LightData ld, ShadingData sd, float roughness, vec3 f0) /* counter clockwise */ vec3 points[8]; - points[0] = sd.l_vector + Px; - points[1] = sd.l_vector - Pxy2; - points[2] = sd.l_vector - Py; - points[3] = sd.l_vector - Pxy1; - points[4] = sd.l_vector - Px; - points[5] = sd.l_vector + Pxy2; - points[6] = sd.l_vector + Py; - points[7] = sd.l_vector + Pxy1; + points[0] = l_vector.xyz + Px; + points[1] = l_vector.xyz - Pxy2; + points[2] = l_vector.xyz - Py; + points[3] = l_vector.xyz - Pxy1; + points[4] = l_vector.xyz - Px; + points[5] = l_vector.xyz + Pxy2; + points[6] = l_vector.xyz + Py; + points[7] = l_vector.xyz + Pxy1; float bsdf = ltc_evaluate_circle(sd.N, sd.V, ltc_mat, points); #else vec3 points[4]; - points[0] = sd.l_vector + Px; - points[1] = sd.l_vector - Py; - points[2] = sd.l_vector - Px; - points[3] = sd.l_vector + Py; + points[0] = l_vector.xyz + Px; + points[1] = l_vector.xyz - Py; + points[2] = l_vector.xyz - Px; + points[3] = l_vector.xyz + Py; float bsdf = ltc_evaluate(sd.N, sd.V, ltc_mat, points); /* sqrt(pi/2) difference between square and disk area */ bsdf *= 1.25331413731; @@ -151,13 +151,13 @@ vec3 direct_ggx_sphere(LightData ld, ShadingData sd, float roughness, vec3 f0) return spec; } -vec3 direct_ggx_rectangle(LightData ld, ShadingData sd, float roughness, vec3 f0) +vec3 direct_ggx_rectangle(LightData ld, ShadingData sd, vec4 l_vector, float roughness, vec3 f0) { vec3 corners[4]; - corners[0] = sd.l_vector + ld.l_right * -ld.l_sizex + ld.l_up * ld.l_sizey; - corners[1] = sd.l_vector + ld.l_right * -ld.l_sizex + ld.l_up * -ld.l_sizey; - corners[2] = sd.l_vector + ld.l_right * ld.l_sizex + ld.l_up * -ld.l_sizey; - corners[3] = sd.l_vector + ld.l_right * ld.l_sizex + ld.l_up * ld.l_sizey; + corners[0] = l_vector.xyz + ld.l_right * -ld.l_sizex + ld.l_up * ld.l_sizey; + corners[1] = l_vector.xyz + ld.l_right * -ld.l_sizex + ld.l_up * -ld.l_sizey; + corners[2] = l_vector.xyz + ld.l_right * ld.l_sizex + ld.l_up * -ld.l_sizey; + corners[3] = l_vector.xyz + ld.l_right * ld.l_sizex + ld.l_up * ld.l_sizey; vec2 uv = lut_coords(dot(sd.N, sd.V), sqrt(roughness)); vec3 brdf_lut = texture(utilTex, vec3(uv, 1.0)).rgb; diff --git a/source/blender/draw/engines/eevee/shaders/irradiance_lib.glsl b/source/blender/draw/engines/eevee/shaders/irradiance_lib.glsl index 0f95d552d1f..95e7af41398 100644 --- a/source/blender/draw/engines/eevee/shaders/irradiance_lib.glsl +++ b/source/blender/draw/engines/eevee/shaders/irradiance_lib.glsl @@ -1,6 +1,8 @@ uniform sampler2D irradianceGrid; +#define IRRADIANCE_LIB + #ifdef IRRADIANCE_CUBEMAP struct IrradianceData { vec3 color; @@ -132,10 +134,8 @@ vec3 compute_irradiance(vec3 N, IrradianceData ird) #endif } -vec3 get_cell_color(ivec3 localpos, ivec3 gridres, int offset, vec3 ir_dir) +vec3 irradiance_from_cell_get(int cell, vec3 ir_dir) { - /* Keep in sync with update_irradiance_probe */ - int cell = offset + localpos.z + localpos.y * gridres.z + localpos.x * gridres.z * gridres.y; IrradianceData ir_data = load_irradiance_cell(cell, ir_dir); return compute_irradiance(ir_dir, ir_data); } diff --git a/source/blender/draw/engines/eevee/shaders/lamps_lib.glsl b/source/blender/draw/engines/eevee/shaders/lamps_lib.glsl new file mode 100644 index 00000000000..b031b45d1c4 --- /dev/null +++ b/source/blender/draw/engines/eevee/shaders/lamps_lib.glsl @@ -0,0 +1,193 @@ + +uniform sampler2DArray shadowCubes; +uniform sampler2DArrayShadow shadowCascades; + +layout(std140) uniform shadow_block { + ShadowCubeData shadows_cube_data[MAX_SHADOW_CUBE]; + ShadowMapData shadows_map_data[MAX_SHADOW_MAP]; + ShadowCascadeData shadows_cascade_data[MAX_SHADOW_CASCADE]; +}; + +layout(std140) uniform probe_block { + CubeData probes_data[MAX_PROBE]; +}; + +layout(std140) uniform grid_block { + GridData grids_data[MAX_GRID]; +}; + +layout(std140) uniform planar_block { + PlanarData planars_data[MAX_PLANAR]; +}; + +layout(std140) uniform light_block { + LightData lights_data[MAX_LIGHT]; +}; + +/* type */ +#define POINT 0.0 +#define SUN 1.0 +#define SPOT 2.0 +#define HEMI 3.0 +#define AREA 4.0 + +float shadow_cubemap(float shid, vec3 l_vector, vec3 W) +{ + ShadowCubeData scd = shadows_cube_data[int(shid)]; + + vec3 cubevec = W - l_vector; + float dist = length(cubevec) - scd.sh_cube_bias; + + float z = texture_octahedron(shadowCubes, vec4(cubevec, shid)).r; + + float esm_test = saturate(exp(scd.sh_cube_exp * (z - dist))); + // float sh_test = step(0, z - dist); + + return esm_test; +} + +float shadow_cascade(float shid, vec3 W) +{ + /* Shadow Cascade */ + shid -= (MAX_SHADOW_CUBE + MAX_SHADOW_MAP); + ShadowCascadeData smd = shadows_cascade_data[int(shid)]; + + /* Finding Cascade index */ + vec4 z = vec4(-dot(cameraPos - W, cameraForward)); + vec4 comp = step(z, smd.split_distances); + float cascade = dot(comp, comp); + mat4 shadowmat; + float bias; + + /* Manual Unrolling of a loop for better performance. + * Doing fetch directly with cascade index leads to + * major performance impact. (0.27ms -> 10.0ms for 1 light) */ + if (cascade == 0.0) { + shadowmat = smd.shadowmat[0]; + bias = smd.bias[0]; + } + else if (cascade == 1.0) { + shadowmat = smd.shadowmat[1]; + bias = smd.bias[1]; + } + else if (cascade == 2.0) { + shadowmat = smd.shadowmat[2]; + bias = smd.bias[2]; + } + else { + shadowmat = smd.shadowmat[3]; + bias = smd.bias[3]; + } + + vec4 shpos = shadowmat * vec4(W, 1.0); + shpos.z -= bias * shpos.w; + shpos.xyz /= shpos.w; + + return texture(shadowCascades, vec4(shpos.xy, shid * float(MAX_CASCADE_NUM) + cascade, shpos.z)); +} + +float light_visibility(LightData ld, vec3 W, vec3 l_vector) +{ + float vis = 1.0; + + if (ld.l_type == SPOT) { + float z = dot(ld.l_forward, l_vector); + vec3 lL = l_vector / z; + float x = dot(ld.l_right, lL) / ld.l_sizex; + float y = dot(ld.l_up, lL) / ld.l_sizey; + + float ellipse = 1.0 / sqrt(1.0 + x * x + y * y); + + float spotmask = smoothstep(0.0, 1.0, (ellipse - ld.l_spot_size) / ld.l_spot_blend); + + vis *= spotmask; + vis *= step(0.0, -dot(l_vector, ld.l_forward)); + } + else if (ld.l_type == AREA) { + vis *= step(0.0, -dot(l_vector, ld.l_forward)); + } + + /* shadowing */ + if (ld.l_shadowid >= (MAX_SHADOW_MAP + MAX_SHADOW_CUBE)) { + vis *= shadow_cascade(ld.l_shadowid, W); + } + else if (ld.l_shadowid >= 0.0) { + vis *= shadow_cubemap(ld.l_shadowid, l_vector, W); + } + + return vis; +} + +float light_diffuse(LightData ld, ShadingData sd, vec4 l_vector) +{ +#ifdef USE_LTC + if (ld.l_type == SUN) { + /* TODO disk area light */ + return direct_diffuse_sun(ld, sd); + } + else if (ld.l_type == AREA) { + return direct_diffuse_rectangle(ld, sd, l_vector); + } + else { + return direct_diffuse_sphere(ld, sd, l_vector); + } +#else + if (ld.l_type == SUN) { + return direct_diffuse_sun(ld, sd); + } + else { + return direct_diffuse_point(sd, l_vector); + } +#endif +} + +vec3 light_specular(LightData ld, ShadingData sd, vec4 l_vector, float roughness, vec3 f0) +{ +#ifdef USE_LTC + if (ld.l_type == SUN) { + /* TODO disk area light */ + return direct_ggx_sun(ld, sd, roughness, f0); + } + else if (ld.l_type == AREA) { + return direct_ggx_rectangle(ld, sd, l_vector, roughness, f0); + } + else { + return direct_ggx_sphere(ld, sd, l_vector, roughness, f0); + } +#else + if (ld.l_type == SUN) { + return direct_ggx_sun(ld, sd, roughness, f0); + } + else { + return direct_ggx_point(sd, l_vector, roughness, f0); + } +#endif +} + +#ifdef HAIR_SHADER +void light_hair_common( + LightData ld, ShadingData sd, vec4 l_vector, vec3 norm_view, + out float occlu_trans, out float occlu, + out vec3 norm_lamp, out vec3 view_vec) +{ + const float transmission = 0.3; /* Uniform internal scattering factor */ + + vec3 lamp_vec; + + if (ld.l_type == SUN || ld.l_type == AREA) { + lamp_vec = ld.l_forward; + } + else { + lamp_vec = -l_vector.xyz; + } + + norm_lamp = cross(lamp_vec, sd.N); + norm_lamp = normalize(cross(sd.N, norm_lamp)); /* Normal facing lamp */ + + /* Rotate view vector onto the cross(tangent, light) plane */ + view_vec = normalize(norm_lamp * dot(norm_view, sd.V) + sd.N * dot(sd.N, sd.V)); + + float occlusion = (dot(norm_view, norm_lamp) * 0.5 + 0.5); + float occltrans = transmission + (occlusion * (1.0 - transmission)); /* Includes transmission component */ +} +#endif diff --git a/source/blender/draw/engines/eevee/shaders/lightprobe_cube_display_frag.glsl b/source/blender/draw/engines/eevee/shaders/lightprobe_cube_display_frag.glsl index d651a866433..fc0b5b9548b 100644 --- a/source/blender/draw/engines/eevee/shaders/lightprobe_cube_display_frag.glsl +++ b/source/blender/draw/engines/eevee/shaders/lightprobe_cube_display_frag.glsl @@ -1,24 +1,15 @@ -uniform mat4 ProjectionMatrix; -uniform mat4 ViewMatrixInverse; - -uniform sampler2DArray probeCubes; -uniform float lodMax; - flat in int pid; in vec3 worldNormal; in vec3 worldPosition; out vec4 FragColor; -#define cameraForward normalize(ViewMatrixInverse[2].xyz) -#define cameraPos ViewMatrixInverse[3].xyz - void main() { vec3 V = (ProjectionMatrix[3][3] == 0.0) /* if perspective */ ? normalize(cameraPos - worldPosition) : cameraForward; vec3 N = normalize(worldNormal); - FragColor = vec4(textureLod_octahedron(probeCubes, vec4(reflect(-V, N), pid), 0.0, lodMax).rgb, 1.0); + FragColor = vec4(textureLod_octahedron(probeCubes, vec4(reflect(-V, N), pid), 0.0, lodCubeMax).rgb, 1.0); } diff --git a/source/blender/draw/engines/eevee/shaders/lightprobe_lib.glsl b/source/blender/draw/engines/eevee/shaders/lightprobe_lib.glsl new file mode 100644 index 00000000000..32da31339d1 --- /dev/null +++ b/source/blender/draw/engines/eevee/shaders/lightprobe_lib.glsl @@ -0,0 +1,245 @@ +/* ----------- Uniforms --------- */ + +uniform sampler2DArray probePlanars; +uniform float lodPlanarMax; + +uniform sampler2DArray probeCubes; +uniform float lodCubeMax; + +/* ----------- Structures --------- */ + +struct CubeData { + vec4 position_type; + vec4 attenuation_fac_type; + mat4 influencemat; + mat4 parallaxmat; +}; + +#define PROBE_PARALLAX_BOX 1.0 +#define PROBE_ATTENUATION_BOX 1.0 + +#define p_position position_type.xyz +#define p_parallax_type position_type.w +#define p_atten_fac attenuation_fac_type.x +#define p_atten_type attenuation_fac_type.y + +struct PlanarData { + vec4 plane_equation; + vec4 clip_vec_x_fade_scale; + vec4 clip_vec_y_fade_bias; + vec4 clip_edges; + vec4 facing_scale_bias; + mat4 reflectionmat; /* transform world space into reflection texture space */ +}; + +#define pl_plane_eq plane_equation +#define pl_normal plane_equation.xyz +#define pl_facing_scale facing_scale_bias.x +#define pl_facing_bias facing_scale_bias.y +#define pl_fade_scale clip_vec_x_fade_scale.w +#define pl_fade_bias clip_vec_y_fade_bias.w +#define pl_clip_pos_x clip_vec_x_fade_scale.xyz +#define pl_clip_pos_y clip_vec_y_fade_bias.xyz +#define pl_clip_edges clip_edges + +struct GridData { + mat4 localmat; + ivec4 resolution_offset; + vec4 ws_corner_atten_scale; /* world space corner position */ + vec4 ws_increment_x_atten_bias; /* world space vector between 2 opposite cells */ + vec4 ws_increment_y; + vec4 ws_increment_z; +}; + +#define g_corner ws_corner_atten_scale.xyz +#define g_atten_scale ws_corner_atten_scale.w +#define g_atten_bias ws_increment_x_atten_bias.w +#define g_increment_x ws_increment_x_atten_bias.xyz +#define g_increment_y ws_increment_y.xyz +#define g_increment_z ws_increment_z.xyz +#define g_resolution resolution_offset.xyz +#define g_offset resolution_offset.w + +/* ----------- Functions --------- */ + +float probe_attenuation_cube(CubeData pd, vec3 W) +{ + vec3 localpos = transform_point(pd.influencemat, W); + + float fac; + if (pd.p_atten_type == PROBE_ATTENUATION_BOX) { + vec3 axes_fac = saturate(pd.p_atten_fac - pd.p_atten_fac * abs(localpos)); + fac = min_v3(axes_fac); + } + else { + fac = saturate(pd.p_atten_fac - pd.p_atten_fac * length(localpos)); + } + + return fac; +} + +float probe_attenuation_planar(PlanarData pd, vec3 W, vec3 N) +{ + /* Normal Facing */ + float fac = saturate(dot(pd.pl_normal, N) * pd.pl_facing_scale + pd.pl_facing_bias); + + /* Distance from plane */ + fac *= saturate(abs(dot(pd.pl_plane_eq, vec4(W, 1.0))) * pd.pl_fade_scale + pd.pl_fade_bias); + + /* Fancy fast clipping calculation */ + vec2 dist_to_clip; + dist_to_clip.x = dot(pd.pl_clip_pos_x, W); + dist_to_clip.y = dot(pd.pl_clip_pos_y, W); + fac *= step(2.0, dot(step(pd.pl_clip_edges, dist_to_clip.xxyy), vec2(-1.0, 1.0).xyxy)); /* compare and add all tests */ + + return fac; +} + +float probe_attenuation_grid(GridData gd, vec3 W, out vec3 localpos) +{ + localpos = transform_point(gd.localmat, W); + + float fade = min(1.0, min_v3(1.0 - abs(localpos))); + return saturate(fade * gd.g_atten_scale + gd.g_atten_bias); +} + +vec3 probe_evaluate_cube(float id, CubeData cd, vec3 W, vec3 R, float roughness) +{ + /* Correct reflection ray using parallax volume intersection. */ + vec3 localpos = transform_point(cd.parallaxmat, W); + vec3 localray = mat3(cd.parallaxmat) * R; + + float dist; + if (cd.p_parallax_type == PROBE_PARALLAX_BOX) { + dist = line_unit_box_intersect_dist(localpos, localray); + } + else { + dist = line_unit_sphere_intersect_dist(localpos, localray); + } + + /* Use Distance in WS directly to recover intersection */ + vec3 intersection = W + R * dist - cd.p_position; + + /* From Frostbite PBR Course + * Distance based roughness + * http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf */ + float original_roughness = roughness; + float linear_roughness = sqrt(roughness); + float distance_roughness = saturate(dist * linear_roughness / length(intersection)); + linear_roughness = mix(distance_roughness, linear_roughness, linear_roughness); + roughness = linear_roughness * linear_roughness; + + float fac = saturate(original_roughness * 2.0 - 1.0); + R = mix(intersection, R, fac * fac); + + return textureLod_octahedron(probeCubes, vec4(R, id), roughness * lodCubeMax, lodCubeMax).rgb; +} + +vec3 probe_evaluate_world_spec(vec3 R, float roughness) +{ + return textureLod_octahedron(probeCubes, vec4(R, 0.0), roughness * lodCubeMax, lodCubeMax).rgb; +} + +vec3 probe_evaluate_planar( + float id, PlanarData pd, vec3 W, vec3 N, vec3 V, + float rand, vec3 camera_pos, float roughness, + inout float fade) +{ + /* Sample reflection depth. */ + vec4 refco = pd.reflectionmat * vec4(W, 1.0); + refco.xy /= refco.w; + float ref_depth = textureLod(probePlanars, vec3(refco.xy, id), 0.0).a; + + /* Find view vector / reflection plane intersection. (dist_to_plane is negative) */ + float dist_to_plane = line_plane_intersect_dist(camera_pos, V, pd.pl_plane_eq); + vec3 point_on_plane = camera_pos + V * dist_to_plane; + + /* How far the pixel is from the plane. */ + ref_depth = ref_depth + dist_to_plane; + + /* Compute distorded reflection vector based on the distance to the reflected object. + * In other words find intersection between reflection vector and the sphere center + * around point_on_plane. */ + vec3 proj_ref = reflect(reflect(-V, N) * ref_depth, pd.pl_normal); + + /* Final point in world space. */ + vec3 ref_pos = point_on_plane + proj_ref; + + /* Reproject to find texture coords. */ + refco = pd.reflectionmat * vec4(ref_pos, 1.0); + refco.xy /= refco.w; + + /* Distance to roughness */ + float linear_roughness = sqrt(roughness); + float distance_roughness = min(linear_roughness, ref_depth * linear_roughness); + linear_roughness = mix(distance_roughness, linear_roughness, linear_roughness); + + /* Decrease influence for high roughness */ + fade *= saturate((1.0 - linear_roughness) * 5.0 - 2.0); + + float lod = linear_roughness * 2.5 * lodPlanarMax; + vec3 sample = textureLod(probePlanars, vec3(refco.xy, id), lod).rgb; + + /* Use a second sample randomly rotated to blur out the lowres aspect */ + vec2 rot_sample = (1.0 / vec2(textureSize(probePlanars, 0).xy)) * vec2(cos(rand * M_2PI), sin(rand * M_2PI)) * lod; + sample += textureLod(probePlanars, vec3(refco.xy + rot_sample, id), lod).rgb; + sample *= 0.5; + + return sample; +} + +#ifdef IRRADIANCE_LIB +vec3 probe_evaluate_grid(GridData gd, vec3 W, vec3 N, vec3 localpos) +{ + localpos = localpos * 0.5 + 0.5; + localpos = localpos * vec3(gd.g_resolution) - 0.5; + + vec3 localpos_floored = floor(localpos); + vec3 trilinear_weight = fract(localpos); + + float weight_accum = 0.0; + vec3 irradiance_accum = vec3(0.0); + + /* For each neighboor cells */ + for (int i = 0; i < 8; ++i) { + ivec3 offset = ivec3(i, i >> 1, i >> 2) & ivec3(1); + vec3 cell_cos = clamp(localpos_floored + vec3(offset), vec3(0.0), vec3(gd.g_resolution) - 1.0); + + /* Keep in sync with update_irradiance_probe */ + ivec3 icell_cos = ivec3(cell_cos); + int cell = gd.g_offset + icell_cos.z + icell_cos.y * gd.g_resolution.z + icell_cos.x * gd.g_resolution.z * gd.g_resolution.y; + + vec3 color = irradiance_from_cell_get(cell, N); + + /* We need this because we render probes in world space (so we need light vector in WS). + * And rendering them in local probe space is too much problem. */ + vec3 ws_cell_location = gd.g_corner + + (gd.g_increment_x * cell_cos.x + + gd.g_increment_y * cell_cos.y + + gd.g_increment_z * cell_cos.z); + + // vec3 ws_point_to_cell = ws_cell_location - W; + // vec3 ws_light = normalize(ws_point_to_cell); + + vec3 trilinear = mix(1 - trilinear_weight, trilinear_weight, offset); + float weight = trilinear.x * trilinear.y * trilinear.z; + + /* Smooth backface test */ + // weight *= sqrt(max(0.002, dot(ws_light, N))); + + /* Avoid zero weight */ + weight = max(0.00001, weight); + + weight_accum += weight; + irradiance_accum += color * weight; + } + + return irradiance_accum / weight_accum; +} + +vec3 probe_evaluate_world_diff(vec3 N) +{ + return irradiance_from_cell_get(0, N); +} + +#endif /* IRRADIANCE_LIB */ diff --git a/source/blender/draw/engines/eevee/shaders/lightprobe_planar_display_frag.glsl b/source/blender/draw/engines/eevee/shaders/lightprobe_planar_display_frag.glsl index 338dc3bf9c0..2cb43336ace 100644 --- a/source/blender/draw/engines/eevee/shaders/lightprobe_planar_display_frag.glsl +++ b/source/blender/draw/engines/eevee/shaders/lightprobe_planar_display_frag.glsl @@ -1,6 +1,5 @@ uniform int probeIdx; -uniform sampler2DArray probePlanars; layout(std140) uniform planar_block { PlanarData planars_data[MAX_PLANAR]; diff --git a/source/blender/draw/engines/eevee/shaders/lit_surface_frag.glsl b/source/blender/draw/engines/eevee/shaders/lit_surface_frag.glsl index d6cc170f025..6ee87641e1f 100644 --- a/source/blender/draw/engines/eevee/shaders/lit_surface_frag.glsl +++ b/source/blender/draw/engines/eevee/shaders/lit_surface_frag.glsl @@ -3,13 +3,7 @@ uniform int light_count; uniform int probe_count; uniform int grid_count; uniform int planar_count; -uniform mat4 ViewMatrix; -uniform mat4 ViewMatrixInverse; -uniform sampler2DArray probePlanars; - -uniform sampler2DArray probeCubes; -uniform float lodMax; uniform bool specToggle; #ifndef UTIL_TEX @@ -17,31 +11,6 @@ uniform bool specToggle; uniform sampler2DArray utilTex; #endif /* UTIL_TEX */ -uniform sampler2DArray shadowCubes; -uniform sampler2DArrayShadow shadowCascades; - -layout(std140) uniform probe_block { - ProbeData probes_data[MAX_PROBE]; -}; - -layout(std140) uniform grid_block { - GridData grids_data[MAX_GRID]; -}; - -layout(std140) uniform planar_block { - PlanarData planars_data[MAX_PLANAR]; -}; - -layout(std140) uniform light_block { - LightData lights_data[MAX_LIGHT]; -}; - -layout(std140) uniform shadow_block { - ShadowCubeData shadows_cube_data[MAX_SHADOW_CUBE]; - ShadowMapData shadows_map_data[MAX_SHADOW_MAP]; - ShadowCascadeData shadows_cascade_data[MAX_SHADOW_CASCADE]; -}; - in vec3 worldPosition; in vec3 viewPosition; @@ -53,481 +22,131 @@ in vec3 worldNormal; in vec3 viewNormal; #endif -#define cameraForward normalize(ViewMatrixInverse[2].xyz) -#define cameraPos ViewMatrixInverse[3].xyz - -/* type */ -#define POINT 0.0 -#define SUN 1.0 -#define SPOT 2.0 -#define HEMI 3.0 -#define AREA 4.0 - -#ifdef HAIR_SHADER -vec3 light_diffuse(LightData ld, ShadingData sd, vec3 albedo) -{ - if (ld.l_type == SUN) { - return direct_diffuse_sun(ld, sd) * albedo; - } - else if (ld.l_type == AREA) { - return direct_diffuse_rectangle(ld, sd) * albedo; - } - else { - return direct_diffuse_sphere(ld, sd) * albedo; - } -} - -vec3 light_specular(LightData ld, ShadingData sd, float roughness, vec3 f0) -{ - if (ld.l_type == SUN) { - return direct_ggx_sun(ld, sd, roughness, f0); - } - else if (ld.l_type == AREA) { - return direct_ggx_rectangle(ld, sd, roughness, f0); - } - else { - return direct_ggx_sphere(ld, sd, roughness, f0); - } -} - -void light_shade( - LightData ld, ShadingData sd, vec3 albedo, float roughness, vec3 f0, - out vec3 diffuse, out vec3 specular) -{ - const float transmission = 0.3; /* Uniform internal scattering factor */ - ShadingData sd_new = sd; - - vec3 lamp_vec; - - if (ld.l_type == SUN || ld.l_type == AREA) { - lamp_vec = ld.l_forward; - } - else { - lamp_vec = -sd.l_vector; - } - - vec3 norm_view = cross(sd.V, sd.N); - norm_view = normalize(cross(norm_view, sd.N)); /* Normal facing view */ - - vec3 norm_lamp = cross(lamp_vec, sd.N); - norm_lamp = normalize(cross(sd.N, norm_lamp)); /* Normal facing lamp */ - - /* Rotate view vector onto the cross(tangent, light) plane */ - vec3 view_vec = normalize(norm_lamp * dot(norm_view, sd.V) + sd.N * dot(sd.N, sd.V)); - - float occlusion = (dot(norm_view, norm_lamp) * 0.5 + 0.5); - float occltrans = transmission + (occlusion * (1.0 - transmission)); /* Includes transmission component */ - - sd_new.N = -norm_lamp; - - diffuse = light_diffuse(ld, sd_new, albedo) * occltrans; - - sd_new.V = view_vec; - - specular = light_specular(ld, sd_new, roughness, f0) * occlusion; -} -#else -void light_shade( - LightData ld, ShadingData sd, vec3 albedo, float roughness, vec3 f0, - out vec3 diffuse, out vec3 specular) -{ -#ifdef USE_LTC - if (ld.l_type == SUN) { - /* TODO disk area light */ - diffuse = direct_diffuse_sun(ld, sd) * albedo; - specular = direct_ggx_sun(ld, sd, roughness, f0); - } - else if (ld.l_type == AREA) { - diffuse = direct_diffuse_rectangle(ld, sd) * albedo; - specular = direct_ggx_rectangle(ld, sd, roughness, f0); - } - else { - diffuse = direct_diffuse_sphere(ld, sd) * albedo; - specular = direct_ggx_sphere(ld, sd, roughness, f0); - } -#else - if (ld.l_type == SUN) { - diffuse = direct_diffuse_sun(ld, sd) * albedo; - specular = direct_ggx_sun(ld, sd, roughness, f0); - } - else { - diffuse = direct_diffuse_point(ld, sd) * albedo; - specular = direct_ggx_point(sd, roughness, f0); - } -#endif - - specular *= float(specToggle); -} -#endif - -void light_visibility(LightData ld, ShadingData sd, out float vis) -{ - vis = 1.0; - - if (ld.l_type == SPOT) { - float z = dot(ld.l_forward, sd.l_vector); - vec3 lL = sd.l_vector / z; - float x = dot(ld.l_right, lL) / ld.l_sizex; - float y = dot(ld.l_up, lL) / ld.l_sizey; - - float ellipse = 1.0 / sqrt(1.0 + x * x + y * y); - - float spotmask = smoothstep(0.0, 1.0, (ellipse - ld.l_spot_size) / ld.l_spot_blend); - - vis *= spotmask; - vis *= step(0.0, -dot(sd.l_vector, ld.l_forward)); - } - else if (ld.l_type == AREA) { - vis *= step(0.0, -dot(sd.l_vector, ld.l_forward)); - } - - /* shadowing */ - if (ld.l_shadowid >= (MAX_SHADOW_MAP + MAX_SHADOW_CUBE)) { - /* Shadow Cascade */ - float shid = ld.l_shadowid - (MAX_SHADOW_CUBE + MAX_SHADOW_MAP); - ShadowCascadeData smd = shadows_cascade_data[int(shid)]; - - /* Finding Cascade index */ - vec4 z = vec4(-dot(cameraPos - worldPosition, cameraForward)); - vec4 comp = step(z, smd.split_distances); - float cascade = dot(comp, comp); - mat4 shadowmat; - float bias; - - /* Manual Unrolling of a loop for better performance. - * Doing fetch directly with cascade index leads to - * major performance impact. (0.27ms -> 10.0ms for 1 light) */ - if (cascade == 0.0) { - shadowmat = smd.shadowmat[0]; - bias = smd.bias[0]; - } - else if (cascade == 1.0) { - shadowmat = smd.shadowmat[1]; - bias = smd.bias[1]; - } - else if (cascade == 2.0) { - shadowmat = smd.shadowmat[2]; - bias = smd.bias[2]; - } - else { - shadowmat = smd.shadowmat[3]; - bias = smd.bias[3]; - } - - vec4 shpos = shadowmat * vec4(sd.W, 1.0); - shpos.z -= bias * shpos.w; - shpos.xyz /= shpos.w; - - vis *= texture(shadowCascades, vec4(shpos.xy, shid * float(MAX_CASCADE_NUM) + cascade, shpos.z)); - } - else if (ld.l_shadowid >= 0.0) { - /* Shadow Cube */ - float shid = ld.l_shadowid; - ShadowCubeData scd = shadows_cube_data[int(shid)]; - - vec3 cubevec = sd.W - ld.l_position; - float dist = length(cubevec) - scd.sh_cube_bias; - - float z = texture_octahedron(shadowCubes, vec4(cubevec, shid)).r; - - float esm_test = saturate(exp(scd.sh_cube_exp * (z - dist))); - float sh_test = step(0, z - dist); - - vis *= esm_test; - } -} - -vec3 probe_parallax_correction(vec3 W, vec3 spec_dir, ProbeData pd, inout float roughness) -{ - vec3 localpos = (pd.parallaxmat * vec4(W, 1.0)).xyz; - vec3 localray = (pd.parallaxmat * vec4(spec_dir, 0.0)).xyz; - - float dist; - if (pd.p_parallax_type == PROBE_PARALLAX_BOX) { - dist = line_unit_box_intersect_dist(localpos, localray); - } - else { - dist = line_unit_sphere_intersect_dist(localpos, localray); - } - - /* Use Distance in WS directly to recover intersection */ - vec3 intersection = W + spec_dir * dist - pd.p_position; - - /* From Frostbite PBR Course - * Distance based roughness - * http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf */ - float original_roughness = roughness; - float linear_roughness = sqrt(roughness); - float distance_roughness = saturate(dist * linear_roughness / length(intersection)); - linear_roughness = mix(distance_roughness, linear_roughness, linear_roughness); - roughness = linear_roughness * linear_roughness; - - float fac = saturate(original_roughness * 2.0 - 1.0); - return mix(intersection, spec_dir, fac * fac); -} - -float probe_attenuation(vec3 W, ProbeData pd) -{ - vec3 localpos = (pd.influencemat * vec4(W, 1.0)).xyz; - - float fac; - if (pd.p_atten_type == PROBE_ATTENUATION_BOX) { - vec3 axes_fac = saturate(pd.p_atten_fac - pd.p_atten_fac * abs(localpos)); - fac = min_v3(axes_fac); - } - else { - fac = saturate(pd.p_atten_fac - pd.p_atten_fac * length(localpos)); - } - - return fac; -} - -float planar_attenuation(vec3 W, vec3 N, PlanarData pd) -{ - float fac; - - /* Normal Facing */ - fac = saturate(dot(pd.pl_normal, N) * pd.pl_facing_scale + pd.pl_facing_bias); - - /* Distance from plane */ - fac *= saturate(abs(dot(pd.pl_plane_eq, vec4(W, 1.0))) * pd.pl_fade_scale + pd.pl_fade_bias); - - /* Fancy fast clipping calculation */ - vec2 dist_to_clip; - dist_to_clip.x = dot(pd.pl_clip_pos_x, W); - dist_to_clip.y = dot(pd.pl_clip_pos_y, W); - fac *= step(2.0, dot(step(pd.pl_clip_edges, dist_to_clip.xxyy), vec2(-1.0, 1.0).xyxy)); /* compare and add all tests */ - - return fac; -} - -float compute_occlusion(vec3 N, float micro_occlusion, vec2 randuv, out vec3 bent_normal) -{ -#ifdef USE_AO /* Screen Space Occlusion */ - - float macro_occlusion; - vec3 vnor = mat3(ViewMatrix) * N; - -#ifdef USE_BENT_NORMAL - gtao(vnor, viewPosition, randuv, macro_occlusion, bent_normal); - bent_normal = mat3(ViewMatrixInverse) * bent_normal; -#else - gtao(vnor, viewPosition, randuv, macro_occlusion); - bent_normal = N; -#endif - return min(macro_occlusion, micro_occlusion); - -#else /* No added Occlusion. */ - - bent_normal = N; - return micro_occlusion; - -#endif -} vec3 eevee_surface_lit(vec3 world_normal, vec3 albedo, vec3 f0, float roughness, float ao) { roughness = clamp(roughness, 1e-8, 0.9999); float roughnessSquared = roughness * roughness; - ShadingData sd; - sd.N = normalize(world_normal); - sd.V = (ProjectionMatrix[3][3] == 0.0) /* if perspective */ - ? normalize(cameraPos - worldPosition) - : cameraForward; - sd.W = worldPosition; + ShadingData sd = ShadingData(cameraVec, normalize(world_normal)); + + vec4 rand = texture(utilTex, vec3(gl_FragCoord.xy / LUT_SIZE, 2.0)); - vec3 radiance = vec3(0.0); + /* ---------------- SCENE LAMPS LIGHTING ----------------- */ #ifdef HAIR_SHADER - /* View facing normal */ - vec3 norm_view = cross(sd.V, sd.N); - norm_view = normalize(cross(norm_view, sd.N)); /* Normal facing view */ + vec3 norm_view = cross(sd.V, sd.N); + norm_view = normalize(cross(norm_view, sd.N)); /* Normal facing view */ #endif - - /* Analytic Lights */ + vec3 diff = vec3(0.0); + vec3 spec = vec3(0.0); for (int i = 0; i < MAX_LIGHT && i < light_count; ++i) { LightData ld = lights_data[i]; - vec3 diff, spec; - float vis = 1.0; - sd.l_vector = ld.l_position - worldPosition; - light_visibility(ld, sd, vis); - light_shade(ld, sd, albedo, roughnessSquared, f0, diff, spec); + vec4 l_vector; /* Non-Normalized Light Vector with length in last component. */ + l_vector.xyz = ld.l_position - worldPosition; + l_vector.w = length(l_vector.xyz); + + vec3 l_color_vis = ld.l_color * light_visibility(ld, worldPosition, l_vector.xyz); - radiance += vis * (diff + spec) * ld.l_color; +#ifdef HAIR_SHADER + vec3 norm_lamp, view_vec; + float occlu_trans, occlu; + light_hair_common(ld, sd, l_vector, norm_view, occlu_trans, occlu, norm_lamp, view_vec); + + ShadingData hsd = sd; + hsd.N = -norm_lamp; + diff += l_color_vis * light_diffuse(ld, hsd, l_vector) * occlu_trans; + hsd.V = view_vec; + spec += l_color_vis * light_specular(ld, hsd, l_vector, roughnessSquared, f0) * occlu; +#else + diff += l_color_vis * light_diffuse(ld, sd, l_vector); + spec += l_color_vis * light_specular(ld, sd, l_vector, roughnessSquared, f0); +#endif } + /* Accumulate outgoing radiance */ + vec3 out_light = diff * albedo + spec * float(specToggle); + #ifdef HAIR_SHADER sd.N = -norm_view; #endif - vec3 bent_normal; - vec4 rand = textureLod(utilTex, vec3(gl_FragCoord.xy / LUT_SIZE, 2.0), 0.0).rgba; - float final_ao = compute_occlusion(sd.N, ao, rand.rg, bent_normal); + /* ---------------- SPECULAR ENVIRONMENT LIGHTING ----------------- */ /* Envmaps */ - vec3 R = reflect(-sd.V, sd.N); - vec3 spec_dir = get_specular_dominant_dir(sd.N, R, roughnessSquared); - vec2 uv = lut_coords(dot(sd.N, sd.V), roughness); - vec2 brdf_lut = texture(utilTex, vec3(uv, 1.0)).rg; + vec3 spec_dir = get_specular_dominant_dir(sd.N, sd.V, roughnessSquared); + /* Accumulate light from all sources until accumulator is full. Then apply Occlusion and BRDF. */ vec4 spec_accum = vec4(0.0); - vec4 diff_accum = vec4(0.0); /* Planar Reflections */ for (int i = 0; i < MAX_PLANAR && i < planar_count && spec_accum.a < 0.999; ++i) { PlanarData pd = planars_data[i]; - float influence = planar_attenuation(sd.W, sd.N, pd); - - if (influence > 0.0) { - float influ_spec = min(influence, (1.0 - spec_accum.a)); - - /* Sample reflection depth. */ - vec4 refco = pd.reflectionmat * vec4(sd.W, 1.0); - refco.xy /= refco.w; - float ref_depth = textureLod(probePlanars, vec3(refco.xy, i), 0.0).a; - - /* Find view vector / reflection plane intersection. (dist_to_plane is negative) */ - float dist_to_plane = line_plane_intersect_dist(cameraPos, sd.V, pd.pl_plane_eq); - vec3 point_on_plane = cameraPos + sd.V * dist_to_plane; - - /* How far the pixel is from the plane. */ - ref_depth = ref_depth + dist_to_plane; - - /* Compute distorded reflection vector based on the distance to the reflected object. - * In other words find intersection between reflection vector and the sphere center - * around point_on_plane. */ - vec3 proj_ref = reflect(R * ref_depth, pd.pl_normal); - - /* Final point in world space. */ - vec3 ref_pos = point_on_plane + proj_ref; + float fade = probe_attenuation_planar(pd, worldPosition, sd.N); - /* Reproject to find texture coords. */ - refco = pd.reflectionmat * vec4(ref_pos, 1.0); - refco.xy /= refco.w; - - /* Distance to roughness */ - float linear_roughness = sqrt(roughness); - float distance_roughness = min(linear_roughness, ref_depth * linear_roughness); - linear_roughness = mix(distance_roughness, linear_roughness, linear_roughness); - - /* Decrease influence for high roughness */ - influ_spec *= saturate((1.0 - linear_roughness) * 5.0 - 2.0); - - float lod = linear_roughness * 2.5 * 5.0; - vec3 sample = textureLod(probePlanars, vec3(refco.xy, i), lod).rgb; - - /* Use a second sample randomly rotated to blur out the lowres aspect */ - vec2 rot_sample = (1.0 / vec2(textureSize(probePlanars, 0).xy)) * vec2(cos(rand.a * M_2PI), sin(rand.a * M_2PI)) * lod; - sample += textureLod(probePlanars, vec3(refco.xy + rot_sample, i), lod).rgb; - sample *= 0.5; - - spec_accum.rgb += sample * influ_spec; - spec_accum.a += influ_spec; + if (fade > 0.0) { + vec3 spec = probe_evaluate_planar(float(i), pd, worldPosition, sd.N, sd.V, rand.a, cameraPos, roughness, fade); + accumulate_light(spec, fade, spec_accum); } } /* Specular probes */ - /* Start at 1 because 0 is world probe */ + /* Starts at 1 because 0 is world probe */ for (int i = 1; i < MAX_PROBE && i < probe_count && spec_accum.a < 0.999; ++i) { - ProbeData pd = probes_data[i]; - - float dist_attenuation = probe_attenuation(sd.W, pd); - - if (dist_attenuation > 0.0) { - float roughness_copy = roughness; + CubeData cd = probes_data[i]; - vec3 sample_vec = probe_parallax_correction(sd.W, spec_dir, pd, roughness_copy); - vec4 sample = textureLod_octahedron(probeCubes, vec4(sample_vec, i), roughness_copy * lodMax, lodMax).rgba; + float fade = probe_attenuation_cube(cd, worldPosition); - float influ_spec = min(dist_attenuation, (1.0 - spec_accum.a)); - - spec_accum.rgb += sample.rgb * influ_spec; - spec_accum.a += influ_spec; + if (fade > 0.0) { + vec3 spec = probe_evaluate_cube(float(i), cd, worldPosition, spec_dir, roughness); + accumulate_light(spec, fade, spec_accum); } } - /* Start at 1 because 0 is world irradiance */ - for (int i = 1; i < MAX_GRID && i < grid_count && diff_accum.a < 0.999; ++i) { - GridData gd = grids_data[i]; - - vec3 localpos = (gd.localmat * vec4(sd.W, 1.0)).xyz; - - float fade = min(1.0, min_v3(1.0 - abs(localpos))); - fade = saturate(fade * gd.g_atten_scale + gd.g_atten_bias); - - if (fade > 0.0) { - localpos = localpos * 0.5 + 0.5; - localpos = localpos * vec3(gd.g_resolution) - 0.5; - - vec3 localpos_floored = floor(localpos); - vec3 trilinear_weight = fract(localpos); - - float weight_accum = 0.0; - vec3 irradiance_accum = vec3(0.0); - - /* For each neighboor cells */ - for (int i = 0; i < 8; ++i) { - ivec3 offset = ivec3(i, i >> 1, i >> 2) & ivec3(1); - vec3 cell_cos = clamp(localpos_floored + vec3(offset), vec3(0.0), vec3(gd.g_resolution) - 1.0); - - /* We need this because we render probes in world space (so we need light vector in WS). - * And rendering them in local probe space is too much problem. */ - vec3 ws_cell_location = gd.g_corner + - (gd.g_increment_x * cell_cos.x + - gd.g_increment_y * cell_cos.y + - gd.g_increment_z * cell_cos.z); - vec3 ws_point_to_cell = ws_cell_location - sd.W; - vec3 ws_light = normalize(ws_point_to_cell); - - vec3 trilinear = mix(1 - trilinear_weight, trilinear_weight, offset); - float weight = trilinear.x * trilinear.y * trilinear.z; + /* World Specular */ + if (spec_accum.a < 1.0) { + vec3 spec = probe_evaluate_world_spec(spec_dir, roughness); + accumulate_light(spec, 1.0, spec_accum); + } - /* Smooth backface test */ - // weight *= sqrt(max(0.002, dot(ws_light, sd.N))); + /* Ambient Occlusion */ + vec3 bent_normal; + float final_ao = occlusion_compute(sd.N, viewPosition, ao, rand.rg, bent_normal); - /* Avoid zero weight */ - weight = max(0.00001, weight); + /* Get Brdf intensity */ + vec2 uv = lut_coords(dot(sd.N, sd.V), roughness); + vec2 brdf_lut = texture(utilTex, vec3(uv, 1.0)).rg; - vec3 color = get_cell_color(ivec3(cell_cos), gd.g_resolution, gd.g_offset, bent_normal); + out_light += spec_accum.rgb * F_ibl(f0, brdf_lut) * specular_occlusion(dot(sd.N, sd.V), final_ao, roughness) * float(specToggle); - weight_accum += weight; - irradiance_accum += color * weight; - } + /* ---------------- DIFFUSE ENVIRONMENT LIGHTING ----------------- */ - vec3 indirect_diffuse = irradiance_accum / weight_accum; + /* Accumulate light from all sources until accumulator is full. Then apply Occlusion and BRDF. */ + vec4 diff_accum = vec4(0.0); - float influ_diff = min(fade, (1.0 - diff_accum.a)); + /* Start at 1 because 0 is world irradiance */ + for (int i = 1; i < MAX_GRID && i < grid_count && diff_accum.a < 0.999; ++i) { + GridData gd = grids_data[i]; - diff_accum.rgb += indirect_diffuse * influ_diff; - diff_accum.a += influ_diff; + vec3 localpos; + float fade = probe_attenuation_grid(gd, worldPosition, localpos); - /* For Debug purpose */ - // return texture(irradianceGrid, sd.W.xy).rgb; + if (fade > 0.0) { + vec3 diff = probe_evaluate_grid(gd, worldPosition, bent_normal, localpos); + accumulate_light(diff, fade, diff_accum); } } - /* World probe */ + /* World Diffuse */ if (diff_accum.a < 1.0 && grid_count > 0) { - IrradianceData ir_data = load_irradiance_cell(0, bent_normal); - - vec3 diff = compute_irradiance(bent_normal, ir_data); - diff_accum.rgb += diff * (1.0 - diff_accum.a); - } - - if (spec_accum.a < 1.0) { - ProbeData pd = probes_data[0]; - - vec3 spec = textureLod_octahedron(probeCubes, vec4(spec_dir, 0), roughness * lodMax, lodMax).rgb; - spec_accum.rgb += spec * (1.0 - spec_accum.a); + vec3 diff = probe_evaluate_world_diff(bent_normal); + accumulate_light(diff, 1.0, diff_accum); } - vec3 indirect_radiance = - spec_accum.rgb * F_ibl(f0, brdf_lut) * float(specToggle) * specular_occlusion(dot(sd.N, sd.V), final_ao, roughness) + - diff_accum.rgb * albedo * gtao_multibounce(final_ao, albedo); + out_light += diff_accum.rgb * albedo * gtao_multibounce(final_ao, albedo); - return radiance + indirect_radiance; + return out_light; } |