Blender V5.3
gpu_shader_material_voronoi.bsl.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2013 Inigo Quilez
2 * SPDX-FileCopyrightText: 2023 Blender Authors
3 *
4 * SPDX-License-Identifier: GPL-2.0-or-later */
5
6/*
7 * Smooth Voronoi:
8 *
9 * - https://wiki.blender.org/wiki/User:OmarSquircleArt/GSoC2019/Documentation/Smooth_Voronoi
10 *
11 * Distance To Edge based on:
12 *
13 * - https://www.iquilezles.org/www/articles/voronoilines/voronoilines.htm
14 * - https://www.shadertoy.com/view/ldl3W8
15 *
16 * With optimization to change -2..2 scan window to -1..1 for better performance,
17 * as explained in https://www.shadertoy.com/view/llG3zy.
18 */
19
20#pragma once
21
23
24#define SHD_VORONOI_EUCLIDEAN 0
25#define SHD_VORONOI_MANHATTAN 1
26#define SHD_VORONOI_CHEBYCHEV 2
27#define SHD_VORONOI_MINKOWSKI 3
28
29#define SHD_VORONOI_F1 0
30#define SHD_VORONOI_F2 1
31#define SHD_VORONOI_SMOOTH_F1 2
32#define SHD_VORONOI_DISTANCE_TO_EDGE 3
33#define SHD_VORONOI_N_SPHERE_RADIUS 4
34
36 float scale;
37 float detail;
38 float roughness;
41 float exponent;
46 int metric;
47};
48
54
55/* **** Distance Functions **** */
56
57float voronoi_distance(float a, float b)
58{
59 return abs(a - b);
60}
61
63{
64 if (params.metric == SHD_VORONOI_EUCLIDEAN) {
65 return distance(a, b);
66 }
67 if (params.metric == SHD_VORONOI_MANHATTAN) {
68 return abs(a.x - b.x) + abs(a.y - b.y);
69 }
70 if (params.metric == SHD_VORONOI_CHEBYCHEV) {
71 return max(abs(a.x - b.x), abs(a.y - b.y));
72 }
73 if (params.metric == SHD_VORONOI_MINKOWSKI) {
74 return pow(pow(abs(a.x - b.x), params.exponent) + pow(abs(a.y - b.y), params.exponent),
75 1.0f / params.exponent);
76 }
77 return 0.0f;
78}
79
81{
82 if (params.metric == SHD_VORONOI_EUCLIDEAN) {
83 return distance(a, b);
84 }
85 if (params.metric == SHD_VORONOI_MANHATTAN) {
86 return abs(a.x - b.x) + abs(a.y - b.y) + abs(a.z - b.z);
87 }
88 if (params.metric == SHD_VORONOI_CHEBYCHEV) {
89 return max(abs(a.x - b.x), max(abs(a.y - b.y), abs(a.z - b.z)));
90 }
91 if (params.metric == SHD_VORONOI_MINKOWSKI) {
92 return pow(pow(abs(a.x - b.x), params.exponent) + pow(abs(a.y - b.y), params.exponent) +
93 pow(abs(a.z - b.z), params.exponent),
94 1.0f / params.exponent);
95 }
96 return 0.0f;
97}
98
100{
101 if (params.metric == SHD_VORONOI_EUCLIDEAN) {
102 return distance(a, b);
103 }
104 if (params.metric == SHD_VORONOI_MANHATTAN) {
105 return abs(a.x - b.x) + abs(a.y - b.y) + abs(a.z - b.z) + abs(a.w - b.w);
106 }
107 if (params.metric == SHD_VORONOI_CHEBYCHEV) {
108 return max(abs(a.x - b.x), max(abs(a.y - b.y), max(abs(a.z - b.z), abs(a.w - b.w))));
109 }
110 if (params.metric == SHD_VORONOI_MINKOWSKI) {
111 return pow(pow(abs(a.x - b.x), params.exponent) + pow(abs(a.y - b.y), params.exponent) +
112 pow(abs(a.z - b.z), params.exponent) + pow(abs(a.w - b.w), params.exponent),
113 1.0f / params.exponent);
114 }
115 return 0.0f;
116}
117
118/* **** 1D Voronoi **** */
119
121{
122 return float4(0.0f, 0.0f, 0.0f, coord);
123}
124
126{
127 float cellPosition = floor(coord);
128 float localPosition = coord - cellPosition;
129
130 float minDistance = FLT_MAX;
131 float targetOffset = 0.0f;
132 float targetPosition = 0.0f;
133 for (int i = -1; i <= 1; i++) {
134 float cellOffset = i;
135 float pointPosition = cellOffset +
136 hash_float_to_float(cellPosition + cellOffset) * params.randomness;
137 float distanceToPoint = voronoi_distance(pointPosition, localPosition);
138 if (distanceToPoint < minDistance) {
139 targetOffset = cellOffset;
140 minDistance = distanceToPoint;
141 targetPosition = pointPosition;
142 }
143 }
144
145 VoronoiOutput octave;
146 octave.Distance = minDistance;
147 octave.Color = hash_float_to_vec3(cellPosition + targetOffset);
148 octave.Position = voronoi_position(targetPosition + cellPosition);
149 return octave;
150}
151
153{
154 float cellPosition = floor(coord);
155 float localPosition = coord - cellPosition;
156
157 float smoothDistance = 0.0f;
158 float smoothPosition = 0.0f;
159 float3 smoothColor = float3(0.0f);
160 float h = -1.0f;
161 for (int i = -2; i <= 2; i++) {
162 float cellOffset = i;
163 float pointPosition = cellOffset +
164 hash_float_to_float(cellPosition + cellOffset) * params.randomness;
165 float distanceToPoint = voronoi_distance(pointPosition, localPosition);
166 h = h == -1.0f ?
167 1.0f :
169 0.0f, 1.0f, 0.5f + 0.5f * (smoothDistance - distanceToPoint) / params.smoothness);
170 float correctionFactor = params.smoothness * h * (1.0f - h);
171 smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
172 correctionFactor /= 1.0f + 3.0f * params.smoothness;
173 float3 cellColor = hash_float_to_vec3(cellPosition + cellOffset);
174 smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
175 smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
176 }
177
178 VoronoiOutput octave;
179 octave.Distance = smoothDistance;
180 octave.Color = smoothColor;
181 octave.Position = voronoi_position(cellPosition + smoothPosition);
182 return octave;
183}
184
186{
187 float cellPosition = floor(coord);
188 float localPosition = coord - cellPosition;
189
190 float distanceF1 = FLT_MAX;
191 float distanceF2 = FLT_MAX;
192 float offsetF1 = 0.0f;
193 float positionF1 = 0.0f;
194 float offsetF2 = 0.0f;
195 float positionF2 = 0.0f;
196 for (int i = -1; i <= 1; i++) {
197 float cellOffset = i;
198 float pointPosition = cellOffset +
199 hash_float_to_float(cellPosition + cellOffset) * params.randomness;
200 float distanceToPoint = voronoi_distance(pointPosition, localPosition);
201 if (distanceToPoint < distanceF1) {
202 distanceF2 = distanceF1;
203 distanceF1 = distanceToPoint;
204 offsetF2 = offsetF1;
205 offsetF1 = cellOffset;
206 positionF2 = positionF1;
207 positionF1 = pointPosition;
208 }
209 else if (distanceToPoint < distanceF2) {
210 distanceF2 = distanceToPoint;
211 offsetF2 = cellOffset;
212 positionF2 = pointPosition;
213 }
214 }
215
216 VoronoiOutput octave;
217 octave.Distance = distanceF2;
218 octave.Color = hash_float_to_vec3(cellPosition + offsetF2);
219 octave.Position = voronoi_position(positionF2 + cellPosition);
220 return octave;
221}
222
223float voronoi_distance_to_edge(VoronoiParams params, float coord)
224{
225 float cellPosition = floor(coord);
226 float localPosition = coord - cellPosition;
227
228 float midPointPosition = hash_float_to_float(cellPosition) * params.randomness;
229 float leftPointPosition = -1.0f + hash_float_to_float(cellPosition - 1.0f) * params.randomness;
230 float rightPointPosition = 1.0f + hash_float_to_float(cellPosition + 1.0f) * params.randomness;
231 float distanceToMidLeft = abs((midPointPosition + leftPointPosition) / 2.0f - localPosition);
232 float distanceToMidRight = abs((midPointPosition + rightPointPosition) / 2.0f - localPosition);
233
234 return min(distanceToMidLeft, distanceToMidRight);
235}
236
237float voronoi_n_sphere_radius(VoronoiParams params, float coord)
238{
239 float cellPosition = floor(coord);
240 float localPosition = coord - cellPosition;
241
242 float closestPoint = 0.0f;
243 float closestPointOffset = 0.0f;
244 float minDistance = FLT_MAX;
245 for (int i = -1; i <= 1; i++) {
246 float cellOffset = i;
247 float pointPosition = cellOffset +
248 hash_float_to_float(cellPosition + cellOffset) * params.randomness;
249 float distanceToPoint = abs(pointPosition - localPosition);
250 if (distanceToPoint < minDistance) {
251 minDistance = distanceToPoint;
252 closestPoint = pointPosition;
253 closestPointOffset = cellOffset;
254 }
255 }
256
257 minDistance = FLT_MAX;
258 float closestPointToClosestPoint = 0.0f;
259 for (int i = -1; i <= 1; i++) {
260 if (i == 0) {
261 continue;
262 }
263 float cellOffset = i + closestPointOffset;
264 float pointPosition = cellOffset +
265 hash_float_to_float(cellPosition + cellOffset) * params.randomness;
266 float distanceToPoint = abs(closestPoint - pointPosition);
267 if (distanceToPoint < minDistance) {
268 minDistance = distanceToPoint;
269 closestPointToClosestPoint = pointPosition;
270 }
271 }
272
273 return abs(closestPointToClosestPoint - closestPoint) / 2.0f;
274}
275
276/* **** 2D Voronoi **** */
277
279{
280 return float4(coord.x, coord.y, 0.0f, 0.0f);
281}
282
284{
285 float2 cellPosition_f = floor(coord);
286 float2 localPosition = coord - cellPosition_f;
287 int2 cellPosition = int2(cellPosition_f);
288
289 float minDistance = FLT_MAX;
290 int2 targetOffset = int2(0);
291 float2 targetPosition = float2(0.0f);
292 for (int j = -1; j <= 1; j++) {
293 for (int i = -1; i <= 1; i++) {
294 int2 cellOffset = int2(i, j);
295 float2 pointPosition = float2(cellOffset) +
296 hash_int2_to_vec2(cellPosition + cellOffset) * params.randomness;
297 float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
298 if (distanceToPoint < minDistance) {
299 targetOffset = cellOffset;
300 minDistance = distanceToPoint;
301 targetPosition = pointPosition;
302 }
303 }
304 }
305
306 VoronoiOutput octave;
307 octave.Distance = minDistance;
308 octave.Color = hash_int2_to_vec3(cellPosition + targetOffset);
309 octave.Position = voronoi_position(targetPosition + cellPosition_f);
310 return octave;
311}
312
314{
315 float2 cellPosition_f = floor(coord);
316 float2 localPosition = coord - cellPosition_f;
317 int2 cellPosition = int2(cellPosition_f);
318
319 float smoothDistance = 0.0f;
320 float3 smoothColor = float3(0.0f);
321 float2 smoothPosition = float2(0.0f);
322 float h = -1.0f;
323 for (int j = -2; j <= 2; j++) {
324 for (int i = -2; i <= 2; i++) {
325 int2 cellOffset = int2(i, j);
326 float2 pointPosition = float2(cellOffset) +
327 hash_int2_to_vec2(cellPosition + cellOffset) * params.randomness;
328 float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
329 h = h == -1.0f ?
330 1.0f :
331 smoothstep(0.0f,
332 1.0f,
333 0.5f + 0.5f * (smoothDistance - distanceToPoint) / params.smoothness);
334 float correctionFactor = params.smoothness * h * (1.0f - h);
335 smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
336 correctionFactor /= 1.0f + 3.0f * params.smoothness;
337 float3 cellColor = hash_int2_to_vec3(cellPosition + cellOffset);
338 smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
339 smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
340 }
341 }
342
343 VoronoiOutput octave;
344 octave.Distance = smoothDistance;
345 octave.Color = smoothColor;
346 octave.Position = voronoi_position(cellPosition_f + smoothPosition);
347 return octave;
348}
349
351{
352 float2 cellPosition_f = floor(coord);
353 float2 localPosition = coord - cellPosition_f;
354 int2 cellPosition = int2(cellPosition_f);
355
356 float distanceF1 = FLT_MAX;
357 float distanceF2 = FLT_MAX;
358 int2 offsetF1 = int2(0);
359 float2 positionF1 = float2(0.0f);
360 int2 offsetF2 = int2(0);
361 float2 positionF2 = float2(0.0f);
362 for (int j = -1; j <= 1; j++) {
363 for (int i = -1; i <= 1; i++) {
364 int2 cellOffset = int2(i, j);
365 float2 pointPosition = float2(cellOffset) +
366 hash_int2_to_vec2(cellPosition + cellOffset) * params.randomness;
367 float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
368 if (distanceToPoint < distanceF1) {
369 distanceF2 = distanceF1;
370 distanceF1 = distanceToPoint;
371 offsetF2 = offsetF1;
372 offsetF1 = cellOffset;
373 positionF2 = positionF1;
374 positionF1 = pointPosition;
375 }
376 else if (distanceToPoint < distanceF2) {
377 distanceF2 = distanceToPoint;
378 offsetF2 = cellOffset;
379 positionF2 = pointPosition;
380 }
381 }
382 }
383
384 VoronoiOutput octave;
385 octave.Distance = distanceF2;
386 octave.Color = hash_int2_to_vec3(cellPosition + offsetF2);
387 octave.Position = voronoi_position(positionF2 + cellPosition_f);
388 return octave;
389}
390
392{
393 float2 cellPosition_f = floor(coord);
394 float2 localPosition = coord - cellPosition_f;
395 int2 cellPosition = int2(cellPosition_f);
396
397 float2 vectorToClosest = float2(0.0f);
398 float minDistance = FLT_MAX;
399 for (int j = -1; j <= 1; j++) {
400 for (int i = -1; i <= 1; i++) {
401 int2 cellOffset = int2(i, j);
402 float2 vectorToPoint = float2(cellOffset) +
403 hash_int2_to_vec2(cellPosition + cellOffset) * params.randomness -
404 localPosition;
405 float distanceToPoint = dot(vectorToPoint, vectorToPoint);
406 if (distanceToPoint < minDistance) {
407 minDistance = distanceToPoint;
408 vectorToClosest = vectorToPoint;
409 }
410 }
411 }
412
413 minDistance = FLT_MAX;
414 for (int j = -1; j <= 1; j++) {
415 for (int i = -1; i <= 1; i++) {
416 int2 cellOffset = int2(i, j);
417 float2 vectorToPoint = float2(cellOffset) +
418 hash_int2_to_vec2(cellPosition + cellOffset) * params.randomness -
419 localPosition;
420 float2 perpendicularToEdge = vectorToPoint - vectorToClosest;
421 if (dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
422 float distanceToEdge = dot((vectorToClosest + vectorToPoint) / 2.0f,
423 normalize(perpendicularToEdge));
424 minDistance = min(minDistance, distanceToEdge);
425 }
426 }
427 }
428
429 return minDistance;
430}
431
433{
434 float2 cellPosition_f = floor(coord);
435 float2 localPosition = coord - cellPosition_f;
436 int2 cellPosition = int2(cellPosition_f);
437
438 float2 closestPoint = float2(0.0f);
439 int2 closestPointOffset = int2(0);
440 float minDistance = FLT_MAX;
441 for (int j = -1; j <= 1; j++) {
442 for (int i = -1; i <= 1; i++) {
443 int2 cellOffset = int2(i, j);
444 float2 pointPosition = float2(cellOffset) +
445 hash_int2_to_vec2(cellPosition + cellOffset) * params.randomness;
446 float distanceToPoint = distance(pointPosition, localPosition);
447 if (distanceToPoint < minDistance) {
448 minDistance = distanceToPoint;
449 closestPoint = pointPosition;
450 closestPointOffset = cellOffset;
451 }
452 }
453 }
454
455 minDistance = FLT_MAX;
456 float2 closestPointToClosestPoint = float2(0.0f);
457 for (int j = -1; j <= 1; j++) {
458 for (int i = -1; i <= 1; i++) {
459 if (i == 0 && j == 0) {
460 continue;
461 }
462 int2 cellOffset = int2(i, j) + closestPointOffset;
463 float2 pointPosition = float2(cellOffset) +
464 hash_int2_to_vec2(cellPosition + cellOffset) * params.randomness;
465 float distanceToPoint = distance(closestPoint, pointPosition);
466 if (distanceToPoint < minDistance) {
467 minDistance = distanceToPoint;
468 closestPointToClosestPoint = pointPosition;
469 }
470 }
471 }
472
473 return distance(closestPointToClosestPoint, closestPoint) / 2.0f;
474}
475
476/* **** 3D Voronoi **** */
477
479{
480 return float4(coord.x, coord.y, coord.z, 0.0f);
481}
482
484{
485 float3 cellPosition_f = floor(coord);
486 float3 localPosition = coord - cellPosition_f;
487 int3 cellPosition = int3(cellPosition_f);
488
489 float minDistance = FLT_MAX;
490 int3 targetOffset = int3(0);
491 float3 targetPosition = float3(0.0f);
492 for (int k = -1; k <= 1; k++) {
493 for (int j = -1; j <= 1; j++) {
494 for (int i = -1; i <= 1; i++) {
495 int3 cellOffset = int3(i, j, k);
496 float3 pointPosition = float3(cellOffset) +
497 hash_int3_to_vec3(cellPosition + cellOffset) * params.randomness;
498 float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
499 if (distanceToPoint < minDistance) {
500 targetOffset = cellOffset;
501 minDistance = distanceToPoint;
502 targetPosition = pointPosition;
503 }
504 }
505 }
506 }
507
508 VoronoiOutput octave;
509 octave.Distance = minDistance;
510 octave.Color = hash_int3_to_vec3(cellPosition + targetOffset);
511 octave.Position = voronoi_position(targetPosition + cellPosition_f);
512 return octave;
513}
514
516{
517 float3 cellPosition_f = floor(coord);
518 float3 localPosition = coord - cellPosition_f;
519 int3 cellPosition = int3(cellPosition_f);
520
521 float smoothDistance = 0.0f;
522 float3 smoothColor = float3(0.0f);
523 float3 smoothPosition = float3(0.0f);
524 float h = -1.0f;
525 for (int k = -2; k <= 2; k++) {
526 for (int j = -2; j <= 2; j++) {
527 for (int i = -2; i <= 2; i++) {
528 int3 cellOffset = int3(i, j, k);
529 float3 pointPosition = float3(cellOffset) +
530 hash_int3_to_vec3(cellPosition + cellOffset) * params.randomness;
531 float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
532 h = h == -1.0f ?
533 1.0f :
534 smoothstep(0.0f,
535 1.0f,
536 0.5f + 0.5f * (smoothDistance - distanceToPoint) / params.smoothness);
537 float correctionFactor = params.smoothness * h * (1.0f - h);
538 smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
539 correctionFactor /= 1.0f + 3.0f * params.smoothness;
540 float3 cellColor = hash_int3_to_vec3(cellPosition + cellOffset);
541 smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
542 smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
543 }
544 }
545 }
546
547 VoronoiOutput octave;
548 octave.Distance = smoothDistance;
549 octave.Color = smoothColor;
550 octave.Position = voronoi_position(cellPosition_f + smoothPosition);
551 return octave;
552}
553
555{
556 float3 cellPosition_f = floor(coord);
557 float3 localPosition = coord - cellPosition_f;
558 int3 cellPosition = int3(cellPosition_f);
559
560 float distanceF1 = FLT_MAX;
561 float distanceF2 = FLT_MAX;
562 int3 offsetF1 = int3(0);
563 float3 positionF1 = float3(0.0f);
564 int3 offsetF2 = int3(0);
565 float3 positionF2 = float3(0.0f);
566 for (int k = -1; k <= 1; k++) {
567 for (int j = -1; j <= 1; j++) {
568 for (int i = -1; i <= 1; i++) {
569 int3 cellOffset = int3(i, j, k);
570 float3 pointPosition = float3(cellOffset) +
571 hash_int3_to_vec3(cellPosition + cellOffset) * params.randomness;
572 float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
573 if (distanceToPoint < distanceF1) {
574 distanceF2 = distanceF1;
575 distanceF1 = distanceToPoint;
576 offsetF2 = offsetF1;
577 offsetF1 = cellOffset;
578 positionF2 = positionF1;
579 positionF1 = pointPosition;
580 }
581 else if (distanceToPoint < distanceF2) {
582 distanceF2 = distanceToPoint;
583 offsetF2 = cellOffset;
584 positionF2 = pointPosition;
585 }
586 }
587 }
588 }
589
590 VoronoiOutput octave;
591 octave.Distance = distanceF2;
592 octave.Color = hash_int3_to_vec3(cellPosition + offsetF2);
593 octave.Position = voronoi_position(positionF2 + cellPosition_f);
594 return octave;
595}
596
598{
599 float3 cellPosition_f = floor(coord);
600 float3 localPosition = coord - cellPosition_f;
601 int3 cellPosition = int3(cellPosition_f);
602
603 float3 vectorToClosest = float3(0.0f);
604 float minDistance = FLT_MAX;
605 for (int k = -1; k <= 1; k++) {
606 for (int j = -1; j <= 1; j++) {
607 for (int i = -1; i <= 1; i++) {
608 int3 cellOffset = int3(i, j, k);
609 float3 vectorToPoint = float3(cellOffset) +
610 hash_int3_to_vec3(cellPosition + cellOffset) * params.randomness -
611 localPosition;
612 float distanceToPoint = dot(vectorToPoint, vectorToPoint);
613 if (distanceToPoint < minDistance) {
614 minDistance = distanceToPoint;
615 vectorToClosest = vectorToPoint;
616 }
617 }
618 }
619 }
620
621 minDistance = FLT_MAX;
622 for (int k = -1; k <= 1; k++) {
623 for (int j = -1; j <= 1; j++) {
624 for (int i = -1; i <= 1; i++) {
625 int3 cellOffset = int3(i, j, k);
626 float3 vectorToPoint = float3(cellOffset) +
627 hash_int3_to_vec3(cellPosition + cellOffset) * params.randomness -
628 localPosition;
629 float3 perpendicularToEdge = vectorToPoint - vectorToClosest;
630 if (dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
631 float distanceToEdge = dot((vectorToClosest + vectorToPoint) / 2.0f,
632 normalize(perpendicularToEdge));
633 minDistance = min(minDistance, distanceToEdge);
634 }
635 }
636 }
637 }
638
639 return minDistance;
640}
641
643{
644 float3 cellPosition_f = floor(coord);
645 float3 localPosition = coord - cellPosition_f;
646 int3 cellPosition = int3(cellPosition_f);
647
648 float3 closestPoint = float3(0.0f);
649 int3 closestPointOffset = int3(0);
650 float minDistance = FLT_MAX;
651 for (int k = -1; k <= 1; k++) {
652 for (int j = -1; j <= 1; j++) {
653 for (int i = -1; i <= 1; i++) {
654 int3 cellOffset = int3(i, j, k);
655 float3 pointPosition = float3(cellOffset) +
656 hash_int3_to_vec3(cellPosition + cellOffset) * params.randomness;
657 float distanceToPoint = distance(pointPosition, localPosition);
658 if (distanceToPoint < minDistance) {
659 minDistance = distanceToPoint;
660 closestPoint = pointPosition;
661 closestPointOffset = cellOffset;
662 }
663 }
664 }
665 }
666
667 minDistance = FLT_MAX;
668 float3 closestPointToClosestPoint = float3(0.0f);
669 for (int k = -1; k <= 1; k++) {
670 for (int j = -1; j <= 1; j++) {
671 for (int i = -1; i <= 1; i++) {
672 if (i == 0 && j == 0 && k == 0) {
673 continue;
674 }
675 int3 cellOffset = int3(i, j, k) + closestPointOffset;
676 float3 pointPosition = float3(cellOffset) +
677 hash_int3_to_vec3(cellPosition + cellOffset) * params.randomness;
678 float distanceToPoint = distance(closestPoint, pointPosition);
679 if (distanceToPoint < minDistance) {
680 minDistance = distanceToPoint;
681 closestPointToClosestPoint = pointPosition;
682 }
683 }
684 }
685 }
686
687 return distance(closestPointToClosestPoint, closestPoint) / 2.0f;
688}
689
690/* **** 4D Voronoi **** */
691
693{
694 return coord;
695}
696
698{
699 float4 cellPosition_f = floor(coord);
700 float4 localPosition = coord - cellPosition_f;
701 int4 cellPosition = int4(cellPosition_f);
702
703 float minDistance = FLT_MAX;
704 int4 targetOffset = int4(0);
705 float4 targetPosition = float4(0.0f);
706 for (int u = -1; u <= 1; u++) {
707 for (int k = -1; k <= 1; k++) {
708 for (int j = -1; j <= 1; j++) {
709 for (int i = -1; i <= 1; i++) {
710 int4 cellOffset = int4(i, j, k, u);
711 float4 pointPosition = float4(cellOffset) +
712 hash_int4_to_vec4(cellPosition + cellOffset) * params.randomness;
713 float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
714 if (distanceToPoint < minDistance) {
715 targetOffset = cellOffset;
716 minDistance = distanceToPoint;
717 targetPosition = pointPosition;
718 }
719 }
720 }
721 }
722 }
723
724 VoronoiOutput octave;
725 octave.Distance = minDistance;
726 octave.Color = hash_int4_to_vec3(cellPosition + targetOffset);
727 octave.Position = voronoi_position(targetPosition + cellPosition_f);
728 return octave;
729}
730
732{
733 float4 cellPosition_f = floor(coord);
734 float4 localPosition = coord - cellPosition_f;
735 int4 cellPosition = int4(cellPosition_f);
736
737 float smoothDistance = 0.0f;
738 float3 smoothColor = float3(0.0f);
739 float4 smoothPosition = float4(0.0f);
740 float h = -1.0f;
741 for (int u = -2; u <= 2; u++) {
742 for (int k = -2; k <= 2; k++) {
743 for (int j = -2; j <= 2; j++) {
744 for (int i = -2; i <= 2; i++) {
745 int4 cellOffset = int4(i, j, k, u);
746 float4 pointPosition = float4(cellOffset) +
747 hash_int4_to_vec4(cellPosition + cellOffset) * params.randomness;
748 float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
749 h = h == -1.0f ?
750 1.0f :
751 smoothstep(0.0f,
752 1.0f,
753 0.5f + 0.5f * (smoothDistance - distanceToPoint) / params.smoothness);
754 float correctionFactor = params.smoothness * h * (1.0f - h);
755 smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
756 correctionFactor /= 1.0f + 3.0f * params.smoothness;
757 float3 cellColor = hash_int4_to_vec3(cellPosition + cellOffset);
758 smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
759 smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
760 }
761 }
762 }
763 }
764
765 VoronoiOutput octave;
766 octave.Distance = smoothDistance;
767 octave.Color = smoothColor;
768 octave.Position = voronoi_position(cellPosition_f + smoothPosition);
769 return octave;
770}
771
773{
774 float4 cellPosition_f = floor(coord);
775 float4 localPosition = coord - cellPosition_f;
776 int4 cellPosition = int4(cellPosition_f);
777
778 float distanceF1 = FLT_MAX;
779 float distanceF2 = FLT_MAX;
780 int4 offsetF1 = int4(0);
781 float4 positionF1 = float4(0.0f);
782 int4 offsetF2 = int4(0);
783 float4 positionF2 = float4(0.0f);
784 for (int u = -1; u <= 1; u++) {
785 for (int k = -1; k <= 1; k++) {
786 for (int j = -1; j <= 1; j++) {
787 for (int i = -1; i <= 1; i++) {
788 int4 cellOffset = int4(i, j, k, u);
789 float4 pointPosition = float4(cellOffset) +
790 hash_int4_to_vec4(cellPosition + cellOffset) * params.randomness;
791 float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
792 if (distanceToPoint < distanceF1) {
793 distanceF2 = distanceF1;
794 distanceF1 = distanceToPoint;
795 offsetF2 = offsetF1;
796 offsetF1 = cellOffset;
797 positionF2 = positionF1;
798 positionF1 = pointPosition;
799 }
800 else if (distanceToPoint < distanceF2) {
801 distanceF2 = distanceToPoint;
802 offsetF2 = cellOffset;
803 positionF2 = pointPosition;
804 }
805 }
806 }
807 }
808 }
809
810 VoronoiOutput octave;
811 octave.Distance = distanceF2;
812 octave.Color = hash_int4_to_vec3(cellPosition + offsetF2);
813 octave.Position = voronoi_position(positionF2 + cellPosition_f);
814 return octave;
815}
816
818{
819 float4 cellPosition_f = floor(coord);
820 float4 localPosition = coord - cellPosition_f;
821 int4 cellPosition = int4(cellPosition_f);
822
823 float4 vectorToClosest = float4(0.0f);
824 float minDistance = FLT_MAX;
825 for (int u = -1; u <= 1; u++) {
826 for (int k = -1; k <= 1; k++) {
827 for (int j = -1; j <= 1; j++) {
828 for (int i = -1; i <= 1; i++) {
829 int4 cellOffset = int4(i, j, k, u);
830 float4 vectorToPoint = float4(cellOffset) +
831 hash_int4_to_vec4(cellPosition + cellOffset) * params.randomness -
832 localPosition;
833 float distanceToPoint = dot(vectorToPoint, vectorToPoint);
834 if (distanceToPoint < minDistance) {
835 minDistance = distanceToPoint;
836 vectorToClosest = vectorToPoint;
837 }
838 }
839 }
840 }
841 }
842
843 minDistance = FLT_MAX;
844 for (int u = -1; u <= 1; u++) {
845 for (int k = -1; k <= 1; k++) {
846 for (int j = -1; j <= 1; j++) {
847 for (int i = -1; i <= 1; i++) {
848 int4 cellOffset = int4(i, j, k, u);
849 float4 vectorToPoint = float4(cellOffset) +
850 hash_int4_to_vec4(cellPosition + cellOffset) * params.randomness -
851 localPosition;
852 float4 perpendicularToEdge = vectorToPoint - vectorToClosest;
853 if (dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
854 float distanceToEdge = dot((vectorToClosest + vectorToPoint) / 2.0f,
855 normalize(perpendicularToEdge));
856 minDistance = min(minDistance, distanceToEdge);
857 }
858 }
859 }
860 }
861 }
862
863 return minDistance;
864}
865
867{
868 float4 cellPosition_f = floor(coord);
869 float4 localPosition = coord - cellPosition_f;
870 int4 cellPosition = int4(cellPosition_f);
871
872 float4 closestPoint = float4(0.0f);
873 int4 closestPointOffset = int4(0);
874 float minDistance = FLT_MAX;
875 for (int u = -1; u <= 1; u++) {
876 for (int k = -1; k <= 1; k++) {
877 for (int j = -1; j <= 1; j++) {
878 for (int i = -1; i <= 1; i++) {
879 int4 cellOffset = int4(i, j, k, u);
880 float4 pointPosition = float4(cellOffset) +
881 hash_int4_to_vec4(cellPosition + cellOffset) * params.randomness;
882 float distanceToPoint = distance(pointPosition, localPosition);
883 if (distanceToPoint < minDistance) {
884 minDistance = distanceToPoint;
885 closestPoint = pointPosition;
886 closestPointOffset = cellOffset;
887 }
888 }
889 }
890 }
891 }
892
893 minDistance = FLT_MAX;
894 float4 closestPointToClosestPoint = float4(0.0f);
895 for (int u = -1; u <= 1; u++) {
896 for (int k = -1; k <= 1; k++) {
897 for (int j = -1; j <= 1; j++) {
898 for (int i = -1; i <= 1; i++) {
899 if (i == 0 && j == 0 && k == 0 && u == 0) {
900 continue;
901 }
902 int4 cellOffset = int4(i, j, k, u) + closestPointOffset;
903 float4 pointPosition = float4(cellOffset) +
904 hash_int4_to_vec4(cellPosition + cellOffset) * params.randomness;
905 float distanceToPoint = distance(closestPoint, pointPosition);
906 if (distanceToPoint < minDistance) {
907 minDistance = distanceToPoint;
908 closestPointToClosestPoint = pointPosition;
909 }
910 }
911 }
912 }
913 }
914
915 return distance(closestPointToClosestPoint, closestPoint) / 2.0f;
916}
btScalar max
float3 hash_int2_to_vec3(int2 k)
float3 hash_float_to_vec3(float k)
float2 hash_int2_to_vec2(int2 k)
float4 hash_int4_to_vec4(int4 k)
float3 hash_int3_to_vec3(int3 k)
float hash_float_to_float(float k)
float3 hash_int4_to_vec3(int4 k)
#define FLT_MAX
T smoothstep(T, T, T) RET
#define pow
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
#define abs
#define floor
float distance(float, float) RET
#define SHD_VORONOI_CHEBYCHEV
float voronoi_distance(float a, float b)
#define SHD_VORONOI_MINKOWSKI
float voronoi_n_sphere_radius(VoronoiParams params, float coord)
#define SHD_VORONOI_EUCLIDEAN
VoronoiOutput voronoi_f1(VoronoiParams params, float coord)
VoronoiOutput voronoi_smooth_f1(VoronoiParams params, float coord)
#define SHD_VORONOI_MANHATTAN
VoronoiOutput voronoi_f2(VoronoiParams params, float coord)
float4 voronoi_position(float coord)
float voronoi_distance_to_edge(VoronoiParams params, float coord)
#define mix
#define min(a, b)
Definition sort.cc:38
float x
float y
float z
Definition sky_math.h:136
float y
Definition sky_math.h:136
float x
Definition sky_math.h:136
float y
Definition sky_math.h:225
float z
Definition sky_math.h:225
float x
Definition sky_math.h:225
float w
Definition sky_math.h:225