Blender V5.3
voronoi.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#pragma once
6
8#include "kernel/svm/util.h"
9#include "util/hash.h"
10
12
13/*
14 * SPDX-License-Identifier: MIT
15 * Original code is copyright (c) 2013 Inigo Quilez.
16 *
17 * Smooth Voronoi:
18 *
19 * - https://wiki.blender.org/wiki/User:OmarSquircleArt/GSoC2019/Documentation/Smooth_Voronoi
20 *
21 * Distance To Edge based on:
22 *
23 * - https://www.iquilezles.org/www/articles/voronoilines/voronoilines.htm
24 * - https://www.shadertoy.com/view/ldl3W8
25 *
26 * With optimization to change -2..2 scan window to -1..1 for better performance,
27 * as explained in https://www.shadertoy.com/view/llG3zy.
28 */
29
30struct VoronoiParams {
31 float scale;
32 float detail;
33 float roughness;
34 float lacunarity;
35 float smoothness;
36 float exponent;
37 float randomness;
38 float max_distance;
39 bool normalize;
42};
43
44struct VoronoiOutput {
45 float distance = 0.0f;
48};
49
50/* ***** Distances ***** */
51
52ccl_device float voronoi_distance(const float a, const float b)
53{
54 return fabsf(b - a);
55}
56
57template<typename T>
58ccl_device float voronoi_distance(const T a, const T b, const ccl_private VoronoiParams &params)
59{
60 if (params.metric == NODE_VORONOI_EUCLIDEAN) {
61 return distance(a, b);
62 }
63 if (params.metric == NODE_VORONOI_MANHATTAN) {
64 return reduce_add(fabs(a - b));
65 }
66 if (params.metric == NODE_VORONOI_CHEBYCHEV) {
67 return reduce_max(fabs(a - b));
68 }
69 if (params.metric == NODE_VORONOI_MINKOWSKI) {
70 return powf(reduce_add(power(fabs(a - b), params.exponent)), 1.0f / params.exponent);
71 }
72 return 0.0f;
73}
74
75/* Possibly cheaper/faster version of Voronoi distance, in a way that does not change
76 * logic of "which distance is the closest?". */
77template<typename T>
79 const T b,
80 const ccl_private VoronoiParams &params)
81{
82 if (params.metric == NODE_VORONOI_EUCLIDEAN) {
83 return len_squared(a - b);
84 }
85 if (params.metric == NODE_VORONOI_MANHATTAN) {
86 return reduce_add(fabs(a - b));
87 }
88 if (params.metric == NODE_VORONOI_CHEBYCHEV) {
89 return reduce_max(fabs(a - b));
90 }
91 if (params.metric == NODE_VORONOI_MINKOWSKI) {
92 return reduce_add(power(fabs(a - b), params.exponent));
93 }
94 return 0.0f;
95}
96
97/* **** 1D Voronoi **** */
98
100{
101 return make_float4(0.0f, 0.0f, 0.0f, coord);
102}
103
105{
106 const float cellPosition = floorf(coord);
107 const float localPosition = coord - cellPosition;
108
109 float minDistance = FLT_MAX;
110 float targetOffset = 0.0f;
111 float targetPosition = 0.0f;
112 for (int i = -1; i <= 1; i++) {
113 const float cellOffset = i;
114 const float pointPosition = cellOffset +
115 hash_float_to_float(cellPosition + cellOffset) * params.randomness;
116 const float distanceToPoint = voronoi_distance(pointPosition, localPosition);
117 if (distanceToPoint < minDistance) {
118 targetOffset = cellOffset;
119 minDistance = distanceToPoint;
120 targetPosition = pointPosition;
121 }
122 }
123
124 VoronoiOutput octave;
125 octave.distance = minDistance;
126 octave.color = hash_float_to_float3(cellPosition + targetOffset);
127 octave.position = voronoi_position(targetPosition + cellPosition);
128 return octave;
129}
130
132 const float coord)
133{
134 const float cellPosition = floorf(coord);
135 const float localPosition = coord - cellPosition;
136
137 float smoothDistance = 0.0f;
138 float smoothPosition = 0.0f;
139 float3 smoothColor = make_float3(0.0f, 0.0f, 0.0f);
140 float h = -1.0f;
141 for (int i = -2; i <= 2; i++) {
142 const float cellOffset = i;
143 const float pointPosition = cellOffset +
144 hash_float_to_float(cellPosition + cellOffset) * params.randomness;
145 const float distanceToPoint = voronoi_distance(pointPosition, localPosition);
146 h = h == -1.0f ?
147 1.0f :
149 0.0f, 1.0f, 0.5f + 0.5f * (smoothDistance - distanceToPoint) / params.smoothness);
150 float correctionFactor = params.smoothness * h * (1.0f - h);
151 smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
152 correctionFactor /= 1.0f + 3.0f * params.smoothness;
153 const float3 cellColor = hash_float_to_float3(cellPosition + cellOffset);
154 smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
155 smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
156 }
157
158 VoronoiOutput octave;
159 octave.distance = smoothDistance;
160 octave.color = smoothColor;
161 octave.position = voronoi_position(cellPosition + smoothPosition);
162 return octave;
163}
164
166{
167 const float cellPosition = floorf(coord);
168 const float localPosition = coord - cellPosition;
169
170 float distanceF1 = FLT_MAX;
171 float distanceF2 = FLT_MAX;
172 float offsetF1 = 0.0f;
173 float positionF1 = 0.0f;
174 float offsetF2 = 0.0f;
175 float positionF2 = 0.0f;
176 for (int i = -1; i <= 1; i++) {
177 const float cellOffset = i;
178 const float pointPosition = cellOffset +
179 hash_float_to_float(cellPosition + cellOffset) * params.randomness;
180 const float distanceToPoint = voronoi_distance(pointPosition, localPosition);
181 if (distanceToPoint < distanceF1) {
182 distanceF2 = distanceF1;
183 distanceF1 = distanceToPoint;
184 offsetF2 = offsetF1;
185 offsetF1 = cellOffset;
186 positionF2 = positionF1;
187 positionF1 = pointPosition;
188 }
189 else if (distanceToPoint < distanceF2) {
190 distanceF2 = distanceToPoint;
191 offsetF2 = cellOffset;
192 positionF2 = pointPosition;
193 }
194 }
195
196 VoronoiOutput octave;
197 octave.distance = distanceF2;
198 octave.color = hash_float_to_float3(cellPosition + offsetF2);
199 octave.position = voronoi_position(positionF2 + cellPosition);
200 return octave;
201}
202
204 const float coord)
205{
206 const float cellPosition = floorf(coord);
207 const float localPosition = coord - cellPosition;
208
209 const float midPointPosition = hash_float_to_float(cellPosition) * params.randomness;
210 const float leftPointPosition = -1.0f +
211 hash_float_to_float(cellPosition - 1.0f) * params.randomness;
212 const float rightPointPosition = 1.0f +
213 hash_float_to_float(cellPosition + 1.0f) * params.randomness;
214 const float distanceToMidLeft = fabsf((midPointPosition + leftPointPosition) / 2.0f -
215 localPosition);
216 const float distanceToMidRight = fabsf((midPointPosition + rightPointPosition) / 2.0f -
217 localPosition);
218
219 return min(distanceToMidLeft, distanceToMidRight);
220}
221
223 const float coord)
224{
225 const float cellPosition = floorf(coord);
226 const float localPosition = coord - cellPosition;
227
228 float closestPoint = 0.0f;
229 float closestPointOffset = 0.0f;
230 float minDistance = FLT_MAX;
231 for (int i = -1; i <= 1; i++) {
232 const float cellOffset = i;
233 const float pointPosition = cellOffset +
234 hash_float_to_float(cellPosition + cellOffset) * params.randomness;
235 const float distanceToPoint = fabsf(pointPosition - localPosition);
236 if (distanceToPoint < minDistance) {
237 minDistance = distanceToPoint;
238 closestPoint = pointPosition;
239 closestPointOffset = cellOffset;
240 }
241 }
242
243 minDistance = FLT_MAX;
244 float closestPointToClosestPoint = 0.0f;
245 for (int i = -1; i <= 1; i++) {
246 if (i == 0) {
247 continue;
248 }
249 const float cellOffset = i + closestPointOffset;
250 const float pointPosition = cellOffset +
251 hash_float_to_float(cellPosition + cellOffset) * params.randomness;
252 const float distanceToPoint = fabsf(closestPoint - pointPosition);
253 if (distanceToPoint < minDistance) {
254 minDistance = distanceToPoint;
255 closestPointToClosestPoint = pointPosition;
256 }
257 }
258
259 return fabsf(closestPointToClosestPoint - closestPoint) / 2.0f;
260}
261
262/* **** 2D Voronoi **** */
263
265{
266 return make_float4(coord.x, coord.y, 0.0f, 0.0f);
267}
268
270{
271 const float2 cellPosition_f = floor(coord);
272 const float2 localPosition = coord - cellPosition_f;
273 const int2 cellPosition = make_int2(cellPosition_f);
274
275 float minDistance = FLT_MAX;
276 int2 targetOffset = make_int2(0);
277 float2 targetPosition = make_float2(0.0f, 0.0f);
278 for (int j = -1; j <= 1; j++) {
279 for (int i = -1; i <= 1; i++) {
280 const int2 cellOffset = make_int2(i, j);
281 const float2 pointPosition = make_float2(cellOffset) +
282 hash_int2_to_float2(cellPosition + cellOffset) *
283 params.randomness;
284 const float distanceToPoint = voronoi_distance_bound(pointPosition, localPosition, params);
285 if (distanceToPoint < minDistance) {
286 targetOffset = cellOffset;
287 minDistance = distanceToPoint;
288 targetPosition = pointPosition;
289 }
290 }
291 }
292
293 VoronoiOutput octave;
294 octave.distance = voronoi_distance(targetPosition, localPosition, params);
295 octave.color = hash_int2_to_float3(cellPosition + targetOffset);
296 octave.position = voronoi_position(targetPosition + cellPosition_f);
297 return octave;
298}
299
301 const float2 coord)
302{
303 const float2 cellPosition_f = floor(coord);
304 const float2 localPosition = coord - cellPosition_f;
305 const int2 cellPosition = make_int2(cellPosition_f);
306
307 float smoothDistance = 0.0f;
308 float3 smoothColor = make_float3(0.0f, 0.0f, 0.0f);
309 float2 smoothPosition = make_float2(0.0f, 0.0f);
310 float h = -1.0f;
311 for (int j = -2; j <= 2; j++) {
312 for (int i = -2; i <= 2; i++) {
313 const int2 cellOffset = make_int2(i, j);
314 const float2 pointPosition = make_float2(cellOffset) +
315 hash_int2_to_float2(cellPosition + cellOffset) *
316 params.randomness;
317 const float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
318 h = h == -1.0f ?
319 1.0f :
320 smoothstep(0.0f,
321 1.0f,
322 0.5f + 0.5f * (smoothDistance - distanceToPoint) / params.smoothness);
323 float correctionFactor = params.smoothness * h * (1.0f - h);
324 smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
325 correctionFactor /= 1.0f + 3.0f * params.smoothness;
326 const float3 cellColor = hash_int2_to_float3(cellPosition + cellOffset);
327 smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
328 smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
329 }
330 }
331
332 VoronoiOutput octave;
333 octave.distance = smoothDistance;
334 octave.color = smoothColor;
335 octave.position = voronoi_position(cellPosition_f + smoothPosition);
336 return octave;
337}
338
340{
341 const float2 cellPosition_f = floor(coord);
342 const float2 localPosition = coord - cellPosition_f;
343 const int2 cellPosition = make_int2(cellPosition_f);
344
345 float distanceF1 = FLT_MAX;
346 float distanceF2 = FLT_MAX;
347 int2 offsetF1 = make_int2(0);
348 float2 positionF1 = make_float2(0.0f, 0.0f);
349 int2 offsetF2 = make_int2(0);
350 float2 positionF2 = make_float2(0.0f, 0.0f);
351 for (int j = -1; j <= 1; j++) {
352 for (int i = -1; i <= 1; i++) {
353 const int2 cellOffset = make_int2(i, j);
354 const float2 pointPosition = make_float2(cellOffset) +
355 hash_int2_to_float2(cellPosition + cellOffset) *
356 params.randomness;
357 const float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
358 if (distanceToPoint < distanceF1) {
359 distanceF2 = distanceF1;
360 distanceF1 = distanceToPoint;
361 offsetF2 = offsetF1;
362 offsetF1 = cellOffset;
363 positionF2 = positionF1;
364 positionF1 = pointPosition;
365 }
366 else if (distanceToPoint < distanceF2) {
367 distanceF2 = distanceToPoint;
368 offsetF2 = cellOffset;
369 positionF2 = pointPosition;
370 }
371 }
372 }
373
374 VoronoiOutput octave;
375 octave.distance = distanceF2;
376 octave.color = hash_int2_to_float3(cellPosition + offsetF2);
377 octave.position = voronoi_position(positionF2 + cellPosition_f);
378 return octave;
379}
380
382 const float2 coord)
383{
384 const float2 cellPosition_f = floor(coord);
385 const float2 localPosition = coord - cellPosition_f;
386 const int2 cellPosition = make_int2(cellPosition_f);
387
388 float2 vectorToClosest = make_float2(0.0f, 0.0f);
389 float minDistance = FLT_MAX;
390 for (int j = -1; j <= 1; j++) {
391 for (int i = -1; i <= 1; i++) {
392 const int2 cellOffset = make_int2(i, j);
393 const float2 vectorToPoint = make_float2(cellOffset) +
394 hash_int2_to_float2(cellPosition + cellOffset) *
395 params.randomness -
396 localPosition;
397 const float distanceToPoint = dot(vectorToPoint, vectorToPoint);
398 if (distanceToPoint < minDistance) {
399 minDistance = distanceToPoint;
400 vectorToClosest = vectorToPoint;
401 }
402 }
403 }
404
405 minDistance = FLT_MAX;
406 for (int j = -1; j <= 1; j++) {
407 for (int i = -1; i <= 1; i++) {
408 const int2 cellOffset = make_int2(i, j);
409 const float2 vectorToPoint = make_float2(cellOffset) +
410 hash_int2_to_float2(cellPosition + cellOffset) *
411 params.randomness -
412 localPosition;
413 const float2 perpendicularToEdge = vectorToPoint - vectorToClosest;
414 if (dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
415 const float distanceToEdge = dot((vectorToClosest + vectorToPoint) / 2.0f,
416 normalize(perpendicularToEdge));
417 minDistance = min(minDistance, distanceToEdge);
418 }
419 }
420 }
421
422 return minDistance;
423}
424
426 const float2 coord)
427{
428 const float2 cellPosition_f = floor(coord);
429 const float2 localPosition = coord - cellPosition_f;
430 const int2 cellPosition = make_int2(cellPosition_f);
431
432 float2 closestPoint = make_float2(0.0f, 0.0f);
433 int2 closestPointOffset = make_int2(0);
434 float minDistanceSq = FLT_MAX;
435 for (int j = -1; j <= 1; j++) {
436 for (int i = -1; i <= 1; i++) {
437 const int2 cellOffset = make_int2(i, j);
438 const float2 pointPosition = make_float2(cellOffset) +
439 hash_int2_to_float2(cellPosition + cellOffset) *
440 params.randomness;
441 const float distanceToPointSq = len_squared(pointPosition - localPosition);
442 if (distanceToPointSq < minDistanceSq) {
443 minDistanceSq = distanceToPointSq;
444 closestPoint = pointPosition;
445 closestPointOffset = cellOffset;
446 }
447 }
448 }
449
450 minDistanceSq = FLT_MAX;
451 float2 closestPointToClosestPoint = make_float2(0.0f, 0.0f);
452 for (int j = -1; j <= 1; j++) {
453 for (int i = -1; i <= 1; i++) {
454 if (i == 0 && j == 0) {
455 continue;
456 }
457 const int2 cellOffset = make_int2(i, j) + closestPointOffset;
458 const float2 pointPosition = make_float2(cellOffset) +
459 hash_int2_to_float2(cellPosition + cellOffset) *
460 params.randomness;
461 const float distanceToPointSq = len_squared(closestPoint - pointPosition);
462 if (distanceToPointSq < minDistanceSq) {
463 minDistanceSq = distanceToPointSq;
464 closestPointToClosestPoint = pointPosition;
465 }
466 }
467 }
468
469 return distance(closestPointToClosestPoint, closestPoint) / 2.0f;
470}
471
472/* **** 3D Voronoi **** */
473
475{
476 return make_float4(coord);
477}
478
480{
481 const float3 cellPosition_f = floor(coord);
482 const float3 localPosition = coord - cellPosition_f;
483 const int3 cellPosition = make_int3(cellPosition_f);
484
485 float minDistance = FLT_MAX;
486 int3 targetOffset = make_int3(0);
487 float3 targetPosition = make_float3(0.0f, 0.0f, 0.0f);
488 for (int k = -1; k <= 1; k++) {
489 for (int j = -1; j <= 1; j++) {
490 for (int i = -1; i <= 1; i++) {
491 const int3 cellOffset = make_int3(i, j, k);
492 const float3 pointPosition = make_float3(cellOffset) +
493 hash_int3_to_float3(cellPosition + cellOffset) *
494 params.randomness;
495 const float distanceToPoint = voronoi_distance_bound(pointPosition, localPosition, params);
496 if (distanceToPoint < minDistance) {
497 targetOffset = cellOffset;
498 minDistance = distanceToPoint;
499 targetPosition = pointPosition;
500 }
501 }
502 }
503 }
504
505 VoronoiOutput octave;
506 octave.distance = voronoi_distance(targetPosition, localPosition, params);
507 octave.color = hash_int3_to_float3(cellPosition + targetOffset);
508 octave.position = voronoi_position(targetPosition + cellPosition_f);
509 return octave;
510}
511
513 const float3 coord)
514{
515 const float3 cellPosition_f = floor(coord);
516 const float3 localPosition = coord - cellPosition_f;
517 const int3 cellPosition = make_int3(cellPosition_f);
518
519 float smoothDistance = 0.0f;
520 float3 smoothColor = make_float3(0.0f, 0.0f, 0.0f);
521 float3 smoothPosition = make_float3(0.0f, 0.0f, 0.0f);
522 float h = -1.0f;
523 for (int k = -2; k <= 2; k++) {
524 for (int j = -2; j <= 2; j++) {
525 for (int i = -2; i <= 2; i++) {
526 const int3 cellOffset = make_int3(i, j, k);
527 const float3 pointPosition = make_float3(cellOffset) +
528 hash_int3_to_float3(cellPosition + cellOffset) *
529 params.randomness;
530 const float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
531 h = h == -1.0f ?
532 1.0f :
533 smoothstep(0.0f,
534 1.0f,
535 0.5f + 0.5f * (smoothDistance - distanceToPoint) / params.smoothness);
536 float correctionFactor = params.smoothness * h * (1.0f - h);
537 smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
538 correctionFactor /= 1.0f + 3.0f * params.smoothness;
539 const float3 cellColor = hash_int3_to_float3(cellPosition + cellOffset);
540 smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
541 smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
542 }
543 }
544 }
545
546 VoronoiOutput octave;
547 octave.distance = smoothDistance;
548 octave.color = smoothColor;
549 octave.position = voronoi_position(cellPosition_f + smoothPosition);
550 return octave;
551}
552
554{
555 const float3 cellPosition_f = floor(coord);
556 const float3 localPosition = coord - cellPosition_f;
557 const int3 cellPosition = make_int3(cellPosition_f);
558
559 float distanceF1 = FLT_MAX;
560 float distanceF2 = FLT_MAX;
561 int3 offsetF1 = make_int3(0);
562 float3 positionF1 = make_float3(0.0f, 0.0f, 0.0f);
563 int3 offsetF2 = make_int3(0);
564 float3 positionF2 = make_float3(0.0f, 0.0f, 0.0f);
565 for (int k = -1; k <= 1; k++) {
566 for (int j = -1; j <= 1; j++) {
567 for (int i = -1; i <= 1; i++) {
568 const int3 cellOffset = make_int3(i, j, k);
569 const float3 pointPosition = make_float3(cellOffset) +
570 hash_int3_to_float3(cellPosition + cellOffset) *
571 params.randomness;
572 const 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_float3(cellPosition + offsetF2);
593 octave.position = voronoi_position(positionF2 + cellPosition_f);
594 return octave;
595}
596
598 const float3 coord)
599{
600 const float3 cellPosition_f = floor(coord);
601 const float3 localPosition = coord - cellPosition_f;
602 const int3 cellPosition = make_int3(cellPosition_f);
603
604 float3 vectorToClosest = make_float3(0.0f, 0.0f, 0.0f);
605 float minDistance = FLT_MAX;
606 for (int k = -1; k <= 1; k++) {
607 for (int j = -1; j <= 1; j++) {
608 for (int i = -1; i <= 1; i++) {
609 const int3 cellOffset = make_int3(i, j, k);
610 const float3 vectorToPoint = make_float3(cellOffset) +
611 hash_int3_to_float3(cellPosition + cellOffset) *
612 params.randomness -
613 localPosition;
614 const float distanceToPoint = dot(vectorToPoint, vectorToPoint);
615 if (distanceToPoint < minDistance) {
616 minDistance = distanceToPoint;
617 vectorToClosest = vectorToPoint;
618 }
619 }
620 }
621 }
622
623 minDistance = FLT_MAX;
624 for (int k = -1; k <= 1; k++) {
625 for (int j = -1; j <= 1; j++) {
626 for (int i = -1; i <= 1; i++) {
627 const int3 cellOffset = make_int3(i, j, k);
628 const float3 vectorToPoint = make_float3(cellOffset) +
629 hash_int3_to_float3(cellPosition + cellOffset) *
630 params.randomness -
631 localPosition;
632 const float3 perpendicularToEdge = vectorToPoint - vectorToClosest;
633 if (dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
634 const float distanceToEdge = dot((vectorToClosest + vectorToPoint) / 2.0f,
635 normalize(perpendicularToEdge));
636 minDistance = min(minDistance, distanceToEdge);
637 }
638 }
639 }
640 }
641
642 return minDistance;
643}
644
646 const float3 coord)
647{
648 const float3 cellPosition_f = floor(coord);
649 const float3 localPosition = coord - cellPosition_f;
650 const int3 cellPosition = make_int3(cellPosition_f);
651
652 float3 closestPoint = make_float3(0.0f, 0.0f, 0.0f);
653 int3 closestPointOffset = make_int3(0);
654 float minDistanceSq = FLT_MAX;
655 for (int k = -1; k <= 1; k++) {
656 for (int j = -1; j <= 1; j++) {
657 for (int i = -1; i <= 1; i++) {
658 const int3 cellOffset = make_int3(i, j, k);
659 const float3 pointPosition = make_float3(cellOffset) +
660 hash_int3_to_float3(cellPosition + cellOffset) *
661 params.randomness;
662 const float distanceToPointSq = len_squared(pointPosition - localPosition);
663 if (distanceToPointSq < minDistanceSq) {
664 minDistanceSq = distanceToPointSq;
665 closestPoint = pointPosition;
666 closestPointOffset = cellOffset;
667 }
668 }
669 }
670 }
671
672 minDistanceSq = FLT_MAX;
673 float3 closestPointToClosestPoint = make_float3(0.0f, 0.0f, 0.0f);
674 for (int k = -1; k <= 1; k++) {
675 for (int j = -1; j <= 1; j++) {
676 for (int i = -1; i <= 1; i++) {
677 if (i == 0 && j == 0 && k == 0) {
678 continue;
679 }
680 const int3 cellOffset = make_int3(i, j, k) + closestPointOffset;
681 const float3 pointPosition = make_float3(cellOffset) +
682 hash_int3_to_float3(cellPosition + cellOffset) *
683 params.randomness;
684 const float distanceToPointSq = len_squared(closestPoint - pointPosition);
685 if (distanceToPointSq < minDistanceSq) {
686 minDistanceSq = distanceToPointSq;
687 closestPointToClosestPoint = pointPosition;
688 }
689 }
690 }
691 }
692
693 return distance(closestPointToClosestPoint, closestPoint) / 2.0f;
694}
695
696/* **** 4D Voronoi **** */
697
699{
700 return coord;
701}
702
704{
705 const float4 cellPosition_f = floor(coord);
706 const float4 localPosition = coord - cellPosition_f;
707 const int4 cellPosition = make_int4(cellPosition_f);
708
709 float minDistance = FLT_MAX;
710 int4 targetOffset = zero_int4();
711 float4 targetPosition = zero_float4();
712 for (int u = -1; u <= 1; u++) {
713 for (int k = -1; k <= 1; k++) {
714 for (int j = -1; j <= 1; j++) {
715 for (int i = -1; i <= 1; i++) {
716 const int4 cellOffset = make_int4(i, j, k, u);
717 const float4 pointPosition = make_float4(cellOffset) +
718 hash_int4_to_float4(cellPosition + cellOffset) *
719 params.randomness;
720 const float distanceToPoint = voronoi_distance_bound(
721 pointPosition, localPosition, params);
722 if (distanceToPoint < minDistance) {
723 targetOffset = cellOffset;
724 minDistance = distanceToPoint;
725 targetPosition = pointPosition;
726 }
727 }
728 }
729 }
730 }
731
732 VoronoiOutput octave;
733 octave.distance = voronoi_distance(targetPosition, localPosition, params);
734 octave.color = hash_int4_to_float3(cellPosition + targetOffset);
735 octave.position = voronoi_position(targetPosition + cellPosition_f);
736 return octave;
737}
738
740 const float4 coord)
741{
742 const float4 cellPosition_f = floor(coord);
743 const float4 localPosition = coord - cellPosition_f;
744 const int4 cellPosition = make_int4(cellPosition_f);
745
746 float smoothDistance = 0.0f;
747 float3 smoothColor = make_float3(0.0f, 0.0f, 0.0f);
748 float4 smoothPosition = zero_float4();
749 float h = -1.0f;
750 for (int u = -2; u <= 2; u++) {
751 for (int k = -2; k <= 2; k++) {
752 for (int j = -2; j <= 2; j++) {
753 for (int i = -2; i <= 2; i++) {
754 const int4 cellOffset = make_int4(i, j, k, u);
755 const float4 pointPosition = make_float4(cellOffset) +
756 hash_int4_to_float4(cellPosition + cellOffset) *
757 params.randomness;
758 const float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
759 h = h == -1.0f ?
760 1.0f :
761 smoothstep(0.0f,
762 1.0f,
763 0.5f + 0.5f * (smoothDistance - distanceToPoint) / params.smoothness);
764 float correctionFactor = params.smoothness * h * (1.0f - h);
765 smoothDistance = mix(smoothDistance, distanceToPoint, h) - correctionFactor;
766 correctionFactor /= 1.0f + 3.0f * params.smoothness;
767 const float3 cellColor = hash_int4_to_float3(cellPosition + cellOffset);
768 smoothColor = mix(smoothColor, cellColor, h) - correctionFactor;
769 smoothPosition = mix(smoothPosition, pointPosition, h) - correctionFactor;
770 }
771 }
772 }
773 }
774
775 VoronoiOutput octave;
776 octave.distance = smoothDistance;
777 octave.color = smoothColor;
778 octave.position = voronoi_position(cellPosition_f + smoothPosition);
779 return octave;
780}
781
783{
784 const float4 cellPosition_f = floor(coord);
785 const float4 localPosition = coord - cellPosition_f;
786 const int4 cellPosition = make_int4(cellPosition_f);
787
788 float distanceF1 = FLT_MAX;
789 float distanceF2 = FLT_MAX;
790 int4 offsetF1 = zero_int4();
791 float4 positionF1 = zero_float4();
792 int4 offsetF2 = zero_int4();
793 float4 positionF2 = zero_float4();
794 for (int u = -1; u <= 1; u++) {
795 for (int k = -1; k <= 1; k++) {
796 for (int j = -1; j <= 1; j++) {
797 for (int i = -1; i <= 1; i++) {
798 const int4 cellOffset = make_int4(i, j, k, u);
799 const float4 pointPosition = make_float4(cellOffset) +
800 hash_int4_to_float4(cellPosition + cellOffset) *
801 params.randomness;
802 const float distanceToPoint = voronoi_distance(pointPosition, localPosition, params);
803 if (distanceToPoint < distanceF1) {
804 distanceF2 = distanceF1;
805 distanceF1 = distanceToPoint;
806 offsetF2 = offsetF1;
807 offsetF1 = cellOffset;
808 positionF2 = positionF1;
809 positionF1 = pointPosition;
810 }
811 else if (distanceToPoint < distanceF2) {
812 distanceF2 = distanceToPoint;
813 offsetF2 = cellOffset;
814 positionF2 = pointPosition;
815 }
816 }
817 }
818 }
819 }
820
821 VoronoiOutput octave;
822 octave.distance = distanceF2;
823 octave.color = hash_int4_to_float3(cellPosition + offsetF2);
824 octave.position = voronoi_position(positionF2 + cellPosition_f);
825 return octave;
826}
827
829 const float4 coord)
830{
831 const float4 cellPosition_f = floor(coord);
832 const float4 localPosition = coord - cellPosition_f;
833 const int4 cellPosition = make_int4(cellPosition_f);
834
835 float4 vectorToClosest = zero_float4();
836 float minDistance = FLT_MAX;
837 for (int u = -1; u <= 1; u++) {
838 for (int k = -1; k <= 1; k++) {
839 for (int j = -1; j <= 1; j++) {
840 for (int i = -1; i <= 1; i++) {
841 const int4 cellOffset = make_int4(i, j, k, u);
842 const float4 vectorToPoint = make_float4(cellOffset) +
843 hash_int4_to_float4(cellPosition + cellOffset) *
844 params.randomness -
845 localPosition;
846 const float distanceToPoint = dot(vectorToPoint, vectorToPoint);
847 if (distanceToPoint < minDistance) {
848 minDistance = distanceToPoint;
849 vectorToClosest = vectorToPoint;
850 }
851 }
852 }
853 }
854 }
855
856 minDistance = FLT_MAX;
857 for (int u = -1; u <= 1; u++) {
858 for (int k = -1; k <= 1; k++) {
859 for (int j = -1; j <= 1; j++) {
860 for (int i = -1; i <= 1; i++) {
861 const int4 cellOffset = make_int4(i, j, k, u);
862 const float4 vectorToPoint = make_float4(cellOffset) +
863 hash_int4_to_float4(cellPosition + cellOffset) *
864 params.randomness -
865 localPosition;
866 const float4 perpendicularToEdge = vectorToPoint - vectorToClosest;
867 if (dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
868 const float distanceToEdge = dot((vectorToClosest + vectorToPoint) / 2.0f,
869 normalize(perpendicularToEdge));
870 minDistance = min(minDistance, distanceToEdge);
871 }
872 }
873 }
874 }
875 }
876
877 return minDistance;
878}
879
881 const float4 coord)
882{
883 const float4 cellPosition_f = floor(coord);
884 const float4 localPosition = coord - cellPosition_f;
885 const int4 cellPosition = make_int4(cellPosition_f);
886
887 float4 closestPoint = zero_float4();
888 int4 closestPointOffset = zero_int4();
889 float minDistanceSq = FLT_MAX;
890 for (int u = -1; u <= 1; u++) {
891 for (int k = -1; k <= 1; k++) {
892 for (int j = -1; j <= 1; j++) {
893 for (int i = -1; i <= 1; i++) {
894 const int4 cellOffset = make_int4(i, j, k, u);
895 const float4 pointPosition = make_float4(cellOffset) +
896 hash_int4_to_float4(cellPosition + cellOffset) *
897 params.randomness;
898 const float distanceToPointSq = len_squared(pointPosition - localPosition);
899 if (distanceToPointSq < minDistanceSq) {
900 minDistanceSq = distanceToPointSq;
901 closestPoint = pointPosition;
902 closestPointOffset = cellOffset;
903 }
904 }
905 }
906 }
907 }
908
909 minDistanceSq = FLT_MAX;
910 float4 closestPointToClosestPoint = zero_float4();
911 for (int u = -1; u <= 1; u++) {
912 for (int k = -1; k <= 1; k++) {
913 for (int j = -1; j <= 1; j++) {
914 for (int i = -1; i <= 1; i++) {
915 if (i == 0 && j == 0 && k == 0 && u == 0) {
916 continue;
917 }
918 const int4 cellOffset = make_int4(i, j, k, u) + closestPointOffset;
919 const float4 pointPosition = make_float4(cellOffset) +
920 hash_int4_to_float4(cellPosition + cellOffset) *
921 params.randomness;
922 const float distanceToPointSq = len_squared(closestPoint - pointPosition);
923 if (distanceToPointSq < minDistanceSq) {
924 minDistanceSq = distanceToPointSq;
925 closestPointToClosestPoint = pointPosition;
926 }
927 }
928 }
929 }
930 }
931
932 return distance(closestPointToClosestPoint, closestPoint) / 2.0f;
933}
934
935/* **** Fractal Voronoi **** */
936
937/* The fractalization logic is the same as for fBM Noise, except that some additions are replaced
938 * by lerps. */
939template<typename T>
941 const T coord)
942{
943 float amplitude = 1.0f;
944 float max_amplitude = 0.0f;
945 float scale = 1.0f;
946
948 const bool zero_input = params.detail == 0.0f || params.roughness == 0.0f;
949
950 for (int i = 0; i <= ceilf(params.detail); ++i) {
951 VoronoiOutput octave = (params.feature == NODE_VORONOI_F2) ?
952 voronoi_f2(params, coord * scale) :
953 (params.feature == NODE_VORONOI_SMOOTH_F1 &&
954 params.smoothness != 0.0f) ?
955 voronoi_smooth_f1(params, coord * scale) :
956 voronoi_f1(params, coord * scale);
957
958 if (zero_input) {
959 max_amplitude = 1.0f;
960 output = octave;
961 break;
962 }
963 if (i <= params.detail) {
964 max_amplitude += amplitude;
965 output.distance += octave.distance * amplitude;
966 output.color += octave.color * amplitude;
967 output.position = mix(output.position, octave.position / scale, amplitude);
968 scale *= params.lacunarity;
969 amplitude *= params.roughness;
970 }
971 else {
972 const float remainder = params.detail - floorf(params.detail);
973 if (remainder != 0.0f) {
974 max_amplitude = mix(max_amplitude, max_amplitude + amplitude, remainder);
975 output.distance = mix(
976 output.distance, output.distance + octave.distance * amplitude, remainder);
977 output.color = mix(output.color, output.color + octave.color * amplitude, remainder);
978 output.position = mix(
979 output.position, mix(output.position, octave.position / scale, amplitude), remainder);
980 }
981 }
982 }
983
984 if (params.normalize) {
985 output.distance /= max_amplitude * params.max_distance;
986 output.color /= max_amplitude;
987 }
988
989 output.position = safe_divide(output.position, params.scale);
990
991 return output;
992}
993
994/* The fractalization logic is the same as for fBM Noise, except that some additions are replaced
995 * by lerps. */
996template<typename T>
998 const T coord)
999{
1000 float amplitude = 1.0f;
1001 float max_amplitude = params.max_distance;
1002 float scale = 1.0f;
1003 float distance = 8.0f;
1004
1005 const bool zero_input = params.detail == 0.0f || params.roughness == 0.0f;
1006
1007 for (int i = 0; i <= ceilf(params.detail); ++i) {
1008 const float octave_distance = voronoi_distance_to_edge(params, coord * scale);
1009
1010 if (zero_input) {
1011 distance = octave_distance;
1012 break;
1013 }
1014 if (i <= params.detail) {
1015 max_amplitude = mix(max_amplitude, params.max_distance / scale, amplitude);
1016 distance = mix(distance, min(distance, octave_distance / scale), amplitude);
1017 scale *= params.lacunarity;
1018 amplitude *= params.roughness;
1019 }
1020 else {
1021 const float remainder = params.detail - floorf(params.detail);
1022 if (remainder != 0.0f) {
1023 const float lerp_amplitude = mix(max_amplitude, params.max_distance / scale, amplitude);
1024 max_amplitude = mix(max_amplitude, lerp_amplitude, remainder);
1025 const float lerp_distance = mix(
1026 distance, min(distance, octave_distance / scale), amplitude);
1027 distance = mix(distance, min(distance, lerp_distance), remainder);
1028 }
1029 }
1030 }
1031
1032 if (params.normalize) {
1033 distance /= max_amplitude;
1034 }
1035
1036 return distance;
1037}
1038
1041 const float distance,
1042 const float3 color,
1043 const float3 position,
1044 const float w,
1045 const float radius)
1046{
1047 if (stack_valid(node.distance_offset)) {
1048 stack_store_float(stack, node.distance_offset, distance);
1049 }
1050 if (stack_valid(node.color_offset)) {
1051 stack_store_float3(stack, node.color_offset, color);
1052 }
1053 if (stack_valid(node.position_offset)) {
1054 stack_store_float3(stack, node.position_offset, position);
1055 }
1056 if (stack_valid(node.w_out_offset)) {
1057 stack_store_float(stack, node.w_out_offset, w);
1058 }
1059 if (stack_valid(node.radius_offset)) {
1060 stack_store_float(stack, node.radius_offset, radius);
1061 }
1062}
1063
1064template<uint64_t node_feature_mask>
1067{
1068 /* Read from stack. */
1069 float3 coord = stack_load_float3(stack, node.coord);
1070 float w = stack_load(stack, node.w);
1071
1072 VoronoiParams params;
1073 params.feature = node.feature;
1074 params.metric = node.metric;
1075 params.scale = stack_load(stack, node.scale);
1076 params.detail = stack_load(stack, node.detail);
1077 params.roughness = stack_load(stack, node.roughness);
1078 params.lacunarity = stack_load(stack, node.lacunarity);
1079 params.smoothness = stack_load(stack, node.smoothness);
1080 params.exponent = stack_load(stack, node.exponent);
1081 params.randomness = stack_load(stack, node.randomness);
1082 params.max_distance = 0.0f;
1083 params.normalize = node.normalize;
1084
1085 params.detail = clamp(params.detail, 0.0f, 15.0f);
1086 params.roughness = clamp(params.roughness, 0.0f, 1.0f);
1087 params.randomness = clamp(params.randomness, 0.0f, 1.0f);
1088 params.smoothness = clamp(params.smoothness / 2.0f, 0.0f, 0.5f);
1089
1090 coord *= params.scale;
1091 w *= params.scale;
1092
1093 /* Compute output, specialized for each dimension. */
1094 switch (params.feature) {
1096 float distance = 0.0f;
1097 params.max_distance = 0.5f + 0.5f * params.randomness;
1098 switch (node.dimensions) {
1099 case 1:
1101 break;
1102 case 2:
1104 break;
1105 case 3:
1107 break;
1108 case 4:
1110 break;
1111 default:
1112 kernel_assert(0);
1113 break;
1114 }
1115
1116 svm_voronoi_output(stack, node, distance, zero_float3(), zero_float3(), 0.0f, 0.0f);
1117 break;
1118 }
1120 float radius = 0.0f;
1121 switch (node.dimensions) {
1122 case 1:
1123 radius = voronoi_n_sphere_radius(params, w);
1124 break;
1125 case 2:
1126 radius = voronoi_n_sphere_radius(params, make_float2(coord));
1127 break;
1128 case 3:
1129 radius = voronoi_n_sphere_radius(params, coord);
1130 break;
1131 case 4:
1132 radius = voronoi_n_sphere_radius(params, make_float4(coord, w));
1133 break;
1134 default:
1135 kernel_assert(0);
1136 break;
1137 }
1138
1139 svm_voronoi_output(stack, node, 0.0f, zero_float3(), zero_float3(), 0.0f, radius);
1140 break;
1141 }
1142 default: {
1144 switch (node.dimensions) {
1145 case 1:
1146 params.max_distance = (0.5f + 0.5f * params.randomness) *
1147 ((params.feature == NODE_VORONOI_F2) ? 2.0f : 1.0f);
1148 output = fractal_voronoi_x_fx(params, w);
1149 break;
1150 case 2:
1151 IF_KERNEL_NODES_FEATURE (VORONOI_EXTRA) {
1153 make_float2(0.5f + 0.5f * params.randomness,
1154 0.5f + 0.5f * params.randomness),
1155 params) *
1156 ((params.feature == NODE_VORONOI_F2) ? 2.0f : 1.0f);
1157 output = fractal_voronoi_x_fx(params, make_float2(coord));
1158 }
1159 break;
1160 case 3:
1161 IF_KERNEL_NODES_FEATURE (VORONOI_EXTRA) {
1163 make_float3(0.5f + 0.5f * params.randomness,
1164 0.5f + 0.5f * params.randomness,
1165 0.5f + 0.5f * params.randomness),
1166 params) *
1167 ((params.feature == NODE_VORONOI_F2) ? 2.0f : 1.0f);
1168 output = fractal_voronoi_x_fx(params, coord);
1169 }
1170 break;
1171 case 4:
1172 IF_KERNEL_NODES_FEATURE (VORONOI_EXTRA) {
1174 make_float4(0.5f + 0.5f * params.randomness,
1175 0.5f + 0.5f * params.randomness,
1176 0.5f + 0.5f * params.randomness,
1177 0.5f + 0.5f * params.randomness),
1178 params) *
1179 ((params.feature == NODE_VORONOI_F2) ? 2.0f : 1.0f);
1180 output = fractal_voronoi_x_fx(params, make_float4(coord, w));
1181 }
1182 break;
1183 default:
1184 kernel_assert(0);
1185 break;
1186 }
1187
1188 svm_voronoi_output(stack,
1189 node,
1190 output.distance,
1191 output.color,
1192 make_float3(output.position),
1193 output.position.w,
1194 0.0f);
1195 break;
1196 }
1197 }
1198}
1199
#define output
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
ccl_device_inline void stack_store_float(ccl_private float *stack, const uint a, const float f)
ccl_device_inline float3 stack_load_float3(const ccl_private float *stack, const uint a)
ccl_device_inline void stack_store_float3(ccl_private float *stack, const uint a, const float3 f)
ccl_device_inline bool stack_valid(const uint a)
ccl_device_inline T stack_load(const ccl_private float *stack, const uint a)
#define kernel_assert(cond)
#define ccl_restrict
#define IF_KERNEL_NODES_FEATURE(feature)
#define ccl_private
#define ccl_global
#define ccl_device_noinline
#define powf(x, y)
#define CCL_NAMESPACE_END
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
ccl_device_forceinline int3 make_int3(const int x, const int y, const int z)
ccl_device_forceinline int2 make_int2(const int x, const int y)
ccl_device_forceinline int4 make_int4(const int x, const int y, const int z, const int w)
float hash_float_to_float(float k)
#define FLT_MAX
#define position
T smoothstep(T, T, T) RET
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
#define floor
float distance(float, float) RET
constexpr T clamp(T, U, U) RET
VoronoiOutput fractal_voronoi_x_fx(VoronoiParams params, float coord)
float fractal_voronoi_distance_to_edge(VoronoiParams params, T coord)
float voronoi_distance(float a, float b)
float voronoi_n_sphere_radius(VoronoiParams params, float coord)
VoronoiOutput voronoi_f1(VoronoiParams params, float coord)
VoronoiOutput voronoi_smooth_f1(VoronoiParams params, float coord)
VoronoiOutput voronoi_f2(VoronoiParams params, float coord)
float4 voronoi_position(float coord)
float voronoi_distance_to_edge(VoronoiParams params, float coord)
float3x3 scale(float3x3 mat, float2 scale)
float safe_divide(float a, float b)
float reduce_add(float2 a)
float reduce_max(float2 a)
ccl_device_inline float3 hash_float_to_float3(const float k)
Definition hash.h:300
ccl_device_inline float3 hash_int3_to_float3(const int3 k)
Definition hash.h:248
ccl_device_inline float3 hash_int4_to_float3(const int4 k)
Definition hash.h:267
ccl_device_inline float2 hash_int2_to_float2(const int2 k)
Definition hash.h:241
ccl_device_inline float3 hash_int2_to_float3(const int2 k)
Definition hash.h:262
ccl_device_inline float4 hash_int4_to_float4(const int4 k)
Definition hash.h:255
NodeVoronoiFeature
@ NODE_VORONOI_SMOOTH_F1
@ NODE_VORONOI_N_SPHERE_RADIUS
@ NODE_VORONOI_F2
@ NODE_VORONOI_DISTANCE_TO_EDGE
NodeVoronoiDistanceMetric
@ NODE_VORONOI_EUCLIDEAN
@ NODE_VORONOI_MANHATTAN
@ NODE_VORONOI_CHEBYCHEV
@ NODE_VORONOI_MINKOWSKI
ccl_device_inline dual1 len_squared(const ccl_private dual< T > &a)
Definition math_dual.h:273
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
Definition math_dual.h:241
ccl_device_inline float2 power(const float2 v, const float e)
CCL_NAMESPACE_BEGIN ccl_device_inline float2 zero_float2()
Definition math_float2.h:13
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
Definition math_float3.h:17
CCL_NAMESPACE_BEGIN ccl_device_inline float4 zero_float4()
Definition math_float4.h:13
#define T
#define mix
#define floorf
#define fabsf
#define ccl_device
#define make_float2
#define make_float4
#define ceilf
#define min(a, b)
Definition sort.cc:38
float3 color
Definition voronoi.h:46
float4 position
Definition voronoi.h:47
float distance
Definition voronoi.h:45
float x
float y
ccl_device_inline int4 zero_int4()
Definition types_int4.h:79
ccl_device_noinline void svm_node_tex_voronoi(ccl_private float *ccl_restrict stack, const ccl_global SVMNodeTexVoronoi &ccl_restrict node)
Definition voronoi.h:1065
ccl_device void svm_voronoi_output(ccl_private float *ccl_restrict stack, const ccl_global SVMNodeTexVoronoi &ccl_restrict node, const float distance, const float3 color, const float3 position, const float w, const float radius)
Definition voronoi.h:1039
ccl_device float voronoi_distance_bound(const T a, const T b, const ccl_private VoronoiParams &params)
Definition voronoi.h:78