Blender V5.3
eevee_surf_forward.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
10#pragma once
11
12#include "draw_view.bsl.hh"
19
21{
22 [[resource_table]] const eevee::PipelineConstants &pipe = kg.pipe;
23 if (!pipe.is_occupancy_pipe) [[static_branch]] {
24 [[resource_table]] const draw::View &views = kg.view;
25 [[resource_table]] const eevee::Sampling &sampling = kg.sampling;
26 [[resource_table]] const UtilityTexture &util_tx = kg.util_tx;
28 const uint resource_id = id.resource_id<1>();
29
30 const float2 frag_co = sd.frag_co.xy;
31
32 float3 radiance, transmittance;
34 kg, sd, views.get(0), resource_id, sd.thickness, frag_co, radiance, transmittance);
35
36 /* Reset for the next closure tree. */
37 float noise = util_tx.fetch(frag_co, UTIL_BLUE_NOISE_LAYER).r;
38 float closure_rand = fract(noise + sampling.rng_1D_get(SAMPLING_CLOSURE));
39 closure_weights_reset(kg, sd, closure_rand);
40
43 [[resource_table]] eevee::LightprobeSphereRenderData &lp_spheres = lightprobes.spheres;
46
47 float3 V = -views.get(0).world_incident_vector(sd.P);
48 eevee::LightProbeSample samp = lightprobes.load(frag_co, sd.P, sd.N, V);
49 float3 radiance_behind = lp_spheres.spherical_sample_normalized_with_parallax(
50 samp, sd.P, V, 0.0);
51
52 int2 texel = int2(frag_co);
53 if (texelFetchExtend(prev_hiz.hiz_prev_tx, texel, 0).x != 1.0f) {
54 radiance_behind = texelFetch(prev_radiance.previous_layer_radiance_tx, texel, 0).xyz;
55 }
56
57 radiance += radiance_behind * saturate(transmittance);
58 }
59
60 return float4(radiance, saturate(1.0f - average(transmittance)));
61 }
62 else {
63 return float4(0);
64 }
65}
66
67namespace eevee {
68
70 /* Splitting RGB components into different target to overcome the lack of dual source blending
71 * with multiple render targets. */
76};
77
78/* Early fragment test is needed for render passes support for forward surfaces. */
79/* NOTE: This removes the possibility of using gl_FragDepth. */
83 [[resource_table]] LightEvalIterator & /*lights*/,
84 [[resource_table]] LightprobeRenderData & /*lightprobes*/,
85 [[resource_table]] LightprobePlaneRenderData & /*lightprobe_planes*/,
86 [[resource_table]] const draw::View &views,
87 [[resource_table]] const draw::Model & /*models*/,
88 [[resource_table]] const draw::Infos & /*infos*/,
89 [[resource_table]] const UnifiedVolumeData &volumes,
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 [[out]] SurfaceForwardFragOut &frag_out,
98 [[bary_coord]] [[condition(use_barycentric)]] const float3 bary_co,
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 const ViewMatrices view = views.get(0);
105
106 float3 barycentric_co = float3(0.0f);
107 if (pipe.use_barycentric) [[static_branch]] {
108 barycentric_co = bary_co;
109 }
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
128 ThicknessMode(kg.nt.node_tree.thickness_mode));
129
130 nodetree_surface(kg, sd, closure_rand);
131
132 float3 radiance, transmittance;
134 kg, sd, view, resource_id, sd.thickness, frag_co.xy, radiance, transmittance);
135
136 if (pipe.use_lighting_nodes) [[static_branch]] {
137 radiance += sd.light_accum.diffuse_light;
138 radiance += sd.light_accum.glossy_light;
139 radiance += sd.light_accum.transmission_light;
140 }
141
142 /* Volumetric resolve and compositing. */
143 float2 uvs = frag_co.xy * uni.uniform_buf.volumes.main_view_extent_inv;
144 VolumeResolveSample vol = volumes.resolve(float3(uvs, reverse_z::read(frag_co.z)));
145 /* Removes the part of the volume scattering that has
146 * already been added to the destination pixels by the opaque resolve.
147 * Since we do that using the blending pipeline we need to account for material transmittance. */
148 vol.scattering -= vol.scattering * sd.transmittance;
149 radiance = radiance * vol.transmittance + vol.scattering;
150
151 eObjectInfoFlag ob_flag = kg.object_infos_get(sd).flag;
152 if (flag_test(ob_flag, OBJECT_HOLDOUT)) {
153 sd.holdout = 1.0f - average(sd.transmittance);
154 radiance *= 0.0f;
155 }
156
157 sd.holdout = saturate(sd.holdout);
158
159 radiance *= 1.0f - sd.holdout;
160
161 /* There can be 2 frame-buffer layout for forward transparency:
162 * - Combined RGB radiance with Monochromatic transmittance.
163 * - Channel split RGB radiance & RGB transmittance + Dedicated average alpha with holdout. */
164 if (uni.pipeline_buf.use_monochromatic_transmittance) {
165 frag_out.combined_r = float4(radiance.rgb, transmittance.r);
166 }
167 else {
168 frag_out.combined_r = float4(radiance.r, 0.0f, 0.0f, transmittance.r);
169 frag_out.combined_g = float4(radiance.g, 0.0f, 0.0f, transmittance.g);
170 frag_out.combined_b = float4(radiance.b, 0.0f, 0.0f, transmittance.b);
171 frag_out.combined_a = float4(sd.holdout, 0.0f, 0.0f, average(transmittance));
172 }
173}
174
175} // namespace eevee
static Thickness from(float value, ThicknessMode mode)
@ OBJECT_HOLDOUT
#define UTIL_BLUE_NOISE_LAYER
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_forward(KernelGlobals &kg, ShadingData &sd, Closure)
#define front_facing
#define early_fragment_tests
#define bary_coord
#define frag_coord
#define resource_table
#define static_branch
#define fragment
#define condition(cond)
#define frag_color(slot)
T fract(T) RET
TEX_TEMPLATE DataVec texelFetch(T, IntCoord, int) RET
float4 texelFetchExtend(sampler2D, int2, int) RET
float noise(float p)
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_forward(KernelGlobals &kg, PipelineConstants &pipe, LightEvalIterator &, LightprobeRenderData &, LightprobePlaneRenderData &, const draw::View &views, const draw::Model &, const draw::Infos &, const UnifiedVolumeData &volumes, 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, SurfaceForwardFragOut &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)
T read(T depth_buffer_value)
#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
packed_float3 transmittance
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
float x
Definition sky_math.h:225
CCL_NAMESPACE_BEGIN struct Window V