106 const float cellPosition =
floorf(coord);
107 const float localPosition = coord - cellPosition;
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 +
116 const float distanceToPoint =
voronoi_distance(pointPosition, localPosition);
117 if (distanceToPoint < minDistance) {
118 targetOffset = cellOffset;
119 minDistance = distanceToPoint;
120 targetPosition = pointPosition;
134 const float cellPosition =
floorf(coord);
135 const float localPosition = coord - cellPosition;
137 float smoothDistance = 0.0f;
138 float smoothPosition = 0.0f;
141 for (
int i = -2; i <= 2; i++) {
142 const float cellOffset = i;
143 const float pointPosition = cellOffset +
145 const float distanceToPoint =
voronoi_distance(pointPosition, localPosition);
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;
154 smoothColor =
mix(smoothColor, cellColor, h) - correctionFactor;
155 smoothPosition =
mix(smoothPosition, pointPosition, h) - correctionFactor;
160 octave.
color = smoothColor;
167 const float cellPosition =
floorf(coord);
168 const float localPosition = coord - cellPosition;
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 +
180 const float distanceToPoint =
voronoi_distance(pointPosition, localPosition);
181 if (distanceToPoint < distanceF1) {
182 distanceF2 = distanceF1;
183 distanceF1 = distanceToPoint;
185 offsetF1 = cellOffset;
186 positionF2 = positionF1;
187 positionF1 = pointPosition;
189 else if (distanceToPoint < distanceF2) {
190 distanceF2 = distanceToPoint;
191 offsetF2 = cellOffset;
192 positionF2 = pointPosition;
206 const float cellPosition =
floorf(coord);
207 const float localPosition = coord - cellPosition;
210 const float leftPointPosition = -1.0f +
212 const float rightPointPosition = 1.0f +
214 const float distanceToMidLeft =
fabsf((midPointPosition + leftPointPosition) / 2.0f -
216 const float distanceToMidRight =
fabsf((midPointPosition + rightPointPosition) / 2.0f -
219 return min(distanceToMidLeft, distanceToMidRight);
225 const float cellPosition =
floorf(coord);
226 const float localPosition = coord - cellPosition;
228 float closestPoint = 0.0f;
229 float closestPointOffset = 0.0f;
231 for (
int i = -1; i <= 1; i++) {
232 const float cellOffset = i;
233 const float pointPosition = cellOffset +
235 const float distanceToPoint =
fabsf(pointPosition - localPosition);
236 if (distanceToPoint < minDistance) {
237 minDistance = distanceToPoint;
238 closestPoint = pointPosition;
239 closestPointOffset = cellOffset;
244 float closestPointToClosestPoint = 0.0f;
245 for (
int i = -1; i <= 1; i++) {
249 const float cellOffset = i + closestPointOffset;
250 const float pointPosition = cellOffset +
252 const float distanceToPoint =
fabsf(closestPoint - pointPosition);
253 if (distanceToPoint < minDistance) {
254 minDistance = distanceToPoint;
255 closestPointToClosestPoint = pointPosition;
259 return fabsf(closestPointToClosestPoint - closestPoint) / 2.0f;
272 const float2 localPosition = coord - cellPosition_f;
278 for (
int j = -1; j <= 1; j++) {
279 for (
int i = -1; i <= 1; i++) {
285 if (distanceToPoint < minDistance) {
286 targetOffset = cellOffset;
287 minDistance = distanceToPoint;
288 targetPosition = pointPosition;
304 const float2 localPosition = coord - cellPosition_f;
307 float smoothDistance = 0.0f;
311 for (
int j = -2; j <= 2; j++) {
312 for (
int i = -2; i <= 2; i++) {
317 const float distanceToPoint =
voronoi_distance(pointPosition, localPosition, params);
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;
327 smoothColor =
mix(smoothColor, cellColor, h) - correctionFactor;
328 smoothPosition =
mix(smoothPosition, pointPosition, h) - correctionFactor;
334 octave.
color = smoothColor;
342 const float2 localPosition = coord - cellPosition_f;
351 for (
int j = -1; j <= 1; j++) {
352 for (
int i = -1; i <= 1; i++) {
357 const float distanceToPoint =
voronoi_distance(pointPosition, localPosition, params);
358 if (distanceToPoint < distanceF1) {
359 distanceF2 = distanceF1;
360 distanceF1 = distanceToPoint;
362 offsetF1 = cellOffset;
363 positionF2 = positionF1;
364 positionF1 = pointPosition;
366 else if (distanceToPoint < distanceF2) {
367 distanceF2 = distanceToPoint;
368 offsetF2 = cellOffset;
369 positionF2 = pointPosition;
385 const float2 localPosition = coord - cellPosition_f;
390 for (
int j = -1; j <= 1; j++) {
391 for (
int i = -1; i <= 1; i++) {
397 const float distanceToPoint =
dot(vectorToPoint, vectorToPoint);
398 if (distanceToPoint < minDistance) {
399 minDistance = distanceToPoint;
400 vectorToClosest = vectorToPoint;
406 for (
int j = -1; j <= 1; j++) {
407 for (
int i = -1; i <= 1; i++) {
413 const float2 perpendicularToEdge = vectorToPoint - vectorToClosest;
414 if (
dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
415 const float distanceToEdge =
dot((vectorToClosest + vectorToPoint) / 2.0f,
417 minDistance =
min(minDistance, distanceToEdge);
429 const float2 localPosition = coord - cellPosition_f;
435 for (
int j = -1; j <= 1; j++) {
436 for (
int i = -1; i <= 1; i++) {
441 const float distanceToPointSq =
len_squared(pointPosition - localPosition);
442 if (distanceToPointSq < minDistanceSq) {
443 minDistanceSq = distanceToPointSq;
444 closestPoint = pointPosition;
445 closestPointOffset = cellOffset;
452 for (
int j = -1; j <= 1; j++) {
453 for (
int i = -1; i <= 1; i++) {
454 if (i == 0 && j == 0) {
457 const int2 cellOffset =
make_int2(i, j) + closestPointOffset;
461 const float distanceToPointSq =
len_squared(closestPoint - pointPosition);
462 if (distanceToPointSq < minDistanceSq) {
463 minDistanceSq = distanceToPointSq;
464 closestPointToClosestPoint = pointPosition;
469 return distance(closestPointToClosestPoint, closestPoint) / 2.0f;
482 const float3 localPosition = coord - cellPosition_f;
488 for (
int k = -1; k <= 1; k++) {
489 for (
int j = -1; j <= 1; j++) {
490 for (
int i = -1; i <= 1; i++) {
496 if (distanceToPoint < minDistance) {
497 targetOffset = cellOffset;
498 minDistance = distanceToPoint;
499 targetPosition = pointPosition;
516 const float3 localPosition = coord - cellPosition_f;
519 float smoothDistance = 0.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++) {
530 const float distanceToPoint =
voronoi_distance(pointPosition, localPosition, params);
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;
540 smoothColor =
mix(smoothColor, cellColor, h) - correctionFactor;
541 smoothPosition =
mix(smoothPosition, pointPosition, h) - correctionFactor;
548 octave.
color = smoothColor;
556 const float3 localPosition = coord - cellPosition_f;
565 for (
int k = -1; k <= 1; k++) {
566 for (
int j = -1; j <= 1; j++) {
567 for (
int i = -1; i <= 1; i++) {
572 const float distanceToPoint =
voronoi_distance(pointPosition, localPosition, params);
573 if (distanceToPoint < distanceF1) {
574 distanceF2 = distanceF1;
575 distanceF1 = distanceToPoint;
577 offsetF1 = cellOffset;
578 positionF2 = positionF1;
579 positionF1 = pointPosition;
581 else if (distanceToPoint < distanceF2) {
582 distanceF2 = distanceToPoint;
583 offsetF2 = cellOffset;
584 positionF2 = pointPosition;
601 const float3 localPosition = coord - cellPosition_f;
606 for (
int k = -1; k <= 1; k++) {
607 for (
int j = -1; j <= 1; j++) {
608 for (
int i = -1; i <= 1; i++) {
614 const float distanceToPoint =
dot(vectorToPoint, vectorToPoint);
615 if (distanceToPoint < minDistance) {
616 minDistance = distanceToPoint;
617 vectorToClosest = vectorToPoint;
624 for (
int k = -1; k <= 1; k++) {
625 for (
int j = -1; j <= 1; j++) {
626 for (
int i = -1; i <= 1; i++) {
632 const float3 perpendicularToEdge = vectorToPoint - vectorToClosest;
633 if (
dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
634 const float distanceToEdge =
dot((vectorToClosest + vectorToPoint) / 2.0f,
636 minDistance =
min(minDistance, distanceToEdge);
649 const float3 localPosition = coord - cellPosition_f;
655 for (
int k = -1; k <= 1; k++) {
656 for (
int j = -1; j <= 1; j++) {
657 for (
int i = -1; i <= 1; i++) {
662 const float distanceToPointSq =
len_squared(pointPosition - localPosition);
663 if (distanceToPointSq < minDistanceSq) {
664 minDistanceSq = distanceToPointSq;
665 closestPoint = pointPosition;
666 closestPointOffset = cellOffset;
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) {
680 const int3 cellOffset =
make_int3(i, j, k) + closestPointOffset;
684 const float distanceToPointSq =
len_squared(closestPoint - pointPosition);
685 if (distanceToPointSq < minDistanceSq) {
686 minDistanceSq = distanceToPointSq;
687 closestPointToClosestPoint = pointPosition;
693 return distance(closestPointToClosestPoint, closestPoint) / 2.0f;
706 const float4 localPosition = coord - cellPosition_f;
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++) {
721 pointPosition, localPosition, params);
722 if (distanceToPoint < minDistance) {
723 targetOffset = cellOffset;
724 minDistance = distanceToPoint;
725 targetPosition = pointPosition;
743 const float4 localPosition = coord - cellPosition_f;
746 float smoothDistance = 0.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++) {
758 const float distanceToPoint =
voronoi_distance(pointPosition, localPosition, params);
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;
768 smoothColor =
mix(smoothColor, cellColor, h) - correctionFactor;
769 smoothPosition =
mix(smoothPosition, pointPosition, h) - correctionFactor;
777 octave.
color = smoothColor;
785 const float4 localPosition = coord - cellPosition_f;
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++) {
802 const float distanceToPoint =
voronoi_distance(pointPosition, localPosition, params);
803 if (distanceToPoint < distanceF1) {
804 distanceF2 = distanceF1;
805 distanceF1 = distanceToPoint;
807 offsetF1 = cellOffset;
808 positionF2 = positionF1;
809 positionF1 = pointPosition;
811 else if (distanceToPoint < distanceF2) {
812 distanceF2 = distanceToPoint;
813 offsetF2 = cellOffset;
814 positionF2 = pointPosition;
832 const float4 localPosition = coord - cellPosition_f;
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++) {
846 const float distanceToPoint =
dot(vectorToPoint, vectorToPoint);
847 if (distanceToPoint < minDistance) {
848 minDistance = distanceToPoint;
849 vectorToClosest = vectorToPoint;
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++) {
866 const float4 perpendicularToEdge = vectorToPoint - vectorToClosest;
867 if (
dot(perpendicularToEdge, perpendicularToEdge) > 0.0001f) {
868 const float distanceToEdge =
dot((vectorToClosest + vectorToPoint) / 2.0f,
870 minDistance =
min(minDistance, distanceToEdge);
884 const float4 localPosition = coord - cellPosition_f;
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++) {
898 const float distanceToPointSq =
len_squared(pointPosition - localPosition);
899 if (distanceToPointSq < minDistanceSq) {
900 minDistanceSq = distanceToPointSq;
901 closestPoint = pointPosition;
902 closestPointOffset = cellOffset;
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) {
918 const int4 cellOffset =
make_int4(i, j, k, u) + closestPointOffset;
922 const float distanceToPointSq =
len_squared(closestPoint - pointPosition);
923 if (distanceToPointSq < minDistanceSq) {
924 minDistanceSq = distanceToPointSq;
925 closestPointToClosestPoint = pointPosition;
932 return distance(closestPointToClosestPoint, closestPoint) / 2.0f;
943 float amplitude = 1.0f;
944 float max_amplitude = 0.0f;
948 const bool zero_input = params.detail == 0.0f || params.roughness == 0.0f;
950 for (
int i = 0; i <=
ceilf(params.detail); ++i) {
954 params.smoothness != 0.0f) ?
959 max_amplitude = 1.0f;
963 if (i <= params.detail) {
964 max_amplitude += amplitude;
968 scale *= params.lacunarity;
969 amplitude *= params.roughness;
972 const float remainder = params.detail -
floorf(params.detail);
973 if (remainder != 0.0f) {
974 max_amplitude =
mix(max_amplitude, max_amplitude + amplitude, remainder);
984 if (params.normalize) {
985 output.distance /= max_amplitude * params.max_distance;
986 output.color /= max_amplitude;
1000 float amplitude = 1.0f;
1001 float max_amplitude = params.max_distance;
1005 const bool zero_input = params.detail == 0.0f || params.roughness == 0.0f;
1007 for (
int i = 0; i <=
ceilf(params.detail); ++i) {
1014 if (i <= params.detail) {
1015 max_amplitude =
mix(max_amplitude, params.max_distance /
scale, amplitude);
1017 scale *= params.lacunarity;
1018 amplitude *= params.roughness;
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(
1032 if (params.normalize) {
1064template<u
int64_t node_feature_mask>
1090 coord *= params.
scale;
1098 switch (
node.dimensions) {
1120 float radius = 0.0f;
1121 switch (
node.dimensions) {
1144 switch (
node.dimensions) {
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
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 IF_KERNEL_NODES_FEATURE(feature)
#define ccl_device_noinline
#define CCL_NAMESPACE_END
float hash_float_to_float(float k)
T smoothstep(T, T, T) RET
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
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)
ccl_device_inline float3 hash_int3_to_float3(const int3 k)
ccl_device_inline float3 hash_int4_to_float3(const int4 k)
ccl_device_inline float2 hash_int2_to_float2(const int2 k)
ccl_device_inline float3 hash_int2_to_float3(const int2 k)
ccl_device_inline float4 hash_int4_to_float4(const int4 k)
@ NODE_VORONOI_N_SPHERE_RADIUS
@ NODE_VORONOI_DISTANCE_TO_EDGE
NodeVoronoiDistanceMetric
ccl_device_inline dual1 len_squared(const ccl_private dual< T > &a)
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
ccl_device_inline float2 power(const float2 v, const float e)
CCL_NAMESPACE_BEGIN ccl_device_inline float2 zero_float2()
CCL_NAMESPACE_BEGIN ccl_device_inline float3 zero_float3()
CCL_NAMESPACE_BEGIN ccl_device_inline float4 zero_float4()
ccl_device_inline int4 zero_int4()
ccl_device_noinline void svm_node_tex_voronoi(ccl_private float *ccl_restrict stack, const ccl_global SVMNodeTexVoronoi &ccl_restrict node)
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)
ccl_device float voronoi_distance_bound(const T a, const T b, const ccl_private VoronoiParams ¶ms)