Blender V5.3
eevee_surf_hybrid.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2022-2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
11
12#pragma once
13
15
21
23{
26 const uint resource_id = id.resource_id<1>();
27 const float2 frag_co = sd.frag_co.xy;
28
29 float3 radiance, transmittance;
31 kg, sd, kg.view.get(0), resource_id, sd.thickness, frag_co, radiance, transmittance);
32
33 /* Reset for the next closure tree. */
34 float noise = kg.util_tx.fetch(frag_co, UTIL_BLUE_NOISE_LAYER).r;
35 float closure_rand = fract(noise + kg.sampling.rng_1D_get(SAMPLING_CLOSURE));
36 closure_weights_reset(kg, sd, closure_rand);
37
40 eevee::LightProbeSample samp = kg.lightprobes.load(frag_co, sd.P, sd.N, V);
42 samp, sd.P, V, 0.0);
43
44 int2 texel = int2(frag_co);
45 if (texelFetchExtend(kg.previous_layer_hiz.hiz_prev_tx, texel, 0).x != 1.0f) {
46 radiance_behind =
48 }
49
50 radiance += radiance_behind * saturate(transmittance);
51 }
52
53 return float4(radiance, saturate(1.0f - average(transmittance)));
54 }
55 return float4(0);
56}
57
58namespace eevee {
59
61 /* Everything is stored inside a two layered target, one for each format. This is to fit
62 * resource_table limitation of the number of images we can bind on a single shader. */
65 /* Storage for additional infos that are shared across closures. */
67
68 void write_closure_data(int2 texel, int layer, float4 data)
69 {
70 /* NOTE: The image view start at layer GBUF_CLOSURE_FB_LAYER_COUNT so all destination layer is
71 * `layer - GBUF_CLOSURE_FB_LAYER_COUNT`. */
73 }
74
75 void write_normal_data(int2 texel, int layer, float2 data)
76 {
77 /* NOTE: The image view start at layer GBUF_NORMAL_FB_LAYER_COUNT so all destination layer is
78 * `layer - GBUF_NORMAL_FB_LAYER_COUNT`. */
80 }
81
82 void write_header_data(int2 texel, int layer, uint data)
83 {
84 /* NOTE: The image view start at layer GBUF_HEADER_FB_LAYER_COUNT so all destination layer is
85 * `layer - GBUF_HEADER_FB_LAYER_COUNT`. */
87 }
88};
89
99
100/* NOTE: This removes the possibility of using gl_FragDepth. */
106 [[resource_table]] LightEvalIterator & /*lights*/,
107 [[resource_table]] LightprobeRenderData & /*lightprobes*/,
108 [[resource_table]] LightprobePlaneRenderData & /*lightprobe_planes*/,
110 [[resource_table]] RenderPassOutput &render_passes,
111 [[resource_table]] const draw::View &views,
112 [[resource_table]] const draw::Infos & /*infos*/,
113 [[resource_table]] const Uniform &uni,
114 [[resource_table]] const Sampling &sampling,
115 [[resource_table]] const UtilityTexture &util_tx,
116 [[in]] const VertOutCommon &interp,
117 [[in]] [[condition(is_curves)]] const VertOutCurves &curves_interp,
118 [[in]] [[condition(is_pointcloud)]] const VertOutPointcloud &ptcloud_interp,
119 [[frag_coord]] const float4 frag_co,
120 [[out]] HybridFragOut &frag_out,
121 [[bary_coord]] [[condition(use_barycentric)]] const float3 bary_co,
122 [[front_facing]] const bool front_face)
123{
124 draw::ID id{interp.resource_id_raw};
125 const uint resource_id = id.resource_id<1>();
126
127 const ViewMatrices view = views.get(0);
128
129 float3 barycentric_co = float3(0.0f);
130 if (pipe.use_barycentric) [[static_branch]] {
131 barycentric_co = bary_co;
132 }
133
134 ShadingData sd = init_globals(pipe, uni, interp, view, front_face, frag_co);
135 if (pipe.is_mesh) [[static_branch]] {
136 init_globals_mesh(interp, sd, barycentric_co);
137 }
138 else if (pipe.is_curves) [[static_branch]] {
139 init_globals_curves(interp, curves_interp, sd, view);
140 }
141 else if (pipe.is_pointcloud) [[static_branch]] {
142 init_globals_pointcloud(ptcloud_interp, sd);
143 }
144
145 float noise = util_tx.fetch(frag_co.xy, UTIL_BLUE_NOISE_LAYER).r;
146 float closure_rand = fract(noise + sampling.rng_1D_get(SAMPLING_CLOSURE));
147
149 ThicknessMode(kg.nt.node_tree.thickness_mode));
150
151 fragment_displacement(kg, sd);
152
153 nodetree_surface(kg, sd, closure_rand);
154
155 sd.holdout = saturate(sd.holdout);
156
158 float alpha = 1.0f - average(sd.transmittance);
159 float alpha_rcp = safe_rcp(alpha);
160
161 ObjectInfos object_infos = kg.object_infos_get(sd);
162
163 /* Object holdout. */
164 eObjectInfoFlag ob_flag = object_infos.flag;
165 if (flag_test(ob_flag, OBJECT_HOLDOUT)) {
166 /* alpha is set from rejected pixels / dithering. */
167 sd.holdout = 1.0f;
168
169 /* Set alpha to 0.0 so that lighting is not computed. */
170 alpha_rcp = 0.0f;
171 }
172
173 sd.emission *= alpha_rcp;
174
175 int2 out_texel = int2(frag_co.xy);
176
177 bool use_light_linking = receiver_light_set_get(object_infos) != 0;
178 bool use_terminator_offset = object_infos.shadow_terminator_normal_offset > 0.0;
179
180 /* ----- Render Passes output ----- */
181
182 /* Some render pass can be written during the gbuffer pass. Light passes are written later. */
183 cryptomatte.store(out_texel, kg.nt.node_tree.crypto_hash, resource_id);
184 render_passes.store_color(
185 out_texel, uni.uniform_buf.render_pass.emission_id, float4(sd.emission, 1.0f));
186
187 if (pipe.use_lighting_nodes) [[static_branch]] {
188 float light_sample_rcp = safe_rcp(float(sd.light_accum.light_accumulation_count));
189 sd.light_accum.diffuse_color *= light_sample_rcp;
190 sd.light_accum.diffuse_light *= alpha_rcp;
191 sd.light_accum.glossy_color *= light_sample_rcp;
192 sd.light_accum.glossy_light *= alpha_rcp;
193 sd.light_accum.transmission_color *= light_sample_rcp;
194 sd.light_accum.transmission_light *= alpha_rcp;
195
196 if (uni.uniform_buf.render_pass.diffuse_light_id >= 0 &&
197 uni.uniform_buf.render_pass.diffuse_color_id >= 0)
198 {
199 render_passes.store_color(out_texel,
200 uni.uniform_buf.render_pass.diffuse_light_id,
202 render_passes.store_color(out_texel,
203 uni.uniform_buf.render_pass.diffuse_color_id,
205 }
206 else {
208 }
209
210 if (uni.uniform_buf.render_pass.specular_light_id >= 0 &&
211 uni.uniform_buf.render_pass.specular_color_id >= 0)
212 {
213 render_passes.store_color(
214 out_texel,
215 uni.uniform_buf.render_pass.specular_light_id,
217 /* TODO(fclem): Adding color passes together is wrong. Split the passes. */
218 render_passes.store_color(
219 out_texel,
220 uni.uniform_buf.render_pass.specular_color_id,
222 }
223 else {
226 }
227
228#if 0 /* TODO Transmission pass */
229 if (uni.uniform_buf.render_pass.transmission_light_id >= 0 &&
230 uni.uniform_buf.render_pass.transmission_color_id >= 0)
231 {
232 render_passes.store_color(out_texel,
233 uni.uniform_buf.render_pass.transmission_light_id,
235 render_passes.store_color(out_texel,
236 uni.uniform_buf.render_pass.transmission_color_id,
238 }
239 else {
241 }
242#endif
243 }
244
245 /* ----- GBuffer output ----- */
246
247 gbuffer::InputClosures gbuf_data;
248 /* Make sure we do not read uninitialized data (see #159161). */
249 if (pipe.closure_bin_count == 0) [[static_branch]] {
250 gbuf_data.closure[0] = ClosureUndetermined{};
251 }
252 for (int i = 0; i < 3; i++) [[unroll]] {
253 if (pipe.closure_bin_count > i) [[static_branch]] {
254 gbuf_data.closure[i] = sd.closure_get_resolved(kg.pipe, i, alpha_rcp);
255 }
256 }
257 const bool use_object_id = pipe.use_sss || use_light_linking || use_terminator_offset;
258
259 float3 gbuffer_dither = sampling.rng_3D_get(SAMPLING_GBUFFER_U);
261 gbuf_params, gbuf_data, sd.Ng, sd.N, sd.thickness, use_object_id);
262
263 /* Output header and first closure using frame-buffer attachment. */
264 frag_out.gbuf_header = gbuf.header;
266 gbuf.closure[0], frag_co.xy, 0u, gbuffer_dither);
268 gbuf.closure[1], frag_co.xy, 1u, gbuffer_dither);
269 frag_out.gbuf_normal = gbuf.normal[0];
270
271 /* Output remaining closures using image store. */
272 if (gbuf_params.gbuffer_layer_max >= 2) [[static_branch]] {
273 if (!gbuf_params.gbuffer_simple_layout) [[static_branch]] {
275 srt.write_closure_data(out_texel,
276 2,
278 gbuf.closure[2], frag_co.xy, 2u, gbuffer_dither));
279 }
281 srt.write_closure_data(out_texel,
282 3,
284 gbuf.closure[3], frag_co.xy, 3u, gbuffer_dither));
285 }
286 }
288 srt.write_normal_data(out_texel, 1, gbuf.normal[1]);
289 }
290 }
291 if (gbuf_params.gbuffer_layer_max >= 3) [[static_branch]] {
293 srt.write_closure_data(out_texel,
294 4,
296 gbuf.closure[4], frag_co.xy, 4u, gbuffer_dither));
297 }
299 srt.write_closure_data(out_texel,
300 5,
302 gbuf.closure[5], frag_co.xy, 5u, gbuffer_dither));
303 }
305 srt.write_normal_data(out_texel, 2, gbuf.normal[2]);
306 }
307 }
308
309 if (pipe.use_additional_data) [[static_branch]] {
311 srt.write_normal_data(
312 out_texel, uni.pipeline_buf.gbuffer_additional_data_layer_id, gbuf.additional_info);
313 }
314 }
315
316 if (flag_test(gbuf.used_layers, OBJECT_ID)) {
317 srt.write_header_data(out_texel, 1, resource_id);
318 }
319
320 /* ----- Radiance output ----- */
321
322 /* Only output emission during the gbuffer pass. */
323 frag_out.radiance = float4(sd.emission, 0.0f);
324 frag_out.radiance.rgb *= 1.0f - sd.holdout;
325 frag_out.radiance.a = sd.holdout;
326}
327} // namespace eevee
static Thickness from(float value, ThicknessMode mode)
uint receiver_light_set_get(ObjectInfos object_infos)
@ OBJECT_HOLDOUT
#define DEFERRED_GBUFFER_ROG_ID
#define GBUF_NORMAL_FB_LAYER_COUNT
#define GBUF_CLOSURE_SLOT
#define GBUF_HEADER_SLOT
#define GBUF_CLOSURE_FB_LAYER_COUNT
#define GBUF_NORMAL_SLOT
#define UTIL_BLUE_NOISE_LAYER
#define GBUF_HEADER_FB_LAYER_COUNT
float nodetree_thickness(KernelGlobals &, ShadingData &)
Closure nodetree_surface(KernelGlobals &, ShadingData &, float)
void fragment_displacement(KernelGlobals &kg, ShadingData &sd)
void closure_weights_reset(KernelGlobals &kg, ShadingData &sd, float closure_rand)
float4 closure_to_rgba_hybrid(KernelGlobals &kg, ShadingData &sd, Closure)
#define image(slot, qualifiers, format)
#define front_facing
#define early_fragment_tests
#define bary_coord
#define frag_coord
#define resource_table
#define static_branch
#define fragment
#define unroll
#define raster_order_group(i)
#define condition(cond)
#define layer
#define frag_color(slot)
T fract(T) RET
ImageBase< uint, 2, true > uimage2DArray
ImageBase< float, 2, true > image2DArray
#define imageStoreFast
TEX_TEMPLATE DataVec texelFetch(T, IntCoord, int) RET
float4 texelFetchExtend(sampler2D, int2, int) RET
float noise(float p)
float safe_rcp(float a)
float average(float2 a)
bool flag_test(uint flag, uint val)
ccl_device_inline float interp(const float a, const float b, const float t)
Definition math_base.h:549
ShadingData init_globals(const eevee::PipelineConstants &pipe, const eevee::Uniform &uni, const VertOutCommon &interp, const ViewMatrices view, bool front_face, float4 fragment_co)
void init_globals_mesh(const VertOutCommon &interp, ShadingData &sd, float3 barycentric_co)
void forward_lighting_eval(KernelGlobals &kg, const ShadingData &sd, const ViewMatrices view, uint resource_id, Thickness thickness, float2 frag_co, float3 &radiance, float3 &transmittance)
void init_globals_pointcloud(const VertOutPointcloud &ptcloud_interp, ShadingData &sd)
void surf_hybrid(KernelGlobals &kg, PipelineConstants &pipe, SurfaceHybrid &srt, gbuffer::PackParameters &gbuf_params, LightEvalIterator &, LightprobeRenderData &, LightprobePlaneRenderData &, CryptomatteOutput &cryptomatte, RenderPassOutput &render_passes, const draw::View &views, const draw::Infos &, const Uniform &uni, const Sampling &sampling, const UtilityTexture &util_tx, const VertOutCommon &interp, const VertOutCurves &curves_interp, const VertOutPointcloud &ptcloud_interp, const float4 frag_co, HybridFragOut &frag_out, const float3 bary_co, const bool front_face)
void init_globals_curves(const VertOutCommon &interp, const VertOutCurves &curve_interp, ShadingData &sd, const ViewMatrices view)
float4 closure_data_layer_dither_flush_to_zero(float4 data, float2 texel, uint layer_id, float3 offset)
float4 closure_data_layer_dither_round_to_nearest(float4 data, float2 texel, uint layer_id, float3 offset)
Packed pack(const PackParameters &srt, InputClosures cl_data, float3 Ng, packed_float3 surface_N, Thickness thickness, bool use_object_id)
#define saturate(a)
Definition smaa.cc:319
eevee::PipelineConstants pipe
eevee::PreviousLayerHiZ previous_layer_hiz
eevee::PreviousLayerRadiance previous_layer_radiance
eevee::LightprobeRenderData lightprobes
eevee::Sampling sampling
enum eObjectInfoFlag flag
float shadow_terminator_normal_offset
packed_float3 transmittance
ClosureUndetermined closure_get_resolved(const eevee::PipelineConstants &pipe, uchar i, float additional_weight) const
packed_float3 emission
LightAccumulation light_accum
float4 fetch(float2 texel, float layer) const
float3 world_incident_vector(float3 P) const
ViewMatrices get(uint view_id) const
LightprobeSphereRenderData spheres
LightProbeSample load(float2 screen_texel, float3 P, float3 Ng, float3 V) const
float3 spherical_sample_normalized_with_parallax(LightProbeSample samp, float3 P, float3 L, float lod) const
float rng_1D_get(const eSamplingDimension dim) const
void write_normal_data(int2 texel, int layer, float2 data)
void write_closure_data(int2 texel, int layer, float4 data)
void write_header_data(int2 texel, int layer, uint data)
float x
Definition sky_math.h:225
ClosureUndetermined closure[GBUFFER_LAYER_MAX]
float2 normal[GBUFFER_LAYER_MAX]
float4 closure[GBUFFER_LAYER_MAX *2]
CCL_NAMESPACE_BEGIN struct Window V