Blender V5.3
workbench_shadow.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
19
20#pragma once
21
22#include "draw_model.bsl.hh"
23#include "draw_view.bsl.hh"
24#include "gpu_shader_attribute_load_lib.glsl"
28
30
31struct VertIn {
32 /* Local position. */
34};
35
36struct VertOut {
37 /* Local position. */
39 /* Final NDC position. */
42};
43
47
48struct Constants {
50 [[compilation_constant]] const bool shadow_pass; /* shadow_fail if false. */
51};
52
53struct Resources {
55
57
60
61 /* WORKAROUND: Needed to support OpenSubdiv vertex format. Should be removed. */
63
64 [[storage(3, read), frequency(GEOMETRY)]] const float (&pos)[];
66
67 VertIn input_assembly(uint in_vertex_id) const
68 {
69 uint v_i = index_load.load(in_vertex_id);
70
71 VertIn vert_in;
72 vert_in.lP = float3(pos[gpu_attr_load_index(v_i, gpu_attr_3) + 0],
75 return vert_in;
76 }
77
78 VertOut vertex_main(VertIn vert_in, uint resource_id) const
79 {
80 VertOut vert_out;
81 vert_out.lP = vert_in.lP;
82 float3 L = this->pass_data.light_direction_ws;
83
84 ObjectMatrices model = models.get(resource_id);
85 ViewMatrices view = views.get(0);
86
87 float3 ws_P = model.point_object_to_world(vert_in.lP);
88 float extrude_distance = 1e5f;
89 float L_FP = dot(L, this->pass_data.far_plane.xyz);
90 if (L_FP > 0.0f) {
91 float signed_distance = dot(this->pass_data.far_plane.xyz, ws_P) -
92 this->pass_data.far_plane.w;
93 extrude_distance = -signed_distance / L_FP;
94 /* Ensure we don't overlap the far plane. */
95 extrude_distance -= 1e-3f;
96 }
97 vert_out.backPosition = view.point_world_to_homogenous(ws_P + L * extrude_distance);
99 model.point_object_to_world(vert_in.lP));
100 return vert_out;
101 }
102};
103
105 /* Result of evaluation. / */
107
108 void export_vertex(GeomOut geom_out)
109 {
110 out_pos = geom_out.gpu_position;
111#ifdef GPU_METAL
112 /* Apply depth bias. Prevents Z-fighting artifacts when fast-math is enabled. */
113 out_pos.z += 0.00005f;
114#endif
115 }
116
117 void emit_strip_vert(const uint strip_index,
118 uint out_vertex_id,
119 uint out_primitive_id,
120 GeomOut geom_out)
121 {
122 bool is_odd_primitive = (out_primitive_id & 1u) != 0u;
123 /* Maps triangle list primitives to triangle strip indices. */
124 uint out_strip_index = (is_odd_primitive ? (2u - out_vertex_id) : out_vertex_id) +
125 out_primitive_id;
126
127 if (out_strip_index == strip_index) {
128 export_vertex(geom_out);
129 }
130 }
131
132 void emit_triangle_vert(const uint tri_index, uint out_vertex_id, GeomOut geom_out)
133 {
134 if (out_vertex_id == tri_index) {
135 export_vertex(geom_out);
136 }
137 }
138
140 bool invert, VertOut geom_in_1, VertOut geom_in_2, uint out_vertex_id, uint out_primitive_id)
141 {
142 /* Reverse order if back-facing the light. */
143 if (invert) {
144 VertOut geom_in_tmp = geom_in_1;
145 geom_in_1 = geom_in_2;
146 geom_in_2 = geom_in_tmp;
147 }
148
149 GeomOut geom_out;
150 geom_out.gpu_position = geom_in_2.frontPosition;
151 emit_strip_vert(0, out_vertex_id, out_primitive_id, geom_out);
152
153 geom_out.gpu_position = geom_in_1.frontPosition;
154 emit_strip_vert(1, out_vertex_id, out_primitive_id, geom_out);
155
156 geom_out.gpu_position = geom_in_2.backPosition;
157 emit_strip_vert(2, out_vertex_id, out_primitive_id, geom_out);
158
159 geom_out.gpu_position = geom_in_1.backPosition;
160 emit_strip_vert(3, out_vertex_id, out_primitive_id, geom_out);
161 }
162
163 void emit_cap(bool front,
164 bool invert,
165 VertOut geom_in_0,
166 VertOut geom_in_1,
167 VertOut geom_in_2,
168 uint out_vertex_id)
169 {
170 if (invert == front) {
171 VertOut geom_in_tmp = geom_in_1;
172 geom_in_1 = geom_in_2;
173 geom_in_2 = geom_in_tmp;
174 }
175
176 GeomOut geom_out;
177 geom_out.gpu_position = front ? geom_in_0.frontPosition : geom_in_0.backPosition;
178 emit_triangle_vert(0, out_vertex_id, geom_out);
179
180 geom_out.gpu_position = front ? geom_in_1.frontPosition : geom_in_1.backPosition;
181 emit_triangle_vert(1, out_vertex_id, geom_out);
182
183 geom_out.gpu_position = front ? geom_in_2.frontPosition : geom_in_2.backPosition;
184 emit_triangle_vert(2, out_vertex_id, geom_out);
185 }
186
187 void geometry_main(const Resources &srt,
188 VertOut geom_in[4],
189 uint out_vertex_id,
190 uint out_primitive_id,
191 uint out_invocation_id,
192 uint resource_id)
193 {
194 float3 v10 = geom_in[0].lP - geom_in[1].lP;
195 float3 v12 = geom_in[2].lP - geom_in[1].lP;
196 float3 v13 = geom_in[3].lP - geom_in[1].lP;
197
198 float3 n1 = cross(v12, v10);
199 float3 n2 = cross(v13, v12);
200
201#if 1 /* DEGENERATE_TRIS_WORKAROUND */
202 /* Check if area is null, relative to the edge lengths so it does not depend on object scale.
203 * Use less or equal to include overlapping vertices, where both are zero. */
204 constexpr float DEGENERATE_TRIS_EPSILON = 1e-10f;
205 float2 faces_area = float2(length_squared(n1), length_squared(n2));
206 float2 edges_area = float2(length_squared(v12) * length_squared(v10),
207 length_squared(v13) * length_squared(v12));
208 bool2 degen_faces = lessThanEqual(faces_area, DEGENERATE_TRIS_EPSILON * edges_area);
209
210 /* Both triangles are degenerate, abort. */
211 if (all(degen_faces)) {
212 return;
213 }
214#endif
215 ObjectMatrices model = srt.models.get(resource_id);
216
217 float3 ls_light_direction = model.normal_world_to_object(
219
220 float2 facing = float2(dot(n1, ls_light_direction), dot(n2, ls_light_direction));
221
222 bool2 backface = greaterThan(facing, float2(0.0f));
223
224 /* WATCH: maybe unpredictable in some cases. */
225 bool is_manifold = any(notEqual(geom_in[0].lP, geom_in[3].lP));
226
227#if 1 /* DEGENERATE_TRIS_WORKAROUND */
228 if (srt.consts.double_manifold == false) [[static_branch]] {
229 /* If the mesh is known to be manifold and we don't use double count,
230 * only create an quad if the we encounter a facing geom. */
231 if ((degen_faces.x && backface.y) || (degen_faces.y && backface.x)) {
232 return;
233 }
234 }
235
236 /* If one of the 2 triangles is degenerate, replace edge by a non-manifold one. */
237 backface.x = (degen_faces.x) ? !backface.y : backface.x;
238 backface.y = (degen_faces.y) ? !backface.x : backface.y;
239 is_manifold = (any(degen_faces)) ? false : is_manifold;
240#endif
241
242 /* If both faces face the same direction it's not an outline edge. */
243 if (backface.x == backface.y) {
244 return;
245 }
246
248 if (out_invocation_id != 0u && !is_manifold) {
249 /* Only Increment/Decrement twice for manifold edges. */
250 return;
251 }
252 }
253
254 extrude_edge(backface.x, geom_in[1], geom_in[2], out_vertex_id, out_primitive_id);
255 }
256
258 VertOut geom_in[3],
259 uint out_vertex_id,
260 uint out_invocation_id,
261 uint resource_id)
262 {
263 float3 v10 = geom_in[0].lP - geom_in[1].lP;
264 float3 v12 = geom_in[2].lP - geom_in[1].lP;
265
266 float3 Ng = cross(v12, v10);
267
268 ObjectMatrices model = srt.models.get(resource_id);
269
270 float3 ls_light_direction = model.normal_world_to_object(
271 float3(srt.pass_data.light_direction_ws));
272
273 float facing = dot(Ng, ls_light_direction);
274
275 bool backface = facing > 0.0f;
276
277 bool invert = false;
278 bool is_manifold = true;
279 if (srt.consts.double_manifold) [[static_branch]] {
280 /* In case of non manifold geom, we only increase/decrease
281 * the stencil buffer by one but do every faces as they were facing the light. */
282 invert = backface;
283 is_manifold = false;
284 }
285
286 if (!is_manifold || !backface) {
287 bool do_front = out_invocation_id == 0;
288 emit_cap(do_front, invert, geom_in[0], geom_in[1], geom_in[2], out_vertex_id);
289 }
290 }
291};
292
293[[vertex]]
295 [[resource_table]] const draw::Resource &res,
296 [[vertex_id]] const int vert_id,
297 [[instance_index]] const int inst_index,
298 [[position]] float4 &out_position)
299{
300 /* Line adjacency primitive. */
301 constexpr uint input_primitive_vertex_count = 4u;
302 /* Triangle list primitive. */
303 constexpr uint output_primitive_vertex_count = 3u;
304 constexpr uint output_primitive_count = 2u;
305
306 uint output_invocation_count = 1u;
307 if (srt.consts.double_manifold) [[static_branch]] {
308 output_invocation_count = 2u;
309 }
310
311 constexpr uint output_vertex_count_per_invocation = output_primitive_count *
312 output_primitive_vertex_count;
313 const uint output_vertex_count_per_input_primitive = output_vertex_count_per_invocation *
314 output_invocation_count;
315
316 uint in_primitive_id = uint(vert_id) / output_vertex_count_per_input_primitive;
317 uint in_primitive_first_vertex = in_primitive_id * input_primitive_vertex_count;
318
319 uint out_vertex_id = uint(vert_id) % output_primitive_vertex_count;
320 uint out_primitive_id = (uint(vert_id) / output_primitive_vertex_count) % output_primitive_count;
321 uint out_invocation_id = (uint(vert_id) / output_vertex_count_per_invocation) %
322 output_invocation_count;
323
324 uint resource_id = res.get(inst_index).resource_id<1>();
325
326 VertIn vert_in[input_primitive_vertex_count];
327 vert_in[0] = srt.input_assembly(in_primitive_first_vertex + 0u);
328 vert_in[1] = srt.input_assembly(in_primitive_first_vertex + 1u);
329 vert_in[2] = srt.input_assembly(in_primitive_first_vertex + 2u);
330 vert_in[3] = srt.input_assembly(in_primitive_first_vertex + 3u);
331
332 VertOut vert_out[input_primitive_vertex_count];
333 vert_out[0] = srt.vertex_main(vert_in[0], resource_id);
334 vert_out[1] = srt.vertex_main(vert_in[1], resource_id);
335 vert_out[2] = srt.vertex_main(vert_in[2], resource_id);
336 vert_out[3] = srt.vertex_main(vert_in[3], resource_id);
337
339 /* Discard by default. */
340 gs.out_pos = float4(NAN_FLT);
341 gs.geometry_main(srt, vert_out, out_vertex_id, out_primitive_id, out_invocation_id, resource_id);
342 out_position = gs.out_pos;
343}
344
345[[vertex]]
347 [[resource_table]] const draw::Resource &res,
348 [[vertex_id]] const int vert_id,
349 [[instance_index]] const int inst_index,
350 [[position]] float4 &out_position)
351{
352 /* Triangle list primitive. */
353 constexpr uint input_primitive_vertex_count = 3u;
354 /* Triangle list primitive. */
355 constexpr uint output_primitive_vertex_count = 3u;
356 constexpr uint output_primitive_count = 1u;
357 constexpr uint output_invocation_count = 2u;
358
359 constexpr uint output_vertex_count_per_invocation = output_primitive_count *
360 output_primitive_vertex_count;
361 constexpr uint output_vertex_count_per_input_primitive = output_vertex_count_per_invocation *
362 output_invocation_count;
363
364 uint in_primitive_id = uint(vert_id) / output_vertex_count_per_input_primitive;
365 uint in_primitive_first_vertex = in_primitive_id * input_primitive_vertex_count;
366
367 uint out_vertex_id = uint(vert_id) % output_primitive_vertex_count;
368 uint out_invocation_id = (uint(vert_id) / output_vertex_count_per_invocation) %
369 output_invocation_count;
370
371 uint resource_id = res.get(inst_index).resource_id<1>();
372
373 VertIn vert_in[input_primitive_vertex_count];
374 vert_in[0] = srt.input_assembly(in_primitive_first_vertex + 0u);
375 vert_in[1] = srt.input_assembly(in_primitive_first_vertex + 1u);
376 vert_in[2] = srt.input_assembly(in_primitive_first_vertex + 2u);
377
378 VertOut vert_out[input_primitive_vertex_count];
379 vert_out[0] = srt.vertex_main(vert_in[0], resource_id);
380 vert_out[1] = srt.vertex_main(vert_in[1], resource_id);
381 vert_out[2] = srt.vertex_main(vert_in[2], resource_id);
382
384 /* Discard by default. */
385 gs.out_pos = float4(NAN_FLT);
386 gs.geometry_main_caps(srt, vert_out, out_vertex_id, out_invocation_id, resource_id);
387 out_position = gs.out_pos;
388}
389
390[[fragment]]
392{
393 /* No color output, only depth (line below is implicit). */
394 // gl_FragDepth = gl_FragCoord.z;
395}
396
397struct FragOut {
399};
400
401[[fragment]]
403 [[front_facing]] const bool front_facing,
404 [[out]] FragOut &frag_out)
405{
406 constexpr float a = 0.1f;
407
408 if (srt.consts.shadow_pass) [[static_branch]] {
409 frag_out.color.rgb = front_facing ? float3(a, -a, 0.0f) : float3(-a, a, 0.0f);
410 }
411 else {
412 frag_out.color.rgb = front_facing ? float3(a, a, -a) : float3(-a, -a, a);
413 }
414 frag_out.color.a = a;
415}
416
417/* clang-format off */
418PipelineGraphic pass_manifold_no_caps( vert_main, frag_main, Constants{.double_manifold = false, .shadow_pass = true});
419PipelineGraphic pass_no_manifold_no_caps( vert_main, frag_main, Constants{.double_manifold = true, .shadow_pass = true});
420PipelineGraphic fail_manifold_caps( vert_main_caps, frag_main, Constants{.double_manifold = false, .shadow_pass = false});
421PipelineGraphic fail_manifold_no_caps( vert_main, frag_main, Constants{.double_manifold = false, .shadow_pass = false});
422PipelineGraphic fail_no_manifold_caps( vert_main_caps, frag_main, Constants{.double_manifold = true, .shadow_pass = false});
423PipelineGraphic fail_no_manifold_no_caps( vert_main, frag_main, Constants{.double_manifold = true, .shadow_pass = false});
424PipelineGraphic pass_manifold_no_caps_debug( vert_main, frag_debug, Constants{.double_manifold = false, .shadow_pass = true});
425PipelineGraphic pass_no_manifold_no_caps_debug(vert_main, frag_debug, Constants{.double_manifold = true, .shadow_pass = true});
426PipelineGraphic fail_manifold_caps_debug( vert_main_caps, frag_debug, Constants{.double_manifold = false, .shadow_pass = false});
427PipelineGraphic fail_manifold_no_caps_debug( vert_main, frag_debug, Constants{.double_manifold = false, .shadow_pass = false});
428PipelineGraphic fail_no_manifold_caps_debug( vert_main_caps, frag_debug, Constants{.double_manifold = true, .shadow_pass = false});
429PipelineGraphic fail_no_manifold_no_caps_debug(vert_main, frag_debug, Constants{.double_manifold = true, .shadow_pass = false});
430/* clang-format on */
431
432} // namespace workbench::shadow
#define NAN_FLT
uint gpu_attr_load_index(uint vertex_index, int2 stride_and_offset)
#define uniform(slot)
#define instance_index
#define storage(slot, qualifiers)
#define position
#define front_facing
#define push_constant
#define compilation_constant
#define resource_table
#define static_branch
#define fragment
#define vertex_id
#define frequency(freq)
#define vertex
#define frag_color(slot)
VecBase< bool, D > notEqual(VecOp< T, D >, VecOp< T, D >) RET
VecBase< bool, D > lessThanEqual(VecOp< T, D >, VecOp< T, D >) RET
bool any(VecOp< bool, D >) RET
VecBase< bool, D > greaterThan(VecOp< T, D >, VecOp< T, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
bool all(VecOp< bool, D >) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
VecBase< bool, 2 > bool2
float2x2 invert(float2x2 mat)
float length_squared(VecT a)
#define L
PipelineGraphic pass_manifold_no_caps(vert_main, frag_main, Constants{.double_manifold=false,.shadow_pass=true})
PipelineGraphic fail_manifold_no_caps(vert_main, frag_main, Constants{.double_manifold=false,.shadow_pass=false})
PipelineGraphic pass_no_manifold_no_caps(vert_main, frag_main, Constants{.double_manifold=true,.shadow_pass=true})
PipelineGraphic fail_manifold_caps(vert_main_caps, frag_main, Constants{.double_manifold=false,.shadow_pass=false})
PipelineGraphic fail_no_manifold_caps(vert_main_caps, frag_main, Constants{.double_manifold=true,.shadow_pass=false})
PipelineGraphic fail_manifold_no_caps_debug(vert_main, frag_debug, Constants{.double_manifold=false,.shadow_pass=false})
PipelineGraphic pass_no_manifold_no_caps_debug(vert_main, frag_debug, Constants{.double_manifold=true,.shadow_pass=true})
PipelineGraphic fail_no_manifold_no_caps_debug(vert_main, frag_debug, Constants{.double_manifold=true,.shadow_pass=false})
PipelineGraphic fail_no_manifold_caps_debug(vert_main_caps, frag_debug, Constants{.double_manifold=true,.shadow_pass=false})
PipelineGraphic fail_manifold_caps_debug(vert_main_caps, frag_debug, Constants{.double_manifold=false,.shadow_pass=false})
PipelineGraphic fail_no_manifold_no_caps(vert_main, frag_main, Constants{.double_manifold=true,.shadow_pass=false})
void vert_main(const Resources &srt, const draw::Resource &res, const int vert_id, const int inst_index, float4 &out_position)
PipelineGraphic pass_manifold_no_caps_debug(vert_main, frag_debug, Constants{.double_manifold=false,.shadow_pass=true})
void frag_debug(const Resources &srt, const bool front_facing, FragOut &frag_out)
void vert_main_caps(const Resources &srt, const draw::Resource &res, const int vert_id, const int inst_index, float4 &out_position)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
uint load(uint element_index) const
float3 point_object_to_world(float3 lP) const
packed_float3 light_direction_ws
float4 point_world_to_homogenous(float3 P) const
ObjectMatrices get(uint resource_id) const
ViewMatrices get(uint view_id) const
float z
Definition sky_math.h:225
void geometry_main_caps(const Resources &srt, VertOut geom_in[3], uint out_vertex_id, uint out_invocation_id, uint resource_id)
void geometry_main(const Resources &srt, VertOut geom_in[4], uint out_vertex_id, uint out_primitive_id, uint out_invocation_id, uint resource_id)
void emit_cap(bool front, bool invert, VertOut geom_in_0, VertOut geom_in_1, VertOut geom_in_2, uint out_vertex_id)
void extrude_edge(bool invert, VertOut geom_in_1, VertOut geom_in_2, uint out_vertex_id, uint out_primitive_id)
void emit_strip_vert(const uint strip_index, uint out_vertex_id, uint out_primitive_id, GeomOut geom_out)
void emit_triangle_vert(const uint tri_index, uint out_vertex_id, GeomOut geom_out)
VertOut vertex_main(VertIn vert_in, uint resource_id) const
VertIn input_assembly(uint in_vertex_id) const