Blender V5.3
eevee_surf_deferred.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#pragma once
12
19
21{
22 float4 out_color;
23 out_color.rgb = sd.emission;
24 out_color.a = saturate(1.0f - average(sd.transmittance));
25
27 /* Reset for the next closure tree. */
28 float noise = kg.util_tx.fetch(sd.frag_co.xy, UTIL_BLUE_NOISE_LAYER).r;
29 float closure_rand = fract(noise + kg.sampling.rng_1D_get(SAMPLING_CLOSURE));
30 closure_weights_reset(kg, sd, closure_rand);
31 }
32 else {
33 closure_weights_reset(kg, sd, 0.0f);
34 }
35 return out_color;
36}
37
38namespace eevee {
39
41 /* Everything is stored inside a two layered target, one for each format. This is to fit the
42 * limitation of the number of images we can bind on a single shader. */
45 /* Storage for additional infos that are shared across closures. */
47
48 void write_closure_data(int2 texel, int layer, float4 data)
49 {
50 /* NOTE: The image view start at layer GBUF_CLOSURE_FB_LAYER_COUNT so all destination layer is
51 * `layer - GBUF_CLOSURE_FB_LAYER_COUNT`. */
53 }
54
55 void write_normal_data(int2 texel, int layer, float2 data)
56 {
57 /* NOTE: The image view start at layer GBUF_NORMAL_FB_LAYER_COUNT so all destination layer is
58 * `layer - GBUF_NORMAL_FB_LAYER_COUNT`. */
60 }
61
62 void write_header_data(int2 texel, int layer, uint data)
63 {
64 /* NOTE: The image view start at layer GBUF_HEADER_FB_LAYER_COUNT so all destination layer is
65 * `layer - GBUF_HEADER_FB_LAYER_COUNT`. */
67 }
68};
69
79
80/* NOTE: This removes the possibility of using gl_FragDepth. */
86 [[resource_table]] RenderPassOutput &render_passes,
88 [[resource_table]] const draw::Infos &infos,
89 [[resource_table]] const draw::View &views,
90 [[resource_table]] const Uniform &uni,
91 [[resource_table]] const Sampling &sampling,
92 [[resource_table]] const UtilityTexture &util_tx,
93 [[in]] const VertOutCommon &interp,
94 [[in]] [[condition(is_curves)]] const VertOutCurves &curves_interp,
95 [[in]] [[condition(is_pointcloud)]] const VertOutPointcloud &ptcloud_interp,
96 [[frag_coord]] const float4 frag_co,
97 [[bary_coord]] [[condition(use_barycentric)]] const float3 bary_co,
98 [[out]] DeferredFragOut &frag_out,
99 [[front_facing]] const bool front_face)
100{
101 draw::ID id{interp.resource_id_raw};
102 const uint resource_id = id.resource_id<1>();
103
104 float3 barycentric_co = float3(0.0f);
105 if (pipe.use_barycentric) [[static_branch]] {
106 barycentric_co = bary_co;
107 }
108
109 const ViewMatrices view = views.get(0);
110
111 ShadingData sd = init_globals(pipe, uni, interp, view, front_face, frag_co);
112 if (pipe.is_mesh) [[static_branch]] {
113 init_globals_mesh(interp, sd, barycentric_co);
114 }
115 else if (pipe.is_curves) [[static_branch]] {
116 init_globals_curves(interp, curves_interp, sd, view);
117 }
118 else if (pipe.is_pointcloud) [[static_branch]] {
119 init_globals_pointcloud(ptcloud_interp, sd);
120 }
121
122 float noise = util_tx.fetch(frag_co.xy, UTIL_BLUE_NOISE_LAYER).r;
123 float closure_rand = fract(noise + sampling.rng_1D_get(SAMPLING_CLOSURE));
124
125 fragment_displacement(kg, sd);
126
127 nodetree_surface(kg, sd, closure_rand);
128
129 sd.holdout = saturate(sd.holdout);
130
132 ThicknessMode(kg.nt.node_tree.thickness_mode));
133
135 float alpha = 1.0f - average(sd.transmittance);
136 float alpha_rcp = safe_rcp(alpha);
137
138 /* Object holdout. */
139 eObjectInfoFlag ob_flag = kg.object_infos_get(sd).flag;
140 if (flag_test(ob_flag, OBJECT_HOLDOUT)) {
141 /* alpha is set from rejected pixels / dithering. */
142 sd.holdout = 1.0f;
143
144 /* Set alpha to 0.0 so that lighting is not computed. */
145 alpha_rcp = 0.0f;
146 }
147
148 sd.emission *= alpha_rcp;
149
150 int2 out_texel = int2(frag_co.xy);
151
152 ObjectInfos object_infos = infos.get(resource_id);
153 bool use_light_linking = receiver_light_set_get(object_infos) != 0;
154 bool use_terminator_offset = object_infos.shadow_terminator_normal_offset > 0.0;
155
156 /* ----- Render Passes output ----- */
157
158 /* Some render pass can be written during the gbuffer pass. Light passes are written later. */
159 cryptomatte.store(out_texel, kg.nt.node_tree.crypto_hash, resource_id);
160 render_passes.store_color(
161 out_texel, uni.uniform_buf.render_pass.emission_id, float4(sd.emission, 1.0f));
162
163 /* ----- GBuffer output ----- */
164
165 gbuffer::InputClosures gbuf_data;
166 /* Make sure we do not read uninitialized data (see #159161). */
167 if (pipe.closure_bin_count == 0) [[static_branch]] {
168 gbuf_data.closure[0] = ClosureUndetermined{};
169 }
170 for (int i = 0; i < 3; i++) [[unroll]] {
171 if (pipe.closure_bin_count > i) [[static_branch]] {
172 gbuf_data.closure[i] = sd.closure_get_resolved(kg.pipe, i, alpha_rcp);
173 }
174 }
175 const bool use_object_id = pipe.use_sss || use_light_linking || use_terminator_offset;
176
177 float3 gbuffer_dither = sampling.rng_3D_get(SAMPLING_GBUFFER_U);
179 gbuf_params, gbuf_data, sd.Ng, sd.N, thickness, use_object_id);
180
181 /* Output header and first closure using frame-buffer attachment. */
182 frag_out.gbuf_header = gbuf.header;
184 gbuf.closure[0], frag_co.xy, 0u, gbuffer_dither);
186 gbuf.closure[1], frag_co.xy, 1u, gbuffer_dither);
187 frag_out.gbuf_normal = gbuf.normal[0];
188
189 /* Output remaining closures using image store. */
190 if (gbuf_params.gbuffer_layer_max >= 2) [[static_branch]] {
191 if (!gbuf_params.gbuffer_simple_layout) [[static_branch]] {
193 srt.write_closure_data(out_texel,
194 2,
196 gbuf.closure[2], frag_co.xy, 2u, gbuffer_dither));
197 }
199 srt.write_closure_data(out_texel,
200 3,
202 gbuf.closure[3], frag_co.xy, 3u, gbuffer_dither));
203 }
204 }
206 srt.write_normal_data(out_texel, 1, gbuf.normal[1]);
207 }
208 }
209 if (gbuf_params.gbuffer_layer_max >= 3) [[static_branch]] {
211 srt.write_closure_data(out_texel,
212 4,
214 gbuf.closure[4], frag_co.xy, 4u, gbuffer_dither));
215 }
217 srt.write_closure_data(out_texel,
218 5,
220 gbuf.closure[5], frag_co.xy, 5u, gbuffer_dither));
221 }
223 srt.write_normal_data(out_texel, 2, gbuf.normal[2]);
224 }
225 }
226
227 if (pipe.use_additional_data) [[static_branch]] {
229 srt.write_normal_data(
230 out_texel, uni.pipeline_buf.gbuffer_additional_data_layer_id, gbuf.additional_info);
231 }
232 }
233
234 if (flag_test(gbuf.used_layers, OBJECT_ID)) {
235 srt.write_header_data(out_texel, 1, resource_id);
236 }
237
238 /* ----- Radiance output ----- */
239
240 /* Only output emission during the gbuffer pass. */
241 frag_out.radiance = float4(sd.emission, 0.0f);
242 frag_out.radiance.rgb *= 1.0f - sd.holdout;
243 frag_out.radiance.a = sd.holdout;
244}
245
246} // 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(KernelGlobals &kg, ShadingData &sd, Closure cl)
#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
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 init_globals_pointcloud(const VertOutPointcloud &ptcloud_interp, ShadingData &sd)
void surf_deferred(KernelGlobals &kg, PipelineConstants &pipe, SurfaceDeferred &srt, gbuffer::PackParameters &gbuf_params, RenderPassOutput &render_passes, CryptomatteOutput &cryptomatte, const draw::Infos &infos, const draw::View &views, 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, const float3 bary_co, DeferredFragOut &frag_out, 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::Sampling sampling
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
float4 fetch(float2 texel, float layer) const
float rng_1D_get(const eSamplingDimension dim) const
void write_header_data(int2 texel, int layer, uint data)
void write_closure_data(int2 texel, int layer, float4 data)
void write_normal_data(int2 texel, int layer, float2 data)
ClosureUndetermined closure[GBUFFER_LAYER_MAX]
float2 normal[GBUFFER_LAYER_MAX]
float4 closure[GBUFFER_LAYER_MAX *2]