Blender V5.3
gpu_shader_simple.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2016-2022 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
8
10
11namespace builtin {
12
13struct FragOut {
15};
16
21
35
36/* Vertex attributes. Unused ones will be optimized out. */
37struct VertIn {
39 [[attribute(1), condition(!use_uniform_color)]] float4 color;
40 [[attribute(2), condition(use_lighting)]] float3 nor;
41};
42
45};
46
50
51struct VertOutLit {
53};
54
56 /* We leverage hardware interpolation to compute distance along the line. */
57 [[flat]] float2 stipple_start; /* In screen space */
59};
60
62 [[resource_table]] const Simple &srt,
63 [[resource_table]] [[condition(use_clipping)]] const ClipPlanes &clip,
64 [[in]] const VertIn &v_in,
65 [[position]] float4 &out_pos,
66 [[out]] [[condition(!use_smooth_color)]] VertOutFlat &flat_out,
67 [[out]] [[condition(use_smooth_color)]] VertOutSmooth &smooth_out,
68 [[out]] [[condition(use_dashed)]] VertOutDashed &dashed_out,
69 [[out]] [[condition(use_lighting)]] VertOutLit &lit_out,
70 [[clip_distance]] [[condition(use_clipping)]] float (&clip_distance)[6])
71{
72 out_pos = srt.ModelViewProjectionMatrix * float4(v_in.pos, 1.0f);
73
74 if (srt.use_smooth_color) [[static_branch]] {
75 if (!srt.use_uniform_color) [[static_branch]] {
76 smooth_out.color = v_in.color;
77 }
78 }
79 else if (srt.use_uniform_color) [[static_branch]] {
80 flat_out.color = srt.color;
81 }
82 else {
83 flat_out.color = v_in.color;
84 }
85
86 if (srt.use_lighting) [[static_branch]] {
87 lit_out.normal = normalize(srt.NormalMatrix * v_in.nor);
88 }
89
90 if (srt.use_dashed) [[static_branch]] {
91 dashed_out.stipple_pos = srt.viewport_size * 0.5f * (out_pos.xy / out_pos.w);
92 dashed_out.stipple_start = dashed_out.stipple_pos;
93 }
94
95 if (srt.use_clipping) [[static_branch]] {
96 float4 ws_pos = clip.ClipModelMatrix * float4(v_in.pos, 1.0f);
97 clip_distance[0] = dot(clip.clip_planes.world[0], ws_pos);
98 clip_distance[1] = dot(clip.clip_planes.world[1], ws_pos);
99 clip_distance[2] = dot(clip.clip_planes.world[2], ws_pos);
100 clip_distance[3] = dot(clip.clip_planes.world[3], ws_pos);
101 clip_distance[4] = dot(clip.clip_planes.world[4], ws_pos);
102 clip_distance[5] = dot(clip.clip_planes.world[5], ws_pos);
103 }
104}
105
112
126
129 [[attribute(1), condition(!use_uniform_color)]] float4 color;
130 [[attribute(2), condition(!use_uniform_point_size)]] float size;
131};
132
137
139 [[resource_table]] const SimplePoint &srt,
140 [[resource_table]] [[condition(use_clipping)]] const ClipPlanes &clip,
141 [[in]] const VertInPoint &v_in,
142 [[position]] float4 &out_pos,
143 [[out]] VertOutPoint &v_out,
144 [[point_size]] float &out_point_size,
145 [[clip_distance]] [[condition(use_clipping)]] float (&clip_distance)[6])
146{
147 out_pos = srt.ModelViewProjectionMatrix * float4(v_in.pos, 1.0f);
148
149 if (srt.use_uniform_color) [[static_branch]] {
150 v_out.color = srt.color;
151 }
152 else {
153 v_out.color = v_in.color;
154 }
155
156 if (srt.use_uniform_point_size) [[static_branch]] {
157 out_point_size = srt.size;
158 }
159 else {
160 out_point_size = v_in.size;
161 }
162
163 /* Calculate concentric radii in pixels. */
164 float radius = 0.5f * out_point_size;
165 /* Start at the outside and progress toward the center. */
166 v_out.radii = float2(radius, radius - 1.0f).xyxy;
167 if (srt.point_style == POINT_CIRCLE_AA_OUTLINE) [[static_branch]] {
168 v_out.radii.zw -= srt.outlineWidth;
169 }
170 /* Convert to PointCoord units. */
171 v_out.radii /= out_point_size;
172
173 if (srt.use_clipping) [[static_branch]] {
174 float4 ws_pos = clip.ClipModelMatrix * float4(v_in.pos, 1.0f);
175 clip_distance[0] = dot(clip.clip_planes.world[0], ws_pos);
176 clip_distance[1] = dot(clip.clip_planes.world[1], ws_pos);
177 clip_distance[2] = dot(clip.clip_planes.world[2], ws_pos);
178 clip_distance[3] = dot(clip.clip_planes.world[3], ws_pos);
179 clip_distance[4] = dot(clip.clip_planes.world[4], ws_pos);
180 clip_distance[5] = dot(clip.clip_planes.world[5], ws_pos);
181 }
182}
183
186 [[point_coord]] const float2 pt_coord,
187 [[in]] const VertOutPoint &v_out,
188 [[out]] FragOut &frag_out)
189{
190 /* transparent outside of point
191 * --- 0 ---
192 * smooth transition
193 * --- 1 ---
194 * pure outline color
195 * --- 2 ---
196 * smooth transition
197 * --- 3 ---
198 * pure point color
199 * ...
200 * dist = 0 at center of point */
201 float dist = length(pt_coord - float2(0.5f));
202
203 if (srt.point_style == POINT_CIRCLE_AA_OUTLINE) [[static_branch]] {
204 float fac = smoothstep(v_out.radii[3], v_out.radii[2], dist);
205 frag_out.color = mix(v_out.color, srt.outlineColor, fac);
206 }
207 else {
208 frag_out.color = v_out.color;
209 }
210
211 if (srt.point_style > 1 /* POINT_SQUARE */) [[static_branch]] {
212 if (srt.point_style >= 3 /* POINT_CIRCLE_AA */) [[static_branch]] {
213 /* Soft transition to 0 alpha. */
214 frag_out.color.a *= mix(1.0f, 0.0f, smoothstep(v_out.radii[1], v_out.radii[0], dist));
215 }
216 else {
217 /* Round point with jagged edges. */
218 if (dist > v_out.radii[0]) {
220 }
221 }
222
223 if (frag_out.color.a == 0.0f) {
225 }
226 }
227
228 frag_out.color = colorspace.rec709_srgb_to_output_space(frag_out.color);
229}
230
232 [[resource_table]] const Simple &srt,
234 [[in]] [[condition(!use_smooth_color)]] const VertOutFlat &flat_out,
235 [[in]] [[condition(use_smooth_color)]] const VertOutSmooth &smooth_out,
236 [[out]] FragOut &frag_out)
237{
238 if (srt.use_smooth_color) [[static_branch]] {
239 frag_out.color = smooth_out.color;
240 }
241 else {
242 frag_out.color = flat_out.color;
243 }
244
245 frag_out.color = colorspace.rec709_srgb_to_output_space(frag_out.color);
246}
247
252
253[[vertex]] void simple_clip([[resource_table]] const Simple &srt,
254 [[resource_table]] const SimpleClip &clip,
255 [[in]] const VertIn &v_in,
256 [[position]] float4 &out_pos,
257 [[out]] VertOutFlat &flat_out,
258 [[clip_distance]] float (&clip_distance)[1])
259{
260 out_pos = srt.ModelViewProjectionMatrix * float4(v_in.pos, 1.0f);
261 clip_distance[0] = dot(clip.ModelMatrix * float4(v_in.pos, 1.0f), clip.ClipPlane);
262 if (srt.use_uniform_color) [[static_branch]] {
263 flat_out.color = srt.color;
264 }
265}
266
267struct Checker {
270 [[push_constant]] const int size;
271};
272
274 [[frag_coord]] const float4 frag_co,
275 [[out]] FragOut &frag_out)
276{
277 float2 phase = mod(frag_co.xy, (srt.size * 2)) / float(srt.size);
278 frag_out.color = ((phase.x > 1.0f) != (phase.y > 1.0f)) ? srt.color1 : srt.color2;
279}
280
284 [[push_constant]] const int size1;
285 [[push_constant]] const int size2;
286};
287
289 [[frag_coord]] const float4 frag_co,
290 [[out]] FragOut &frag_out)
291{
292 float phase = mod((frag_co.x + frag_co.y), float(srt.size1 + srt.size2)) / float(srt.size1);
293 frag_out.color = (phase < 1.0f) ? srt.color1 : srt.color2;
294}
295
296struct Dashed {
299 /* TODO(fclem): Remove this. And decide to discard if color2 alpha is 0. */
300 [[push_constant]] const int colors_len; /* Enabled if > 0, 1 for solid line. */
301 [[push_constant]] const float dash_width;
302 [[push_constant]] const float udash_factor; /* if > 1.0f, solid line. */
303};
304
306 [[in]] const VertOutDashed &v_out,
307 [[out]] FragOut &frag_out)
308{
309 float distance_along_line = distance(v_out.stipple_pos, v_out.stipple_start);
310 /* Solid line case, simple. */
311 if (srt.udash_factor >= 1.0f) {
312 frag_out.color = srt.color;
313 }
314 /* Actually dashed line... */
315 else {
316 float normalized_distance = fract(distance_along_line / srt.dash_width);
317 if (normalized_distance <= srt.udash_factor) {
318 frag_out.color = srt.color;
319 }
320 else if (srt.colors_len > 0) {
321 frag_out.color = srt.color2;
322 }
323 else {
325 }
326 }
327}
328
332
334 [[in]] const VertOutLit &v_out,
335 [[out]] FragOut &frag_out)
336{
337 frag_out.color = srt.simple_lighting_data.l_color;
338 frag_out.color.xyz *= clamp(
339 dot(normalize(v_out.normal), srt.simple_lighting_data.light), 0.0f, 1.0f);
340}
341
342} // namespace builtin
343
344/* clang-format off */
346 .use_uniform_color = true,
347 .use_smooth_color = false,
348 .use_clipping = false,
349 .use_dashed = false,
350 .use_lighting = false});
352 .use_uniform_color = false,
353 .use_smooth_color = false,
354 .use_clipping = false,
355 .use_dashed = false,
356 .use_lighting = false});
358 .use_uniform_color = false,
359 .use_smooth_color = true,
360 .use_clipping = false,
361 .use_dashed = false,
362 .use_lighting = false});
364 .use_uniform_color = true,
365 .use_smooth_color = false,
366 .use_clipping = false,
367 .use_dashed = true});
369 .use_uniform_color = true,
370 .use_smooth_color = false,
371 .use_clipping = false,
372 .use_dashed = false,
373 .use_lighting = true});
374
376 .use_uniform_color = true,
377 .use_smooth_color = false,
378 .use_clipping = true,
379 .use_dashed = false,
380 .use_lighting = false});
382 .use_uniform_color = false,
383 .use_smooth_color = false,
384 .use_clipping = true,
385 .use_dashed = false,
386 .use_lighting = false});
388 .use_uniform_color = false,
389 .use_smooth_color = true,
390 .use_clipping = true,
391 .use_dashed = false,
392 .use_lighting = false});
394 .use_uniform_color = true,
395 .use_smooth_color = false,
396 .use_clipping = true,
397 .use_dashed = true,
398 .use_lighting = false});
399
400/* Confusing naming convention. But this is a version with only one local clip plane. */
402 .use_uniform_color = true,
403 .use_smooth_color = false,
404 .use_clipping = true,
405 .use_dashed = false,
406 .use_lighting = false});
407
409 .point_style = 1 /* SQUARE */,
410 .use_uniform_color = true,
411 .use_uniform_point_size = true,
412 .use_clipping = false});
414 .point_style = 1 /* SQUARE */,
415 .use_uniform_color = false,
416 .use_uniform_point_size = true,
417 .use_clipping = false});
419 .point_style = 2 /* POINT_CIRCLE */,
420 .use_uniform_color = false,
421 .use_uniform_point_size = false,
422 .use_clipping = false});
424 .point_style = 3 /* POINT_CIRCLE_AA */,
425 .use_uniform_color = true,
426 .use_uniform_point_size = true,
427 .use_clipping = false});
429 .point_style = 4 /* POINT_CIRCLE_AA_OUTLINE */,
430 .use_uniform_color = true,
431 .use_uniform_point_size = true,
432 .use_clipping = false});
433
435 .point_style = 3 /* POINT_CIRCLE_AA */,
436 .use_uniform_color = true,
437 .use_uniform_point_size = true,
438 .use_clipping = true});
439
441 .use_uniform_color = true,
442 .use_smooth_color = false,
443 .use_clipping = false,
444 .use_dashed = false,
445 .use_lighting = false});
446
448 .use_uniform_color = true,
449 .use_smooth_color = false,
450 .use_clipping = false,
451 .use_dashed = false,
452 .use_lighting = false});
453/* clang-format on */
#define uniform(slot)
#define point_size
#define position
#define flat
#define frag_coord
#define smooth
#define push_constant
#define compilation_constant
#define resource_table
#define attribute(slot)
#define static_branch
#define fragment
#define frequency(freq)
#define no_perspective
#define clip_distance
#define condition(cond)
#define vertex
#define frag_color(slot)
#define point_coord
T smoothstep(T, T, T) RET
void gpu_discard_fragment()
T fract(T) RET
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
VecBase< float, D > constexpr mod(VecOp< float, D >, VecOp< float, D >) RET
float distance(float, float) RET
constexpr T clamp(T, U, U) RET
float length(VecOp< float, D >) RET
PipelineGraphic gpu_shader_3D_point_uniform_size_uniform_color_outline_aa(builtin::simple_point_vert, builtin::simple_point_frag, builtin::SimplePoint{ .point_style=4,.use_uniform_color=true,.use_uniform_point_size=true,.use_clipping=false})
PipelineGraphic gpu_shader_3D_line_dashed_uniform_color_clipped(builtin::simple_vert, builtin::dashed_line_frag, builtin::Simple{ .use_uniform_color=true,.use_smooth_color=false,.use_clipping=true,.use_dashed=true,.use_lighting=false})
PipelineGraphic gpu_shader_3D_point_flat_color(builtin::simple_point_vert, builtin::simple_point_frag, builtin::SimplePoint{ .point_style=1,.use_uniform_color=false,.use_uniform_point_size=true,.use_clipping=false})
PipelineGraphic gpu_shader_3D_uniform_color(builtin::simple_vert, builtin::simple_frag, builtin::Simple{ .use_uniform_color=true,.use_smooth_color=false,.use_clipping=false,.use_dashed=false,.use_lighting=false})
PipelineGraphic gpu_shader_3D_clipped_uniform_color(builtin::simple_clip, builtin::simple_frag, builtin::Simple{ .use_uniform_color=true,.use_smooth_color=false,.use_clipping=true,.use_dashed=false,.use_lighting=false})
PipelineGraphic gpu_shader_3D_flat_color(builtin::simple_vert, builtin::simple_frag, builtin::Simple{ .use_uniform_color=false,.use_smooth_color=false,.use_clipping=false,.use_dashed=false,.use_lighting=false})
PipelineGraphic gpu_shader_3D_point_uniform_color(builtin::simple_point_vert, builtin::simple_point_frag, builtin::SimplePoint{ .point_style=1,.use_uniform_color=true,.use_uniform_point_size=true,.use_clipping=false})
PipelineGraphic gpu_shader_3D_point_uniform_size_uniform_color_aa(builtin::simple_point_vert, builtin::simple_point_frag, builtin::SimplePoint{ .point_style=3,.use_uniform_color=true,.use_uniform_point_size=true,.use_clipping=false})
PipelineGraphic gpu_shader_simple_lighting(builtin::simple_vert, builtin::simple_lit_frag, builtin::Simple{ .use_uniform_color=true,.use_smooth_color=false,.use_clipping=false,.use_dashed=false,.use_lighting=true})
PipelineGraphic gpu_shader_3D_smooth_color(builtin::simple_vert, builtin::simple_frag, builtin::Simple{ .use_uniform_color=false,.use_smooth_color=true,.use_clipping=false,.use_dashed=false,.use_lighting=false})
PipelineGraphic gpu_shader_2D_checker(builtin::simple_vert, builtin::checker_frag, builtin::Simple{ .use_uniform_color=true,.use_smooth_color=false,.use_clipping=false,.use_dashed=false,.use_lighting=false})
PipelineGraphic gpu_shader_3D_point_uniform_size_uniform_color_aa_clipped(builtin::simple_point_vert, builtin::simple_point_frag, builtin::SimplePoint{ .point_style=3,.use_uniform_color=true,.use_uniform_point_size=true,.use_clipping=true})
PipelineGraphic gpu_shader_2D_diag_stripes(builtin::simple_vert, builtin::diag_stripes_frag, builtin::Simple{ .use_uniform_color=true,.use_smooth_color=false,.use_clipping=false,.use_dashed=false,.use_lighting=false})
PipelineGraphic gpu_shader_3D_point_varying_size_varying_color(builtin::simple_point_vert, builtin::simple_point_frag, builtin::SimplePoint{ .point_style=2,.use_uniform_color=false,.use_uniform_point_size=false,.use_clipping=false})
PipelineGraphic gpu_shader_3D_line_dashed_uniform_color(builtin::simple_vert, builtin::dashed_line_frag, builtin::Simple{ .use_uniform_color=true,.use_smooth_color=false,.use_clipping=false,.use_dashed=true})
PipelineGraphic gpu_shader_3D_uniform_color_clipped(builtin::simple_vert, builtin::simple_frag, builtin::Simple{ .use_uniform_color=true,.use_smooth_color=false,.use_clipping=true,.use_dashed=false,.use_lighting=false})
PipelineGraphic gpu_shader_3D_flat_color_clipped(builtin::simple_vert, builtin::simple_frag, builtin::Simple{ .use_uniform_color=false,.use_smooth_color=false,.use_clipping=true,.use_dashed=false,.use_lighting=false})
PipelineGraphic gpu_shader_3D_smooth_color_clipped(builtin::simple_vert, builtin::simple_frag, builtin::Simple{ .use_uniform_color=false,.use_smooth_color=true,.use_clipping=true,.use_dashed=false,.use_lighting=false})
MatBase< float, 4, 4 > float4x4
void simple_vert(const Simple &srt, const ClipPlanes &clip, const VertIn &v_in, float4 &out_pos, VertOutFlat &flat_out, VertOutSmooth &smooth_out, VertOutDashed &dashed_out, VertOutLit &lit_out, float(&clip_distance)[6])
void diag_stripes_frag(const DiagStripes &srt, const float4 frag_co, FragOut &frag_out)
void simple_clip(const Simple &srt, const SimpleClip &clip, const VertIn &v_in, float4 &out_pos, VertOutFlat &flat_out, float(&clip_distance)[1])
void checker_frag(const Checker &srt, const float4 frag_co, FragOut &frag_out)
void dashed_line_frag(const Dashed &srt, const VertOutDashed &v_out, FragOut &frag_out)
void simple_point_vert(const SimplePoint &srt, const ClipPlanes &clip, const VertInPoint &v_in, float4 &out_pos, VertOutPoint &v_out, float &out_point_size, float(&clip_distance)[6])
void simple_frag(const Simple &srt, const ColorSpace &colorspace, const VertOutFlat &flat_out, const VertOutSmooth &smooth_out, FragOut &frag_out)
void simple_lit_frag(const SimpleLit &srt, const VertOutLit &v_out, FragOut &frag_out)
void simple_point_frag(const SimplePoint &srt, const ColorSpace &colorspace, const float2 pt_coord, const VertOutPoint &v_out, FragOut &frag_out)
#define mix
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
const GPUClipPlanes & clip_planes
SimpleLightingData & simple_lighting_data
const float4x4 ModelViewProjectionMatrix
const float3x3 NormalMatrix
const float4x4 ModelViewProjectionMatrix
float x
float y