Blender V5.3
gpu_shader_material_fractal_voronoi.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
9
10/* TODO(jbakker): Deduplicate code when OpenGL backend has been removed.
11 * `fractal_voronoi_x_fx` functions are identical, except for the input parameter.
12 * It used to be a macro, but didn't work on legacy drivers. */
13
14/* The fractalization logic is the same as for fBM Noise, except that some additions are replaced
15 * by lerps. */
16template<typename T> float fractal_voronoi_distance_to_edge(VoronoiParams params, T coord)
17{
18 float amplitude = 1.0f;
19 float max_amplitude = params.max_distance;
20 float scale = 1.0f;
21 float distance = 8.0f;
22
23 bool zero_input = params.detail == 0.0f || params.roughness == 0.0f;
24
25 for (int i = 0; i <= ceil(params.detail); ++i) {
26 float octave_distance = voronoi_distance_to_edge(params, coord * scale);
27
28 if (zero_input) {
29 distance = octave_distance;
30 break;
31 }
32 if (i <= params.detail) {
33 max_amplitude = mix(max_amplitude, params.max_distance / scale, amplitude);
34 distance = mix(distance, min(distance, octave_distance / scale), amplitude);
35 scale *= params.lacunarity;
36 amplitude *= params.roughness;
37 }
38 else {
39 float remainder = params.detail - floor(params.detail);
40 if (remainder != 0.0f) {
41 float lerp_amplitude = mix(max_amplitude, params.max_distance / scale, amplitude);
42 max_amplitude = mix(max_amplitude, lerp_amplitude, remainder);
43 float lerp_distance = mix(distance, min(distance, octave_distance / scale), amplitude);
44 distance = mix(distance, min(distance, lerp_distance), remainder);
45 }
46 }
47 }
48
49 if (params.normalize) {
50 distance /= max_amplitude;
51 }
52
53 return distance;
54}
55
56/* **** 1D Fractal Voronoi **** */
57
58/* The fractalization logic is the same as for fBM Noise, except that some additions are replaced
59 * by lerps. */
61{
62 float amplitude = 1.0f;
63 float max_amplitude = 0.0f;
64 float scale = 1.0f;
65
66 VoronoiOutput Output;
67 Output.Distance = 0.0f;
68 Output.Color = float3(0.0f, 0.0f, 0.0f);
69 Output.Position = float4(0.0f, 0.0f, 0.0f, 0.0f);
70 bool zero_input = params.detail == 0.0f || params.roughness == 0.0f;
71
72 for (int i = 0; i <= ceil(params.detail); ++i) {
73 VoronoiOutput octave;
74 if (params.feature == SHD_VORONOI_F2) {
75 octave = voronoi_f2(params, coord * scale);
76 }
77 else if (params.feature == SHD_VORONOI_SMOOTH_F1 && params.smoothness != 0.0f) {
78 octave = voronoi_smooth_f1(params, coord * scale);
79 }
80 else {
81 octave = voronoi_f1(params, coord * scale);
82 }
83
84 if (zero_input) {
85 max_amplitude = 1.0f;
86 Output = octave;
87 break;
88 }
89 if (i <= params.detail) {
90 max_amplitude += amplitude;
91 Output.Distance += octave.Distance * amplitude;
92 Output.Color += octave.Color * amplitude;
93 Output.Position = mix(Output.Position, octave.Position / scale, amplitude);
94 scale *= params.lacunarity;
95 amplitude *= params.roughness;
96 }
97 else {
98 float remainder = params.detail - floor(params.detail);
99 if (remainder != 0.0f) {
100 max_amplitude = mix(max_amplitude, max_amplitude + amplitude, remainder);
101 Output.Distance = mix(
102 Output.Distance, Output.Distance + octave.Distance * amplitude, remainder);
103 Output.Color = mix(Output.Color, Output.Color + octave.Color * amplitude, remainder);
104 Output.Position = mix(
105 Output.Position, mix(Output.Position, octave.Position / scale, amplitude), remainder);
106 }
107 }
108 }
109
110 if (params.normalize) {
111 Output.Distance /= max_amplitude * params.max_distance;
112 Output.Color /= max_amplitude;
113 }
114
115 Output.Position = safe_divide(Output.Position, params.scale);
116
117 return Output;
118}
119
120template float fractal_voronoi_distance_to_edge<float>(VoronoiParams params, float coord);
121
122/* **** 2D Fractal Voronoi **** */
123
124/* The fractalization logic is the same as for fBM Noise, except that some additions are replaced
125 * by lerps. */
127{
128 float amplitude = 1.0f;
129 float max_amplitude = 0.0f;
130 float scale = 1.0f;
131
132 VoronoiOutput Output;
133 Output.Distance = 0.0f;
134 Output.Color = float3(0.0f, 0.0f, 0.0f);
135 Output.Position = float4(0.0f, 0.0f, 0.0f, 0.0f);
136 bool zero_input = params.detail == 0.0f || params.roughness == 0.0f;
137
138 for (int i = 0; i <= ceil(params.detail); ++i) {
139 VoronoiOutput octave;
140 if (params.feature == SHD_VORONOI_F2) {
141 octave = voronoi_f2(params, coord * scale);
142 }
143 else if (params.feature == SHD_VORONOI_SMOOTH_F1 && params.smoothness != 0.0f) {
144 octave = voronoi_smooth_f1(params, coord * scale);
145 }
146 else {
147 octave = voronoi_f1(params, coord * scale);
148 }
149
150 if (zero_input) {
151 max_amplitude = 1.0f;
152 Output = octave;
153 break;
154 }
155 else if (i <= params.detail) {
156 max_amplitude += amplitude;
157 Output.Distance += octave.Distance * amplitude;
158 Output.Color += octave.Color * amplitude;
159 Output.Position = mix(Output.Position, octave.Position / scale, amplitude);
160 scale *= params.lacunarity;
161 amplitude *= params.roughness;
162 }
163 else {
164 float remainder = params.detail - floor(params.detail);
165 if (remainder != 0.0f) {
166 max_amplitude = mix(max_amplitude, max_amplitude + amplitude, remainder);
167 Output.Distance = mix(
168 Output.Distance, Output.Distance + octave.Distance * amplitude, remainder);
169 Output.Color = mix(Output.Color, Output.Color + octave.Color * amplitude, remainder);
170 Output.Position = mix(
171 Output.Position, mix(Output.Position, octave.Position / scale, amplitude), remainder);
172 }
173 }
174 }
175
176 if (params.normalize) {
177 Output.Distance /= max_amplitude * params.max_distance;
178 Output.Color /= max_amplitude;
179 }
180
181 Output.Position = safe_divide(Output.Position, params.scale);
182
183 return Output;
184}
185
187
188/* **** 3D Fractal Voronoi **** */
189
190/* The fractalization logic is the same as for fBM Noise, except that some additions are replaced
191 * by lerps. */
193{
194 float amplitude = 1.0f;
195 float max_amplitude = 0.0f;
196 float scale = 1.0f;
197
198 VoronoiOutput Output;
199 Output.Distance = 0.0f;
200 Output.Color = float3(0.0f, 0.0f, 0.0f);
201 Output.Position = float4(0.0f, 0.0f, 0.0f, 0.0f);
202 bool zero_input = params.detail == 0.0f || params.roughness == 0.0f;
203
204 for (int i = 0; i <= ceil(params.detail); ++i) {
205 VoronoiOutput octave;
206 if (params.feature == SHD_VORONOI_F2) {
207 octave = voronoi_f2(params, coord * scale);
208 }
209 else if (params.feature == SHD_VORONOI_SMOOTH_F1 && params.smoothness != 0.0f) {
210 octave = voronoi_smooth_f1(params, coord * scale);
211 }
212 else {
213 octave = voronoi_f1(params, coord * scale);
214 }
215
216 if (zero_input) {
217 max_amplitude = 1.0f;
218 Output = octave;
219 break;
220 }
221 else if (i <= params.detail) {
222 max_amplitude += amplitude;
223 Output.Distance += octave.Distance * amplitude;
224 Output.Color += octave.Color * amplitude;
225 Output.Position = mix(Output.Position, octave.Position / scale, amplitude);
226 scale *= params.lacunarity;
227 amplitude *= params.roughness;
228 }
229 else {
230 float remainder = params.detail - floor(params.detail);
231 if (remainder != 0.0f) {
232 max_amplitude = mix(max_amplitude, max_amplitude + amplitude, remainder);
233 Output.Distance = mix(
234 Output.Distance, Output.Distance + octave.Distance * amplitude, remainder);
235 Output.Color = mix(Output.Color, Output.Color + octave.Color * amplitude, remainder);
236 Output.Position = mix(
237 Output.Position, mix(Output.Position, octave.Position / scale, amplitude), remainder);
238 }
239 }
240 }
241
242 if (params.normalize) {
243 Output.Distance /= max_amplitude * params.max_distance;
244 Output.Color /= max_amplitude;
245 }
246
247 Output.Position = safe_divide(Output.Position, params.scale);
248
249 return Output;
250}
251
253
254/* **** 4D Fractal Voronoi **** */
255
256/* The fractalization logic is the same as for fBM Noise, except that some additions are replaced
257 * by lerps. */
259{
260 float amplitude = 1.0f;
261 float max_amplitude = 0.0f;
262 float scale = 1.0f;
263
264 VoronoiOutput Output;
265 Output.Distance = 0.0f;
266 Output.Color = float3(0.0f, 0.0f, 0.0f);
267 Output.Position = float4(0.0f, 0.0f, 0.0f, 0.0f);
268 bool zero_input = params.detail == 0.0f || params.roughness == 0.0f;
269
270 for (int i = 0; i <= ceil(params.detail); ++i) {
271 VoronoiOutput octave;
272 if (params.feature == SHD_VORONOI_F2) {
273 octave = voronoi_f2(params, coord * scale);
274 }
275 else if (params.feature == SHD_VORONOI_SMOOTH_F1 && params.smoothness != 0.0f) {
276 octave = voronoi_smooth_f1(params, coord * scale);
277 }
278 else {
279 octave = voronoi_f1(params, coord * scale);
280 }
281
282 if (zero_input) {
283 max_amplitude = 1.0f;
284 Output = octave;
285 break;
286 }
287 else if (i <= params.detail) {
288 max_amplitude += amplitude;
289 Output.Distance += octave.Distance * amplitude;
290 Output.Color += octave.Color * amplitude;
291 Output.Position = mix(Output.Position, octave.Position / scale, amplitude);
292 scale *= params.lacunarity;
293 amplitude *= params.roughness;
294 }
295 else {
296 float remainder = params.detail - floor(params.detail);
297 if (remainder != 0.0f) {
298 max_amplitude = mix(max_amplitude, max_amplitude + amplitude, remainder);
299 Output.Distance = mix(
300 Output.Distance, Output.Distance + octave.Distance * amplitude, remainder);
301 Output.Color = mix(Output.Color, Output.Color + octave.Color * amplitude, remainder);
302 Output.Position = mix(
303 Output.Position, mix(Output.Position, octave.Position / scale, amplitude), remainder);
304 }
305 }
306 }
307
308 if (params.normalize) {
309 Output.Distance /= max_amplitude * params.max_distance;
310 Output.Color /= max_amplitude;
311 }
312
313 Output.Position = safe_divide(Output.Position, params.scale);
314
315 return Output;
316}
317
#define floor
float distance(float, float) RET
#define ceil
VoronoiOutput fractal_voronoi_x_fx(VoronoiParams params, float coord)
float fractal_voronoi_distance_to_edge(VoronoiParams params, T coord)
#define SHD_VORONOI_SMOOTH_F1
VoronoiOutput voronoi_f1(VoronoiParams params, float coord)
VoronoiOutput voronoi_smooth_f1(VoronoiParams params, float coord)
VoronoiOutput voronoi_f2(VoronoiParams params, float coord)
float voronoi_distance_to_edge(VoronoiParams params, float coord)
float3x3 scale(float3x3 mat, float2 scale)
float safe_divide(float a, float b)
#define T
#define mix
#define min(a, b)
Definition sort.cc:38