Blender V5.3
eevee_deferred_combine.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
7#include "draw_view.bsl.hh"
11#include "eevee_hiz.bsl.hh"
15
16namespace eevee::deferred {
17
18struct Combine {
19 /* NOTE: Both light IDs have a valid specialized assignment of '-1' so only when default is
20 * present will we instead dynamically look-up ID from the uniform buffer. */
33
34 /* Inputs. */
39
41
43 {
44 uint data = texelFetch(direct_radiance_txs, int3(texel, i), 0).r;
45 return rgb9e5_decode(data);
46 }
47
49 {
50 switch (i) {
51 case 0:
52 return texelFetch(indirect_radiance_1_tx, texel, 0).rgb;
53 case 1:
54 return texelFetch(indirect_radiance_2_tx, texel, 0).rgb;
55 case 2:
56 return texelFetch(indirect_radiance_3_tx, texel, 0).rgb;
57 default:
58 return float3(0);
59 }
60 return float3(0);
61 }
62};
63
67
68[[vertex]]
69void combine_vert([[vertex_id]] const int vert_id,
70 [[position]] float4 &out_position,
71 [[out]] CombineVertOut &v_out)
72{
73 fullscreen_vertex(vert_id, out_position, v_out.screen_uv);
74}
75
79
84/* Early fragment test is needed to avoid processing fragments background fragments. */
87 [[resource_table]] RenderPassOutput &render_passes,
88 [[resource_table]] const draw::View &views,
89 [[resource_table]] const Uniform &uni,
90 [[resource_table]] const HiZ &hiz,
91 [[resource_table]] const ::gbuffer::Reader &reader,
92 [[frag_coord]] const float4 frag_co,
93 [[in]] const CombineVertOut &v_out,
94 [[out]] CombineFragOut &frag_out)
95{
96 int2 texel = int2(frag_co.xy);
97
98 const gbuffer::Layers gbuf = reader.read_layers(texel);
99 const uchar closure_count = gbuf.header.closure_len();
100 const uint3 bin_indices = gbuf.header.bin_index_per_layer();
101
102 float sum_weight = 0.0f;
103 float3 diffuse_color =
104 render_passes.load_color(texel, uni.uniform_buf.render_pass.diffuse_color_id).rgb;
105 float3 diffuse_direct =
106 render_passes.load_color(texel, uni.uniform_buf.render_pass.diffuse_light_id).rgb;
107 float3 diffuse_indirect = float3(0.0f);
108 float3 specular_color =
109 render_passes.load_color(texel, uni.uniform_buf.render_pass.specular_color_id).rgb;
110 float3 specular_direct =
111 render_passes.load_color(texel, uni.uniform_buf.render_pass.specular_light_id).rgb;
112 float3 specular_indirect = float3(0.0f);
113 float3 out_direct = diffuse_direct + specular_direct;
114 float3 out_indirect = float3(0.0f);
115 float3 average_normal = float3(0.0f);
116 /* Denoising render pass data. */
117 float average_roughness = 0.0f;
118 float3 diffuse_albedo = diffuse_color;
119 float3 specular_albedo = specular_color;
120
121 /* Unroll needed for gbuf.layer access. */
122 for (int i = 0; i < 3 /* GBUFFER_LAYER_MAX */; i++) [[unroll]] {
123 if (i < closure_count) {
124 ClosureUndetermined cl = gbuf.layer[i];
125 if (cl.type != CLOSURE_NONE_ID) {
126
127 uchar layer_index = bin_indices[i];
128 float3 closure_direct_light = srt.load_radiance_direct(texel, layer_index);
129 float3 closure_indirect_light = float3(0.0f);
130
131 if (srt.use_split_radiance) {
132 closure_indirect_light = srt.load_radiance_indirect(texel, layer_index);
133 }
134
135 float closure_weight = reduce_add(cl.color);
136 sum_weight += closure_weight;
137
138 average_normal += cl.N * closure_weight;
139
140 if (srt.render_passes_denoising_diffuse_albedo_enabled ||
141 srt.render_passes_denoising_specular_albedo_enabled ||
142 srt.render_passes_denoising_roughness_enabled)
143 {
144 /* These two values are equivalent between Cycles and EEVEE:
145 * - Cycles: sqrtf(bsdf_get_specular_roughness_squared(sc))
146 * - EEVEE: square(closure_apparent_roughness_get(cl)) */
147 float closure_roughness = closure_apparent_roughness_get(cl);
148 average_roughness += closure_roughness * closure_weight;
149 if (srt.use_albedo_roughness_weighting) {
150 float roughness_sq = square(closure_roughness);
151 float diffuse_weight = smoothstep(0.0f, 0.15f, roughness_sq);
152 diffuse_albedo += diffuse_weight * cl.color;
153 specular_albedo += (1.0 - diffuse_weight) * cl.color;
154 }
155 }
156
157 switch (cl.type) {
161 diffuse_color += cl.color;
162 diffuse_direct += closure_direct_light * cl.color;
163 diffuse_indirect += closure_indirect_light * cl.color;
164 if (srt.render_passes_denoising_diffuse_albedo_enabled &&
165 !srt.use_albedo_roughness_weighting)
166 {
167 diffuse_albedo += cl.color;
168 }
169 break;
170 case CLOSURE_BSDF_MICROFACET_GGX_REFLECTION_ID:
173 specular_color += cl.color;
174 specular_direct += closure_direct_light * cl.color;
175 specular_indirect += closure_indirect_light * cl.color;
176 if (srt.render_passes_denoising_specular_albedo_enabled &&
177 !srt.use_albedo_roughness_weighting)
178 {
179 specular_albedo += cl.color;
180 }
181 break;
182 case CLOSURE_NONE_ID:
183 assert(false);
184 break;
185 }
186
187 if ((cl.type == CLOSURE_BSDF_TRANSLUCENT_ID ||
189 (reader.read_thickness(gbuf.header, texel).value() != 0.0f))
190 {
191 /* We model two transmission event, so the surface color need to be applied twice. */
192 cl.color *= cl.color;
193 }
194
195 out_direct += closure_direct_light * cl.color;
196 out_indirect += closure_indirect_light * cl.color;
197 }
198 }
199 }
200
201 if (srt.use_radiance_feedback) {
202 /* Output unmodified radiance for indirect lighting. */
203 float3 out_radiance = imageLoad(srt.radiance_feedback_img, texel).rgb;
204 out_radiance += out_direct + out_indirect;
205 /* Prevent NaNs from propagating. */
206 out_radiance = any(isnan(out_radiance)) ? float3(0.0f) : out_radiance;
207 imageStore(srt.radiance_feedback_img, texel, float4(out_radiance, 0.0f));
208 }
209
210 /* Light clamping. */
211 float clamp_direct = uni.uniform_buf.clamp.surface_direct;
212 float clamp_indirect = uni.uniform_buf.clamp.surface_indirect;
213 out_direct = colorspace::brightness_clamp_max(out_direct, clamp_direct);
214 out_indirect = colorspace::brightness_clamp_max(out_indirect, clamp_indirect);
215 /* Apply contribution scaling after clamping (compositing-equivalent). */
216 out_direct *= uni.uniform_buf.clamp.direct_scale;
217 out_indirect *= uni.uniform_buf.clamp.indirect_scale;
218
219 /* TODO(@fclem): Shouldn't we clamp these relative the main clamp? */
220 diffuse_direct = colorspace::brightness_clamp_max(diffuse_direct, clamp_direct);
221 diffuse_indirect = colorspace::brightness_clamp_max(diffuse_indirect, clamp_indirect);
222 specular_direct = colorspace::brightness_clamp_max(specular_direct, clamp_direct);
223 specular_indirect = colorspace::brightness_clamp_max(specular_indirect, clamp_indirect);
224
225 diffuse_direct *= uni.uniform_buf.clamp.direct_scale;
226 diffuse_indirect *= uni.uniform_buf.clamp.indirect_scale;
227 specular_direct *= uni.uniform_buf.clamp.direct_scale;
228 specular_indirect *= uni.uniform_buf.clamp.indirect_scale;
229
230 /* Light passes. */
231 if (srt.render_pass_diffuse_light_enabled) {
232 float3 diffuse_light = diffuse_direct + diffuse_indirect;
233 render_passes.store_color(
234 texel, uni.uniform_buf.render_pass.diffuse_color_id, float4(diffuse_color, 1.0f));
235 render_passes.store_color(
236 texel, uni.uniform_buf.render_pass.diffuse_light_id, float4(diffuse_light, 1.0f));
237 }
238 if (srt.render_pass_specular_light_enabled) {
239 float3 specular_light = specular_direct + specular_indirect;
240 render_passes.store_color(
241 texel, uni.uniform_buf.render_pass.specular_color_id, float4(specular_color, 1.0f));
242 render_passes.store_color(
243 texel, uni.uniform_buf.render_pass.specular_light_id, float4(specular_light, 1.0f));
244 }
245 if (srt.render_pass_normal_enabled || srt.render_passes_denoising_normal_enabled) {
246 float normal_len = length(average_normal);
247 /* Normalize or fallback to default normal. */
248 average_normal = (normal_len < 1e-5f) ? gbuf.surface_N() : (average_normal / normal_len);
249 }
250 if (srt.render_pass_normal_enabled) {
251 render_passes.store_color(
252 texel, uni.uniform_buf.render_pass.normal_id, float4(average_normal, 1.0f));
253 }
254 if (srt.render_pass_position_enabled) {
255 const ViewMatrices view = views.get(0);
256 float depth = texelFetch(hiz.hiz_tx, texel, 0).r;
257 float3 P = view.point_screen_to_world(float3(v_out.screen_uv, depth));
258 render_passes.store_color(texel, uni.uniform_buf.render_pass.position_id, float4(P, 1.0f));
259 }
260 if (srt.render_passes_denoising_normal_enabled) {
261 const ViewMatrices view = views.get(0);
262 average_normal = view.normal_world_to_view(average_normal);
263 /* For compatibility with Cycles */
264 average_normal.z *= -1.0f;
265 render_passes.store_color(
266 texel, uni.uniform_buf.render_pass.denoising_normal_id, float4(average_normal, 1.0f));
267 }
268 if (srt.render_passes_denoising_diffuse_albedo_enabled) {
269 render_passes.store_color(texel,
270 uni.uniform_buf.render_pass.denoising_diffuse_albedo_id,
271 float4(diffuse_albedo, 1.0f));
272 }
273 if (srt.render_passes_denoising_specular_albedo_enabled) {
274 render_passes.store_color(texel,
275 uni.uniform_buf.render_pass.denoising_specular_albedo_id,
276 float4(specular_albedo, 1.0f));
277 }
278 if (srt.render_passes_denoising_roughness_enabled) {
279 if (sum_weight > 0.0f) {
280 average_roughness /= sum_weight;
281 }
282 render_passes.store_value(
283 texel, uni.uniform_buf.render_pass.denoising_roughness_id, average_roughness);
284 }
285
286 frag_out.combined = float4(out_direct + out_indirect, 0.0f);
287 frag_out.combined = any(isnan(frag_out.combined)) ? float4(1.0f, 0.0f, 1.0f, 0.0f) :
288 frag_out.combined;
289 frag_out.combined = colorspace::safe_color(frag_out.combined);
290}
291
292} // namespace eevee::deferred
293
float closure_apparent_roughness_get(ClosureUndetermined cl)
PipelineGraphic eevee_deferred_combine(eevee::deferred::combine_vert, eevee::deferred::combine_frag)
@ SFLOAT_16_16_16_16
#define assert(assertion)
#define position
#define image(slot, qualifiers, format)
#define early_fragment_tests
#define frag_coord
#define smooth
#define resource_table
#define sampler(slot)
#define specialization_constant(default_value)
#define fragment
#define vertex_id
#define unroll
#define vertex
#define frag_color(slot)
#define isnan
T smoothstep(T, T, T) RET
bool any(VecOp< bool, D >) RET
float length(VecOp< float, D >) RET
IMG_TEMPLATE DataVec imageLoad(const T &, IntCoord) RET
ImageBase< float, 2 > image2D
IMG_TEMPLATE void imageStore(T &, IntCoord, DataVec)
SamplerBase< uint, 2, false, true > usampler2DArray
TEX_TEMPLATE DataVec texelFetch(T, IntCoord, int) RET
SamplerBase< float, 2 > sampler2D
unsigned int uchar
void fullscreen_vertex(int vertex_id, float4 &out_position)
float square(float v)
float reduce_add(float2 a)
float3 rgb9e5_decode(uint data)
@ CLOSURE_BSDF_MICROFACET_GGX_REFRACTION_ID
@ CLOSURE_BSDF_DIFFUSE_ID
@ CLOSURE_BSSRDF_BURLEY_ID
@ CLOSURE_NONE_ID
@ CLOSURE_BSDF_THIN_GLASS_TRANSMISSION_ID
@ CLOSURE_BSDF_TRANSLUCENT_ID
float4 safe_color(float4 c)
float3 brightness_clamp_max(float3 color, float limit)
void combine_vert(const int vert_id, float4 &out_position, CombineVertOut &v_out)
void combine_frag(Combine &srt, RenderPassOutput &render_passes, const draw::View &views, const Uniform &uni, const HiZ &hiz, const ::gbuffer::Reader &reader, const float4 frag_co, const CombineVertOut &v_out, CombineFragOut &frag_out)
float3 point_screen_to_world(float3 ssP) const
float3 load_radiance_direct(int2 texel, uchar i) const
float3 load_radiance_indirect(int2 texel, uchar i) const
float z
Definition sky_math.h:136
uint3 bin_index_per_layer() const
ClosureUndetermined layer[GBUFFER_LAYER_MAX]