44 float localPosition =
w - cellPosition;
46 float minDistance = 8.0f;
47 float targetOffset = 0.0f;
48 float targetPosition = 0.0f;
49 for (
int i = -1; i <= 1; i++) {
51 float pointPosition = cellOffset +
hash_float_to_float(cellPosition + cellOffset) * randomness;
52 float distanceToPoint =
voronoi_distance_1d(pointPosition, localPosition, metric, exponent);
53 if (distanceToPoint < minDistance) {
54 targetOffset = cellOffset;
55 minDistance = distanceToPoint;
56 targetPosition = pointPosition;
59 *outDistance = minDistance;
61 *outW = targetPosition + cellPosition;
74 float localPosition =
w - cellPosition;
76 float smoothDistance = 8.0f;
77 float smoothPosition = 0.0f;
79 for (
int i = -2; i <= 2; i++) {
81 float pointPosition = cellOffset +
hash_float_to_float(cellPosition + cellOffset) * randomness;
82 float distanceToPoint =
voronoi_distance_1d(pointPosition, localPosition, metric, exponent);
84 0.0f, 1.0f, 0.5f + 0.5f * (smoothDistance - distanceToPoint) / smoothness);
85 float correctionFactor = smoothness * h * (1.0f - h);
86 smoothDistance =
mix(smoothDistance, distanceToPoint, h) - correctionFactor;
87 correctionFactor /= 1.0f + 3.0f * smoothness;
89 smoothColor =
mix(smoothColor, cellColor, h) - correctionFactor;
90 smoothPosition =
mix(smoothPosition, pointPosition, h) - correctionFactor;
92 *outDistance = smoothDistance;
93 *outColor = smoothColor;
94 *outW = cellPosition + smoothPosition;
105 float cellPosition =
floorf(
w);
106 float localPosition =
w - cellPosition;
108 float distanceF1 = 8.0f;
109 float distanceF2 = 8.0f;
110 float offsetF1 = 0.0f;
111 float positionF1 = 0.0f;
112 float offsetF2 = 0.0f;
113 float positionF2 = 0.0f;
114 for (
int i = -1; i <= 1; i++) {
115 float cellOffset = i;
116 float pointPosition = cellOffset +
hash_float_to_float(cellPosition + cellOffset) * randomness;
117 float distanceToPoint =
voronoi_distance_1d(pointPosition, localPosition, metric, exponent);
118 if (distanceToPoint < distanceF1) {
119 distanceF2 = distanceF1;
120 distanceF1 = distanceToPoint;
122 offsetF1 = cellOffset;
123 positionF2 = positionF1;
124 positionF1 = pointPosition;
126 else if (distanceToPoint < distanceF2) {
127 distanceF2 = distanceToPoint;
128 offsetF2 = cellOffset;
129 positionF2 = pointPosition;
132 *outDistance = distanceF2;
134 *outW = positionF2 + cellPosition;
141 float cellPosition =
floorf(
w);
142 float localPosition =
w - cellPosition;
147 float distanceToMidLeft =
fabsf((midPointPosition + leftPointPosition) / 2.0f - localPosition);
148 float distanceToMidRight =
fabsf((midPointPosition + rightPointPosition) / 2.0f - localPosition);
150 *outDistance =
min(distanceToMidLeft, distanceToMidRight);
155 float cellPosition =
floorf(
w);
156 float localPosition =
w - cellPosition;
158 float closestPoint = 0.0f;
159 float closestPointOffset = 0.0f;
160 float minDistance = 8.0f;
161 for (
int i = -1; i <= 1; i++) {
162 float cellOffset = i;
163 float pointPosition = cellOffset +
hash_float_to_float(cellPosition + cellOffset) * randomness;
164 float distanceToPoint =
fabsf(pointPosition - localPosition);
165 if (distanceToPoint < minDistance) {
166 minDistance = distanceToPoint;
167 closestPoint = pointPosition;
168 closestPointOffset = cellOffset;
173 float closestPointToClosestPoint = 0.0f;
174 for (
int i = -1; i <= 1; i++) {
178 float cellOffset = i + closestPointOffset;
179 float pointPosition = cellOffset +
hash_float_to_float(cellPosition + cellOffset) * randomness;
180 float distanceToPoint =
fabsf(closestPoint - pointPosition);
181 if (distanceToPoint < minDistance) {
182 minDistance = distanceToPoint;
183 closestPointToClosestPoint = pointPosition;
186 *outRadius =
fabsf(closestPointToClosestPoint - closestPoint) / 2.0f;
223 float2 localPosition = coord - cellPosition;
225 float minDistance = 8.0f;
228 for (
int j = -1; j <= 1; j++) {
229 for (
int i = -1; i <= 1; i++) {
231 float2 pointPosition = cellOffset +
233 float distanceToPoint =
voronoi_distance_2d(pointPosition, localPosition, metric, exponent);
234 if (distanceToPoint < minDistance) {
235 targetOffset = cellOffset;
236 minDistance = distanceToPoint;
237 targetPosition = pointPosition;
241 *outDistance = minDistance;
243 *outPosition = targetPosition + cellPosition;
256 float2 localPosition = coord - cellPosition;
258 float smoothDistance = 8.0f;
261 for (
int j = -2; j <= 2; j++) {
262 for (
int i = -2; i <= 2; i++) {
264 float2 pointPosition = cellOffset +
266 float distanceToPoint =
voronoi_distance_2d(pointPosition, localPosition, metric, exponent);
268 0.0f, 1.0f, 0.5f + 0.5f * (smoothDistance - distanceToPoint) / smoothness);
269 float correctionFactor = smoothness * h * (1.0f - h);
270 smoothDistance =
mix(smoothDistance, distanceToPoint, h) - correctionFactor;
271 correctionFactor /= 1.0f + 3.0f * smoothness;
273 smoothColor =
mix(smoothColor, cellColor, h) - correctionFactor;
274 smoothPosition =
mix(smoothPosition, pointPosition, h) - correctionFactor;
277 *outDistance = smoothDistance;
278 *outColor = smoothColor;
279 *outPosition = cellPosition + smoothPosition;
291 float2 localPosition = coord - cellPosition;
293 float distanceF1 = 8.0f;
294 float distanceF2 = 8.0f;
299 for (
int j = -1; j <= 1; j++) {
300 for (
int i = -1; i <= 1; i++) {
302 float2 pointPosition = cellOffset +
304 float distanceToPoint =
voronoi_distance_2d(pointPosition, localPosition, metric, exponent);
305 if (distanceToPoint < distanceF1) {
306 distanceF2 = distanceF1;
307 distanceF1 = distanceToPoint;
309 offsetF1 = cellOffset;
310 positionF2 = positionF1;
311 positionF1 = pointPosition;
313 else if (distanceToPoint < distanceF2) {
314 distanceF2 = distanceToPoint;
315 offsetF2 = cellOffset;
316 positionF2 = pointPosition;
320 *outDistance = distanceF2;
322 *outPosition = positionF2 + cellPosition;
330 float2 localPosition = coord - cellPosition;
333 float minDistance = 8.0f;
334 for (
int j = -1; j <= 1; j++) {
335 for (
int i = -1; i <= 1; i++) {
337 float2 vectorToPoint = cellOffset +
340 float distanceToPoint =
dot(vectorToPoint, vectorToPoint);
341 if (distanceToPoint < minDistance) {
342 minDistance = distanceToPoint;
343 vectorToClosest = vectorToPoint;
349 for (
int j = -1; j <= 1; j++) {
350 for (
int i = -1; i <= 1; i++) {
352 float2 vectorToPoint = cellOffset +
355 float2 perpendicularToEdge = vectorToPoint - vectorToClosest;
356 if (
dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
357 float distanceToEdge =
dot((vectorToClosest + vectorToPoint) / 2.0f,
359 minDistance =
min(minDistance, distanceToEdge);
363 *outDistance = minDistance;
371 float2 localPosition = coord - cellPosition;
375 float minDistance = 8.0f;
376 for (
int j = -1; j <= 1; j++) {
377 for (
int i = -1; i <= 1; i++) {
379 float2 pointPosition = cellOffset +
381 float distanceToPoint =
distance(pointPosition, localPosition);
382 if (distanceToPoint < minDistance) {
383 minDistance = distanceToPoint;
384 closestPoint = pointPosition;
385 closestPointOffset = cellOffset;
392 for (
int j = -1; j <= 1; j++) {
393 for (
int i = -1; i <= 1; i++) {
394 if (i == 0 && j == 0) {
398 float2 pointPosition = cellOffset +
400 float distanceToPoint =
distance(closestPoint, pointPosition);
401 if (distanceToPoint < minDistance) {
402 minDistance = distanceToPoint;
403 closestPointToClosestPoint = pointPosition;
407 *outRadius =
distance(closestPointToClosestPoint, closestPoint) / 2.0f;
445 float3 localPosition = coord - cellPosition;
447 float minDistance = 8.0f;
450 for (
int k = -1; k <= 1; k++) {
451 for (
int j = -1; j <= 1; j++) {
452 for (
int i = -1; i <= 1; i++) {
454 float3 pointPosition = cellOffset +
457 pointPosition, localPosition, metric, exponent);
458 if (distanceToPoint < minDistance) {
459 targetOffset = cellOffset;
460 minDistance = distanceToPoint;
461 targetPosition = pointPosition;
466 *outDistance = minDistance;
468 *outPosition = targetPosition + cellPosition;
481 float3 localPosition = coord - cellPosition;
483 float smoothDistance = 8.0f;
486 for (
int k = -2; k <= 2; k++) {
487 for (
int j = -2; j <= 2; j++) {
488 for (
int i = -2; i <= 2; i++) {
490 float3 pointPosition = cellOffset +
493 pointPosition, localPosition, metric, exponent);
495 0.0f, 1.0f, 0.5f + 0.5f * (smoothDistance - distanceToPoint) / smoothness);
496 float correctionFactor = smoothness * h * (1.0f - h);
497 smoothDistance =
mix(smoothDistance, distanceToPoint, h) - correctionFactor;
498 correctionFactor /= 1.0f + 3.0f * smoothness;
500 smoothColor =
mix(smoothColor, cellColor, h) - correctionFactor;
501 smoothPosition =
mix(smoothPosition, pointPosition, h) - correctionFactor;
505 *outDistance = smoothDistance;
506 *outColor = smoothColor;
507 *outPosition = cellPosition + smoothPosition;
519 float3 localPosition = coord - cellPosition;
521 float distanceF1 = 8.0f;
522 float distanceF2 = 8.0f;
527 for (
int k = -1; k <= 1; k++) {
528 for (
int j = -1; j <= 1; j++) {
529 for (
int i = -1; i <= 1; i++) {
531 float3 pointPosition = cellOffset +
534 pointPosition, localPosition, metric, exponent);
535 if (distanceToPoint < distanceF1) {
536 distanceF2 = distanceF1;
537 distanceF1 = distanceToPoint;
539 offsetF1 = cellOffset;
540 positionF2 = positionF1;
541 positionF1 = pointPosition;
543 else if (distanceToPoint < distanceF2) {
544 distanceF2 = distanceToPoint;
545 offsetF2 = cellOffset;
546 positionF2 = pointPosition;
551 *outDistance = distanceF2;
553 *outPosition = positionF2 + cellPosition;
561 float3 localPosition = coord - cellPosition;
564 float minDistance = 8.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++) {
569 float3 vectorToPoint = cellOffset +
572 float distanceToPoint =
dot(vectorToPoint, vectorToPoint);
573 if (distanceToPoint < minDistance) {
574 minDistance = distanceToPoint;
575 vectorToClosest = vectorToPoint;
582 for (
int k = -1; k <= 1; k++) {
583 for (
int j = -1; j <= 1; j++) {
584 for (
int i = -1; i <= 1; i++) {
586 float3 vectorToPoint = cellOffset +
589 float3 perpendicularToEdge = vectorToPoint - vectorToClosest;
590 if (
dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
591 float distanceToEdge =
dot((vectorToClosest + vectorToPoint) / 2.0f,
593 minDistance =
min(minDistance, distanceToEdge);
598 *outDistance = minDistance;
606 float3 localPosition = coord - cellPosition;
610 float minDistance = 8.0f;
611 for (
int k = -1; k <= 1; k++) {
612 for (
int j = -1; j <= 1; j++) {
613 for (
int i = -1; i <= 1; i++) {
615 float3 pointPosition = cellOffset +
617 float distanceToPoint =
distance(pointPosition, localPosition);
618 if (distanceToPoint < minDistance) {
619 minDistance = distanceToPoint;
620 closestPoint = pointPosition;
621 closestPointOffset = cellOffset;
629 for (
int k = -1; k <= 1; k++) {
630 for (
int j = -1; j <= 1; j++) {
631 for (
int i = -1; i <= 1; i++) {
632 if (i == 0 && j == 0 && k == 0) {
636 float3 pointPosition = cellOffset +
638 float distanceToPoint =
distance(closestPoint, pointPosition);
639 if (distanceToPoint < minDistance) {
640 minDistance = distanceToPoint;
641 closestPointToClosestPoint = pointPosition;
646 *outRadius =
distance(closestPointToClosestPoint, closestPoint) / 2.0f;
684 float4 localPosition = coord - cellPosition;
686 float minDistance = 8.0f;
689 for (
int u = -1; u <= 1; u++) {
690 for (
int k = -1; k <= 1; k++) {
693 for (
int i = -1; i <= 1; i++) {
695 float4 pointPosition = cellOffset +
698 pointPosition, localPosition, metric, exponent);
699 if (distanceToPoint < minDistance) {
700 targetOffset = cellOffset;
701 minDistance = distanceToPoint;
702 targetPosition = pointPosition;
708 *outDistance = minDistance;
710 *outPosition = targetPosition + cellPosition;
723 float4 localPosition = coord - cellPosition;
725 float smoothDistance = 8.0f;
728 for (
int u = -2; u <= 2; u++) {
729 for (
int k = -2; k <= 2; k++) {
732 for (
int i = -2; i <= 2; i++) {
734 float4 pointPosition = cellOffset +
737 pointPosition, localPosition, metric, exponent);
739 0.0f, 1.0f, 0.5f + 0.5f * (smoothDistance - distanceToPoint) / smoothness);
740 float correctionFactor = smoothness * h * (1.0f - h);
741 smoothDistance =
mix(smoothDistance, distanceToPoint, h) - correctionFactor;
742 correctionFactor /= 1.0f + 3.0f * smoothness;
744 smoothColor =
mix(smoothColor, cellColor, h) - correctionFactor;
745 smoothPosition =
mix(smoothPosition, pointPosition, h) - correctionFactor;
750 *outDistance = smoothDistance;
751 *outColor = smoothColor;
752 *outPosition = cellPosition + smoothPosition;
764 float4 localPosition = coord - cellPosition;
766 float distanceF1 = 8.0f;
767 float distanceF2 = 8.0f;
772 for (
int u = -1; u <= 1; u++) {
773 for (
int k = -1; k <= 1; k++) {
776 for (
int i = -1; i <= 1; i++) {
778 float4 pointPosition = cellOffset +
781 pointPosition, localPosition, metric, exponent);
782 if (distanceToPoint < distanceF1) {
783 distanceF2 = distanceF1;
784 distanceF1 = distanceToPoint;
786 offsetF1 = cellOffset;
787 positionF2 = positionF1;
788 positionF1 = pointPosition;
790 else if (distanceToPoint < distanceF2) {
791 distanceF2 = distanceToPoint;
792 offsetF2 = cellOffset;
793 positionF2 = pointPosition;
799 *outDistance = distanceF2;
801 *outPosition = positionF2 + cellPosition;
809 float4 localPosition = coord - cellPosition;
812 float minDistance = 8.0f;
813 for (
int u = -1; u <= 1; u++) {
814 for (
int k = -1; k <= 1; k++) {
817 for (
int i = -1; i <= 1; i++) {
819 float4 vectorToPoint = cellOffset +
822 float distanceToPoint =
dot(vectorToPoint, vectorToPoint);
823 if (distanceToPoint < minDistance) {
824 minDistance = distanceToPoint;
825 vectorToClosest = vectorToPoint;
833 for (
int u = -1; u <= 1; u++) {
834 for (
int k = -1; k <= 1; k++) {
837 for (
int i = -1; i <= 1; i++) {
839 float4 vectorToPoint = cellOffset +
842 float4 perpendicularToEdge = vectorToPoint - vectorToClosest;
843 if (
dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
844 float distanceToEdge =
dot((vectorToClosest + vectorToPoint) / 2.0f,
846 minDistance =
min(minDistance, distanceToEdge);
852 *outDistance = minDistance;
860 float4 localPosition = coord - cellPosition;
864 float minDistance = 8.0f;
865 for (
int u = -1; u <= 1; u++) {
866 for (
int k = -1; k <= 1; k++) {
869 for (
int i = -1; i <= 1; i++) {
871 float4 pointPosition = cellOffset +
873 float distanceToPoint =
distance(pointPosition, localPosition);
874 if (distanceToPoint < minDistance) {
875 minDistance = distanceToPoint;
876 closestPoint = pointPosition;
877 closestPointOffset = cellOffset;
886 for (
int u = -1; u <= 1; u++) {
887 for (
int k = -1; k <= 1; k++) {
890 for (
int i = -1; i <= 1; i++) {
891 if (i == 0 && j == 0 && k == 0 && u == 0) {
895 float4 pointPosition = cellOffset +
897 float distanceToPoint =
distance(closestPoint, pointPosition);
898 if (distanceToPoint < minDistance) {
899 minDistance = distanceToPoint;
900 closestPointToClosestPoint = pointPosition;
906 *outRadius =
distance(closestPointToClosestPoint, closestPoint) / 2.0f;
909 template<u
int node_feature_mask>
921 uint coord_stack_offset, w_stack_offset, scale_stack_offset, smoothness_stack_offset;
922 uint exponent_stack_offset, randomness_stack_offset, distance_out_stack_offset,
923 color_out_stack_offset;
924 uint position_out_stack_offset, w_out_stack_offset, radius_out_stack_offset;
930 &smoothness_stack_offset);
932 &exponent_stack_offset,
933 &randomness_stack_offset,
934 &distance_out_stack_offset,
935 &color_out_stack_offset);
937 stack_offsets.
z, &position_out_stack_offset, &w_out_stack_offset, &radius_out_stack_offset);
949 float distance_out = 0.0f, w_out = 0.0f, radius_out = 0.0f;
953 randomness =
clamp(randomness, 0.0f, 1.0f);
954 smoothness =
clamp(smoothness / 2.0f, 0.0f, 0.5f);
959 switch (dimensions) {
961 switch (voronoi_feature) {
964 w, exponent, randomness, voronoi_metric, &distance_out, &
color_out, &w_out);
978 w, exponent, randomness, voronoi_metric, &distance_out, &
color_out, &w_out);
995 switch (voronoi_feature) {
1037 position_out =
make_float3(position_out_2d.
x, position_out_2d.
y, 0.0f);
1041 switch (voronoi_feature) {
1091 switch (voronoi_feature) {
1129 position_out_4d =
safe_divide(position_out_4d, scale);
1130 position_out =
make_float3(position_out_4d.x, position_out_4d.y, position_out_4d.z);
1131 w_out = position_out_4d.w;
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
#define kernel_assert(cond)
#define ccl_loop_no_unroll
#define ccl_device_noinline
#define CCL_NAMESPACE_END
const KernelGlobalsCPU *ccl_restrict KernelGlobals
ccl_device_inline float3 hash_float_to_float3(float k)
ccl_device_inline float3 hash_float4_to_float3(float4 k)
ccl_device_inline float3 hash_float2_to_float3(float2 k)
ccl_device_inline float2 hash_float2_to_float2(float2 k)
ccl_device_inline float4 hash_float4_to_float4(float4 k)
ccl_device_inline float3 hash_float3_to_float3(float3 k)
ccl_global float * color_out
ccl_gpu_kernel_postfix ccl_global float int int int int float bool int offset
ccl_device_inline void stack_store_float3(ccl_private float *stack, uint a, float3 f)
CCL_NAMESPACE_BEGIN ccl_device_inline float3 stack_load_float3(ccl_private float *stack, uint a)
ccl_device_inline uint4 read_node(KernelGlobals kg, ccl_private int *offset)
ccl_device_forceinline void svm_unpack_node_uchar3(uint i, ccl_private uint *x, ccl_private uint *y, ccl_private uint *z)
ccl_device_inline float stack_load_float_default(ccl_private float *stack, uint a, uint value)
ccl_device_inline void stack_store_float(ccl_private float *stack, uint a, float f)
ccl_device_forceinline void svm_unpack_node_uchar4(uint i, ccl_private uint *x, ccl_private uint *y, ccl_private uint *z, ccl_private uint *w)
ccl_device_inline bool stack_valid(uint a)
@ NODE_VORONOI_N_SPHERE_RADIUS
@ NODE_VORONOI_DISTANCE_TO_EDGE
NodeVoronoiDistanceMetric
#define IF_KERNEL_NODES_FEATURE(feature)
MINLINE float smoothstep(float edge0, float edge1, float x)
ccl_device_inline float2 zero_float2()
ccl_device_inline float2 safe_divide_float2_float(const float2 a, const float b)
ccl_device_inline float4 zero_float4()
T dot(const vec_base< T, Size > &a, const vec_base< T, Size > &b)
T clamp(const T &a, const T &min, const T &max)
T distance(const T &a, const T &b)
vec_base< T, Size > normalize(const vec_base< T, Size > &v)
T safe_divide(const T &a, const T &b)
float hash_float_to_float(float k)
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
ccl_device float voronoi_distance_4d(float4 a, float4 b, NodeVoronoiDistanceMetric metric, float exponent)
ccl_device void voronoi_f2_4d(float4 coord, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float4 *outPosition)
ccl_device void voronoi_smooth_f1_2d(float2 coord, float smoothness, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float2 *outPosition)
ccl_device_noinline int svm_node_tex_voronoi(KernelGlobals kg, ccl_private ShaderData *sd, ccl_private float *stack, uint dimensions, uint feature, uint metric, int offset)
ccl_device void voronoi_n_sphere_radius_2d(float2 coord, float randomness, ccl_private float *outRadius)
ccl_device void voronoi_smooth_f1_4d(float4 coord, float smoothness, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float4 *outPosition)
ccl_device void voronoi_n_sphere_radius_4d(float4 coord, float randomness, ccl_private float *outRadius)
ccl_device float voronoi_distance_2d(float2 a, float2 b, NodeVoronoiDistanceMetric metric, float exponent)
ccl_device void voronoi_f1_2d(float2 coord, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float2 *outPosition)
ccl_device void voronoi_f2_2d(float2 coord, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float2 *outPosition)
ccl_device void voronoi_distance_to_edge_4d(float4 coord, float randomness, ccl_private float *outDistance)
ccl_device void voronoi_f2_1d(float w, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float *outW)
ccl_device void voronoi_distance_to_edge_3d(float3 coord, float randomness, ccl_private float *outDistance)
ccl_device void voronoi_f1_1d(float w, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float *outW)
ccl_device void voronoi_f2_3d(float3 coord, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float3 *outPosition)
ccl_device void voronoi_f1_4d(float4 coord, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float4 *outPosition)
ccl_device float voronoi_distance_3d(float3 a, float3 b, NodeVoronoiDistanceMetric metric, float exponent)
CCL_NAMESPACE_BEGIN ccl_device float voronoi_distance_1d(float a, float b, NodeVoronoiDistanceMetric metric, float exponent)
ccl_device void voronoi_n_sphere_radius_1d(float w, float randomness, ccl_private float *outRadius)
ccl_device void voronoi_distance_to_edge_1d(float w, float randomness, ccl_private float *outDistance)
ccl_device void voronoi_smooth_f1_3d(float3 coord, float smoothness, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float3 *outPosition)
ccl_device void voronoi_distance_to_edge_2d(float2 coord, float randomness, ccl_private float *outDistance)
ccl_device void voronoi_smooth_f1_1d(float w, float smoothness, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float *outW)
ccl_device void voronoi_f1_3d(float3 coord, float exponent, float randomness, NodeVoronoiDistanceMetric metric, ccl_private float *outDistance, ccl_private float3 *outColor, ccl_private float3 *outPosition)
ccl_device void voronoi_n_sphere_radius_3d(float3 coord, float randomness, ccl_private float *outRadius)