Blender V5.3
gpu_shader_nodelink.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2018-2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
14
15#pragma once
16
17#include "gpu_shader_compat.hh"
18
19#include "GPU_shader_shared.hh"
20
21#include "gpu_shader_attribute_load_lib.glsl"
23
25
31
44
48
54
55[[vertex]] void vert([[vertex_id]] const int gl_VertexID,
56 [[instance_index]] const int gpu_InstanceIndex,
57 [[resource_table]] const NodeLinkSRT &srt,
58 [[in]] const NodeLinkVertIn &v_in,
59 [[position]] float4 &gl_Position,
61{
62 constexpr float start_gradient_threshold = 0.35f;
63 constexpr float end_gradient_threshold = 0.65f;
64
65 const NodeLinkData link = srt.link_data_buf[gpu_InstanceIndex];
66
67 const float2 P0 = link.bezier_P0;
68 const float2 P1 = link.bezier_P1;
69 const float2 P2 = link.bezier_P2;
70 const float2 P3 = link.bezier_P3;
71
72 const uint3 color_ids = gpu_attr_decode_uchar4_to_uint4(link.color_ids).xyz;
73
74 const float4 color_start = (color_ids[0] < 3u) ? link.start_color :
75 srt.link_uniforms.colors[color_ids[0]];
76 const float4 color_end = (color_ids[1] < 3u) ? link.end_color :
77 srt.link_uniforms.colors[color_ids[1]];
78 const float4 color_shadow = srt.link_uniforms.colors[color_ids[2]];
79 float line_thickness = link.thickness;
80
81 /* Each instance contains both the outline and the "main" line on top. */
82 constexpr int mid_vertex = 65;
83 bool is_outline_pass = gl_VertexID < mid_vertex;
84
85 interp.line_thickness = line_thickness;
86 interp.is_main_line = (v_in.expand.y == 1.0f && !is_outline_pass) ? 1 : 0;
87 interp.has_back_link = int(link.has_back_link);
88 interp.aspect = srt.link_uniforms.aspect;
89 /* Parameters for the dashed line. */
90 interp.dash_length = link.dash_length;
91 interp.dash_factor = link.dash_factor;
92 interp.dash_alpha = link.dash_alpha;
93 /* Approximate line length, no need for real bezier length calculation. */
94 interp.line_length = distance(P0, P3);
95 /* TODO: Incorrect U, this leads to non-uniform dash distribution. */
96 interp.line_uv = v_in.uv;
97
98 if ((v_in.expand.y == 1.0f) && link.has_back_link) {
99 /* Increase width because two links are drawn. */
100 line_thickness *= 1.7f;
101 }
102
103 if (is_outline_pass) {
104 /* Outline pass. */
105 interp.final_color = color_shadow;
106 }
107 else {
108 /* Second pass. */
109 if (v_in.uv.x < start_gradient_threshold) {
110 interp.final_color = color_start;
111 }
112 else if (v_in.uv.x > end_gradient_threshold) {
113 interp.final_color = color_end;
114 }
115 else {
116 float mixFactor = (v_in.uv.x - start_gradient_threshold) /
117 (end_gradient_threshold - start_gradient_threshold);
118 interp.final_color = mix(color_start, color_end, mixFactor);
119 }
120 line_thickness *= 0.65f;
121 if (link.do_muted) {
122 interp.final_color[3] = 0.65f;
123 }
124 }
125 interp.final_color.a *= link.dim_factor;
126
127 float t = v_in.uv.x;
128 float t2 = t * t;
129 float t2_3 = 3.0f * t2;
130 float one_minus_t = 1.0f - t;
131 float one_minus_t2 = one_minus_t * one_minus_t;
132 float one_minus_t2_3 = 3.0f * one_minus_t2;
133
134 float2 point = (P0 * one_minus_t2 * one_minus_t + P1 * one_minus_t2_3 * t +
135 P2 * t2_3 * one_minus_t + P3 * t2 * t);
136
137 float2 tangent = ((P1 - P0) * one_minus_t2_3 + (P2 - P1) * 6.0f * (t - t2) + (P3 - P2) * t2_3);
138
139 /* Tangent space at t. If the inner and outer control points overlap, the tangent is invalid.
140 * Use the vector between the sockets instead. */
141 tangent = is_zero(tangent) ? normalize(P3 - P0) : normalize(tangent);
142 float2 normal = tangent.yx * float2(-1.0f, 1.0f);
143
144 /* Position vertex on the curve tangent space */
145 point += (v_in.pos.x * tangent + v_in.pos.y * normal) * srt.link_uniforms.arrow_size;
146
147 gl_Position = srt.ModelViewProjectionMatrix * float4(point, 0.0f, 1.0f);
148
149 float2 exp_axis = v_in.expand.x * tangent + v_in.expand.y * normal;
150
151 /* rotate & scale the expand axis */
152 exp_axis = srt.ModelViewProjectionMatrix[0].xy * exp_axis.xx +
153 srt.ModelViewProjectionMatrix[1].xy * exp_axis.yy;
154
155 float expand_dist = line_thickness * (v_in.uv.y * 2.0f - 1.0f);
156
157 /* Expand into a line */
158 gl_Position.xy += exp_axis * srt.link_uniforms.aspect * expand_dist;
159
160 /* If the link is not muted or is not a reroute arrow the points are squashed to the center of
161 * the line. Magic numbers are defined in `drawnode.cc`. */
162 if ((v_in.expand.x == 1.0f && !link.do_muted) ||
163 (v_in.expand.y != 1.0f && (v_in.pos.x < 0.70f || v_in.pos.x > 0.71f) && !link.do_arrow))
164 {
165 gl_Position.xy *= 0.0f;
166 }
167}
168
169#define ANTIALIAS 0.75f
170
171float get_line_alpha(float2 line_uv, float line_thickness, float center, float relative_radius)
172{
173 float radius = relative_radius * line_thickness;
174 float sdf = abs(line_thickness * (line_uv.y - center));
175 return smoothstep(radius, radius - ANTIALIAS, sdf);
176}
177
178[[fragment]] void frag([[in]] const NodeLinkVertOut &interp, [[out]] NodeLinkFragOut &frag_out)
179{
180 float dash_frag_alpha = 1.0f;
181 if (interp.dash_factor < 1.0f) {
182 float distance_along_line = interp.line_length * interp.line_uv.x;
183
184 /* Checking if `normalized_distance <= interp.dash_factor` is already enough for a basic
185 * dash, however we want to handle a nice anti-alias. */
186
187 float dash_center = interp.dash_length * interp.dash_factor * 0.5f;
188 float normalized_distance_triangle =
189 1.0f -
190 abs((fract((distance_along_line - dash_center) / interp.dash_length)) * 2.0f - 1.0f);
191 float t = interp.aspect * ANTIALIAS / interp.dash_length;
192 float slope = 1.0f / (2.0f * t);
193
194 float unclamped_alpha = 1.0f - slope * (normalized_distance_triangle - interp.dash_factor + t);
195 float alpha = max(interp.dash_alpha, min(unclamped_alpha, 1.0f));
196
197 dash_frag_alpha = alpha;
198 }
199
200 if (interp.is_main_line == 0) {
201 frag_out.color = interp.final_color;
202 frag_out.color.a *= get_line_alpha(interp.line_uv, interp.line_thickness, 0.5f, 0.5f) *
203 dash_frag_alpha;
204 return;
205 }
206
207 if (interp.has_back_link == 0) {
208 frag_out.color = interp.final_color;
209 frag_out.color.a *= get_line_alpha(interp.line_uv, interp.line_thickness, 0.5f, 0.5f) *
210 dash_frag_alpha;
211 }
212 else {
213 /* Draw two links right next to each other, the main link and the back-link. */
214 float4 main_link_color = interp.final_color;
215 main_link_color.a *= get_line_alpha(interp.line_uv, interp.line_thickness, 0.75f, 0.3f);
216
217 float4 back_link_color = float4(float3(0.8f), 1.0f);
218 back_link_color.a *= get_line_alpha(interp.line_uv, interp.line_thickness, 0.2f, 0.25f);
219
220 /* Combine both links. */
221 frag_out.color.rgb = main_link_color.rgb * main_link_color.a +
222 back_link_color.rgb * back_link_color.a;
223 frag_out.color.a = main_link_color.a * dash_frag_alpha + back_link_color.a;
224 }
225}
226
227} // namespace builtin::nodelink
228
btScalar max
uint4 gpu_attr_decode_uchar4_to_uint4(uint in_data)
#define uniform(slot)
#define instance_index
#define storage(slot, qualifiers)
#define position
#define flat
#define smooth
#define push_constant
#define resource_table
#define attribute(slot)
#define fragment
#define vertex_id
#define vertex
#define frag_color(slot)
T smoothstep(T, T, T) RET
T fract(T) RET
VecBase< float, D > normalize(VecOp< float, D >) RET
#define abs
float distance(float, float) RET
bool is_zero(float3x3 a)
ccl_device_inline float interp(const float a, const float b, const float t)
Definition math_base.h:549
MatBase< float, 4, 4 > float4x4
#define mix
#define min(a, b)
Definition sort.cc:38
float x
float y