1#define_import_path bevy_pbr::environment_map
2
3#import bevy_pbr::light_probe::query_light_probe
4#import bevy_pbr::mesh_view_bindings as bindings
5#import bevy_pbr::mesh_view_bindings::light_probes
6#import bevy_pbr::mesh_view_bindings::environment_map_uniform
7#import bevy_pbr::lighting::{F_Schlick_vec, LightingInput, LayerLightingInput, LAYER_BASE, LAYER_CLEARCOAT}
8#import bevy_pbr::clustered_forward::ClusterableObjectIndexRanges
9
10struct EnvironmentMapLight {
11    diffuse: vec3<f32>,
12    specular: vec3<f32>,
13};
14
15struct EnvironmentMapRadiances {
16    irradiance: vec3<f32>,
17    radiance: vec3<f32>,
18}
19
20// Define two versions of this function, one for the case in which there are
21// multiple light probes and one for the case in which only the view light probe
22// is present.
23
24#ifdef MULTIPLE_LIGHT_PROBES_IN_ARRAY
25
26fn compute_radiances(
27    input: LayerLightingInput,
28    clusterable_object_index_ranges: ptr<function, ClusterableObjectIndexRanges>,
29    world_position: vec3<f32>,
30    found_diffuse_indirect: bool,
31) -> EnvironmentMapRadiances {
32    // Unpack.
33    let N = input.N;
34    let R = input.R;
35    let perceptual_roughness = input.perceptual_roughness;
36    let roughness = input.roughness;
37
38    var radiances: EnvironmentMapRadiances;
39
40    // Search for a reflection probe that contains the fragment.
41    var query_result = query_light_probe(
42        world_position,
43        /*is_irradiance_volume=*/ false,
44        clusterable_object_index_ranges,
45    );
46
47    // If we didn't find a reflection probe, use the view environment map if applicable.
48    if (query_result.texture_index < 0) {
49        query_result.texture_index = light_probes.view_cubemap_index;
50        query_result.intensity = light_probes.intensity_for_view;
51        query_result.affects_lightmapped_mesh_diffuse =
52            light_probes.view_environment_map_affects_lightmapped_mesh_diffuse != 0u;
53    }
54
55    // If there's no cubemap, bail out.
56    if (query_result.texture_index < 0) {
57        radiances.irradiance = vec3(0.0);
58        radiances.radiance = vec3(0.0);
59        return radiances;
60    }
61
62    // Split-sum approximation for image based lighting: https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
63    let radiance_level = perceptual_roughness * f32(textureNumLevels(
64        bindings::specular_environment_maps[query_result.texture_index]) - 1u);
65
66    // If we're lightmapped, and we shouldn't accumulate diffuse light from the
67    // environment map, note that.
68    var enable_diffuse = !found_diffuse_indirect;
69#ifdef LIGHTMAP
70    enable_diffuse = enable_diffuse && query_result.affects_lightmapped_mesh_diffuse;
71#endif  // LIGHTMAP
72
73    if (enable_diffuse) {
74        var irradiance_sample_dir = N;
75        // Rotating the world space ray direction by the environment light map transform matrix, it is
76        // equivalent to rotating the diffuse environment cubemap itself.
77        irradiance_sample_dir = (environment_map_uniform.transform * vec4(irradiance_sample_dir, 1.0)).xyz;
78        // Cube maps are left-handed so we negate the z coordinate.
79        irradiance_sample_dir.z = -irradiance_sample_dir.z;
80        radiances.irradiance = textureSampleLevel(
81            bindings::diffuse_environment_maps[query_result.texture_index],
82            bindings::environment_map_sampler,
83            irradiance_sample_dir,
84            0.0).rgb * query_result.intensity;
85    }
86
87    var radiance_sample_dir = radiance_sample_direction(N, R, roughness);
88    // Rotating the world space ray direction by the environment light map transform matrix, it is
89    // equivalent to rotating the specular environment cubemap itself.
90    radiance_sample_dir = (environment_map_uniform.transform * vec4(radiance_sample_dir, 1.0)).xyz;
91    // Cube maps are left-handed so we negate the z coordinate.
92    radiance_sample_dir.z = -radiance_sample_dir.z;
93    radiances.radiance = textureSampleLevel(
94        bindings::specular_environment_maps[query_result.texture_index],
95        bindings::environment_map_sampler,
96        radiance_sample_dir,
97        radiance_level).rgb * query_result.intensity;
98
99    return radiances;
100}
101
102#else   // MULTIPLE_LIGHT_PROBES_IN_ARRAY
103
104fn compute_radiances(
105    input: LayerLightingInput,
106    clusterable_object_index_ranges: ptr<function, ClusterableObjectIndexRanges>,
107    world_position: vec3<f32>,
108    found_diffuse_indirect: bool,
109) -> EnvironmentMapRadiances {
110    // Unpack.
111    let N = input.N;
112    let R = input.R;
113    let perceptual_roughness = input.perceptual_roughness;
114    let roughness = input.roughness;
115
116    var radiances: EnvironmentMapRadiances;
117
118    if (light_probes.view_cubemap_index < 0) {
119        radiances.irradiance = vec3(0.0);
120        radiances.radiance = vec3(0.0);
121        return radiances;
122    }
123
124    // Split-sum approximation for image based lighting: https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
125    // Technically we could use textureNumLevels(specular_environment_map) - 1 here, but we use a uniform
126    // because textureNumLevels() does not work on WebGL2
127    let radiance_level = perceptual_roughness * f32(light_probes.smallest_specular_mip_level_for_view);
128
129    let intensity = light_probes.intensity_for_view;
130
131    // If we're lightmapped, and we shouldn't accumulate diffuse light from the
132    // environment map, note that.
133    var enable_diffuse = !found_diffuse_indirect;
134#ifdef LIGHTMAP
135    enable_diffuse = enable_diffuse &&
136        light_probes.view_environment_map_affects_lightmapped_mesh_diffuse;
137#endif  // LIGHTMAP
138
139    if (enable_diffuse) {
140        var irradiance_sample_dir = N;
141        // Rotating the world space ray direction by the environment light map transform matrix, it is
142        // equivalent to rotating the diffuse environment cubemap itself.
143        irradiance_sample_dir = (environment_map_uniform.transform * vec4(irradiance_sample_dir, 1.0)).xyz;
144        // Cube maps are left-handed so we negate the z coordinate.
145        irradiance_sample_dir.z = -irradiance_sample_dir.z;
146        radiances.irradiance = textureSampleLevel(
147            bindings::diffuse_environment_map,
148            bindings::environment_map_sampler,
149            irradiance_sample_dir,
150            0.0).rgb * intensity;
151    }
152
153    var radiance_sample_dir = radiance_sample_direction(N, R, roughness);
154    // Rotating the world space ray direction by the environment light map transform matrix, it is
155    // equivalent to rotating the specular environment cubemap itself.
156    radiance_sample_dir = (environment_map_uniform.transform * vec4(radiance_sample_dir, 1.0)).xyz;
157    // Cube maps are left-handed so we negate the z coordinate.
158    radiance_sample_dir.z = -radiance_sample_dir.z;
159    radiances.radiance = textureSampleLevel(
160        bindings::specular_environment_map,
161        bindings::environment_map_sampler,
162        radiance_sample_dir,
163        radiance_level).rgb * intensity;
164
165    return radiances;
166}
167
168#endif  // MULTIPLE_LIGHT_PROBES_IN_ARRAY
169
170#ifdef STANDARD_MATERIAL_CLEARCOAT
171
172// Adds the environment map light from the clearcoat layer to that of the base
173// layer.
174fn environment_map_light_clearcoat(
175    out: ptr<function, EnvironmentMapLight>,
176    input: ptr<function, LightingInput>,
177    clusterable_object_index_ranges: ptr<function, ClusterableObjectIndexRanges>,
178    found_diffuse_indirect: bool,
179) {
180    // Unpack.
181    let world_position = (*input).P;
182    let clearcoat_NdotV = (*input).layers[LAYER_CLEARCOAT].NdotV;
183    let clearcoat_strength = (*input).clearcoat_strength;
184
185    // Calculate the Fresnel term `Fc` for the clearcoat layer.
186    // 0.04 is a hardcoded value for F0 from the Filament spec.
187    let clearcoat_F0 = vec3<f32>(0.04);
188    let Fc = F_Schlick_vec(clearcoat_F0, 1.0, clearcoat_NdotV) * clearcoat_strength;
189    let inv_Fc = 1.0 - Fc;
190
191    let clearcoat_radiances = compute_radiances(
192        (*input).layers[LAYER_CLEARCOAT],
193        clusterable_object_index_ranges,
194        world_position,
195        found_diffuse_indirect,
196    );
197
198    // Composite the clearcoat layer on top of the existing one.
199    // These formulas are from Filament:
200    // <https://google.github.io/filament/Filament.md.html#lighting/imagebasedlights/clearcoat>
201    (*out).diffuse *= inv_Fc;
202    (*out).specular = (*out).specular * inv_Fc * inv_Fc + clearcoat_radiances.radiance * Fc;
203}
204
205#endif  // STANDARD_MATERIAL_CLEARCOAT
206
207fn environment_map_light(
208    input: ptr<function, LightingInput>,
209    clusterable_object_index_ranges: ptr<function, ClusterableObjectIndexRanges>,
210    found_diffuse_indirect: bool,
211) -> EnvironmentMapLight {
212    // Unpack.
213    let roughness = (*input).layers[LAYER_BASE].roughness;
214    let diffuse_color = (*input).diffuse_color;
215    let NdotV = (*input).layers[LAYER_BASE].NdotV;
216    let F_ab = (*input).F_ab;
217    let F0 = (*input).F0_;
218    let world_position = (*input).P;
219
220    var out: EnvironmentMapLight;
221
222    let radiances = compute_radiances(
223        (*input).layers[LAYER_BASE],
224        clusterable_object_index_ranges,
225        world_position,
226        found_diffuse_indirect,
227    );
228
229    if (all(radiances.irradiance == vec3(0.0)) && all(radiances.radiance == vec3(0.0))) {
230        out.diffuse = vec3(0.0);
231        out.specular = vec3(0.0);
232        return out;
233    }
234
235    // No real world material has specular values under 0.02, so we use this range as a
236    // "pre-baked specular occlusion" that extinguishes the fresnel term, for artistic control.
237    // See: https://google.github.io/filament/Filament.html#specularocclusion
238    let specular_occlusion = saturate(dot(F0, vec3(50.0 * 0.33)));
239
240    // Multiscattering approximation: https://www.jcgt.org/published/0008/01/03/paper.pdf
241    // We initially used this (https://bruop.github.io/ibl) reference with Roughness Dependent
242    // Fresnel, but it made fresnel very bright so we reverted to the "typical" fresnel term.
243    let Ess = F_ab.x + F_ab.y;
244    let FssEss = (F0 * Ess) * specular_occlusion;
245    let Ems = 1.0 - Ess;
246    let Favg = F0 + (1.0 - F0) / 21.0;
247    let Fms = FssEss * Favg / (1.0 - Ems * Favg);
248    let FmsEms = Fms * Ems;
249    let Edss = 1.0 - (FssEss + FmsEms);
250    let kD = diffuse_color * Edss;
251
252    if (!found_diffuse_indirect) {
253        out.diffuse = (FmsEms + kD) * radiances.irradiance;
254    } else {
255        out.diffuse = vec3(0.0);
256    }
257
258    out.specular = FssEss * radiances.radiance;
259
260#ifdef STANDARD_MATERIAL_CLEARCOAT
261    environment_map_light_clearcoat(
262        &out,
263        input,
264        clusterable_object_index_ranges,
265        found_diffuse_indirect,
266    );
267#endif  // STANDARD_MATERIAL_CLEARCOAT
268
269    return out;
270}
271
272// "Moving Frostbite to Physically Based Rendering 3.0", listing 22
273// https://seblagarde.wordpress.com/wp-content/uploads/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf#page=70
274fn radiance_sample_direction(N: vec3<f32>, R: vec3<f32>, roughness: f32) -> vec3<f32> {
275    let smoothness = saturate(1.0 - roughness);
276    let lerp_factor = smoothness * (sqrt(smoothness) + roughness);
277    return mix(N, R, lerp_factor);
278}