33 const int dimensions =
b.node_or_null() ? node_storage(*
b.node_or_null()).dimensions : 3;
34 const bool is_compositor =
b.tree_or_null() &&
b.tree_or_null()->type ==
NTREE_COMPOSIT;
40 .available(dimensions != 1);
45 .available(
ELEM(dimensions, 1, 4))
48 node_storage(
node).dimensions = 1;
51 b.add_input<
decl::Float>(
"Scale"_ustr).min(-1000.0f).
max(1000.0f).default_value(5.0f);
54 b.node_or_null() ? node_storage(*
b.node_or_null()).feature :
SHD_VORONOI_F1);
61 .description(
"The number of Voronoi layers to sum");
69 .description(
"The influence of a Voronoi layer relative to that of the previous layer");
76 .description(
"The scale of a Voronoi layer relative to that of the previous layer");
118 node_storage(
node).dimensions = 1;
163 "node_tex_voronoi_f1_1d",
164 "node_tex_voronoi_f1_2d",
165 "node_tex_voronoi_f1_3d",
166 "node_tex_voronoi_f1_4d",
170 "node_tex_voronoi_f2_1d",
171 "node_tex_voronoi_f2_2d",
172 "node_tex_voronoi_f2_3d",
173 "node_tex_voronoi_f2_4d",
177 "node_tex_voronoi_smooth_f1_1d",
178 "node_tex_voronoi_smooth_f1_2d",
179 "node_tex_voronoi_smooth_f1_3d",
180 "node_tex_voronoi_smooth_f1_4d",
184 "node_tex_voronoi_distance_to_edge_1d",
185 "node_tex_voronoi_distance_to_edge_2d",
186 "node_tex_voronoi_distance_to_edge_3d",
187 "node_tex_voronoi_distance_to_edge_4d",
191 "node_tex_voronoi_n_sphere_radius_1d",
192 "node_tex_voronoi_n_sphere_radius_2d",
193 "node_tex_voronoi_n_sphere_radius_3d",
194 "node_tex_voronoi_n_sphere_radius_4d",
229 : dimensions_(dimensions), feature_(feature), metric_(metric), normalize_(
normalize)
231 BLI_assert(dimensions >= 1 && dimensions <= 4);
234 static std::array<mf::Signature, 12> signatures{
250 this->
set_signature(&signatures[dimensions + feature * 4 - 1]);
253 static std::array<mf::Signature, 12> signatures{
269 this->
set_signature(&signatures[dimensions + feature * 4 - 1]);
276 mf::SignatureBuilder builder{
"voronoi_metric",
signature};
278 if (
ELEM(dimensions, 2, 3, 4)) {
279 builder.single_input<
float3>(
"Vector");
281 if (
ELEM(dimensions, 1, 4)) {
282 builder.single_input<
float>(
"W");
284 builder.single_input<
float>(
"Scale");
285 builder.single_input<
float>(
"Detail");
286 builder.single_input<
float>(
"Roughness");
287 builder.single_input<
float>(
"Lacunarity");
289 builder.single_input<
float>(
"Smoothness");
292 builder.single_input<
float>(
"Exponent");
294 builder.single_input<
float>(
"Randomness");
296 builder.single_output<
float>(
"Distance", mf::ParamFlag::SupportsUnusedOutput);
297 builder.single_output<
ColorGeometry4f>(
"Color", mf::ParamFlag::SupportsUnusedOutput);
298 if (dimensions != 1) {
299 builder.single_output<
float3>(
"Position", mf::ParamFlag::SupportsUnusedOutput);
301 if (
ELEM(dimensions, 1, 4)) {
302 builder.single_output<
float>(
"W", mf::ParamFlag::SupportsUnusedOutput);
311 return mf_params.readonly_single_input<
float3>(param_index,
"Vector");
314 return mf_params.readonly_single_input<
float>(param_index,
"W");
317 return mf_params.readonly_single_input<
float>(param_index,
"Scale");
320 return mf_params.readonly_single_input<
float>(param_index,
"Detail");
323 return mf_params.readonly_single_input<
float>(param_index,
"Roughness");
325 auto get_lacunarity = [&](
int param_index) ->
VArray<float> {
326 return mf_params.readonly_single_input<
float>(param_index,
"Lacunarity");
328 auto get_smoothness = [&](
int param_index) ->
VArray<float> {
329 return mf_params.readonly_single_input<
float>(param_index,
"Smoothness");
332 return mf_params.readonly_single_input<
float>(param_index,
"Exponent");
334 auto get_randomness = [&](
int param_index) ->
VArray<float> {
335 return mf_params.readonly_single_input<
float>(param_index,
"Randomness");
338 return mf_params.uninitialized_single_output_if_required<
float>(param_index,
"Distance");
341 return mf_params.uninitialized_single_output_if_required<
ColorGeometry4f>(param_index,
345 return mf_params.uninitialized_single_output_if_required<
float3>(param_index,
"Position");
348 return mf_params.uninitialized_single_output_if_required<
float>(param_index,
"W");
360 get_smoothness(param++) :
363 get_exponent(param++) :
371 const bool calc_distance = !r_distance.
is_empty();
372 const bool calc_color = !r_color.
is_empty();
373 const bool calc_position = !r_position.
is_empty();
374 const bool calc_w = !r_w.
is_empty();
382 switch (dimensions_) {
390 std::min(std::max(smoothness[i] / 2.0f, 0.0f), 0.5f) :
393 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
399 r_distance[i] =
output.distance;
405 r_w[i] =
output.position.w;
417 std::min(std::max(smoothness[i] / 2.0f, 0.0f), 0.5f) :
422 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
430 params,
float2{vector[i].x, vector[i].y} * params.
scale, calc_color);
432 r_distance[i] =
output.distance;
450 std::min(std::max(smoothness[i] / 2.0f, 0.0f), 0.5f) :
455 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
464 params, vector[i] * params.
scale, calc_color);
466 r_distance[i] =
output.distance;
484 std::min(std::max(smoothness[i] / 2.0f, 0.0f), 0.5f) :
489 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
500 float4{vector[i].x, vector[i].y, vector[i].z,
w[i]} * params.
scale,
503 r_distance[i] =
output.distance;
512 r_w[i] =
output.position.w;
522 static constexpr int8_t id = 0;
524 hash.add(dimensions_);
527 hash.add(normalize_);
543 : dimensions_(dimensions), normalize_(
normalize)
545 BLI_assert(dimensions >= 1 && dimensions <= 4);
546 static std::array<mf::Signature, 4> signatures{
558 mf::SignatureBuilder builder{
"voronoi_dist_to_edge",
signature};
560 if (
ELEM(dimensions, 2, 3, 4)) {
561 builder.single_input<
float3>(
"Vector");
563 if (
ELEM(dimensions, 1, 4)) {
564 builder.single_input<
float>(
"W");
566 builder.single_input<
float>(
"Scale");
567 builder.single_input<
float>(
"Detail");
568 builder.single_input<
float>(
"Roughness");
569 builder.single_input<
float>(
"Lacunarity");
570 builder.single_input<
float>(
"Randomness");
572 builder.single_output<
float>(
"Distance");
580 return mf_params.readonly_single_input<
float3>(param_index,
"Vector");
583 return mf_params.readonly_single_input<
float>(param_index,
"W");
586 return mf_params.readonly_single_input<
float>(param_index,
"Scale");
589 return mf_params.readonly_single_input<
float>(param_index,
"Detail");
592 return mf_params.readonly_single_input<
float>(param_index,
"Roughness");
594 auto get_lacunarity = [&](
int param_index) ->
VArray<float> {
595 return mf_params.readonly_single_input<
float>(param_index,
"Lacunarity");
597 auto get_randomness = [&](
int param_index) ->
VArray<float> {
598 return mf_params.readonly_single_input<
float>(param_index,
"Randomness");
601 return mf_params.uninitialized_single_output<
float>(param_index,
"Distance");
618 switch (dimensions_) {
625 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
639 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
643 params,
float2{vector[i].x, vector[i].y} * params.
scale);
653 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
657 params, vector[i] * params.
scale);
667 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
671 params,
float4{vector[i].x, vector[i].y, vector[i].z,
w[i]} * params.
scale);
680 static constexpr int8_t id = 0;
682 hash.add(dimensions_);
683 hash.add(normalize_);
699 BLI_assert(dimensions >= 1 && dimensions <= 4);
700 static std::array<mf::Signature, 4> signatures{
712 mf::SignatureBuilder builder{
"voronoi_n_sphere",
signature};
714 if (
ELEM(dimensions, 2, 3, 4)) {
715 builder.single_input<
float3>(
"Vector");
717 if (
ELEM(dimensions, 1, 4)) {
718 builder.single_input<
float>(
"W");
720 builder.single_input<
float>(
"Scale");
721 builder.single_input<
float>(
"Randomness");
723 builder.single_output<
float>(
"Radius");
731 return mf_params.readonly_single_input<
float3>(param_index,
"Vector");
734 return mf_params.readonly_single_input<
float>(param_index,
"W");
737 return mf_params.readonly_single_input<
float>(param_index,
"Scale");
739 auto get_randomness = [&](
int param_index) ->
VArray<float> {
740 return mf_params.readonly_single_input<
float>(param_index,
"Randomness");
743 return mf_params.uninitialized_single_output<
float>(param_index,
"Radius");
756 switch (dimensions_) {
760 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
769 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
772 params,
float2{vector[i].x, vector[i].y} * params.
scale);
779 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
788 params.
randomness = std::min(std::max(randomness[i], 0.0f), 1.0f);
791 params,
float4{vector[i].x, vector[i].y, vector[i].z,
w[i]} * params.
scale);
800 static constexpr int8_t id = 0;
802 hash.add(dimensions_);
841 ntype.
ui_name =
"Voronoi Texture";
843 "Generate Worley noise based on the distance to random points. Typically used to generate "
844 "textures such as stones, water, or biological cells";
847 ntype.
declare = file_ns::sh_node_tex_voronoi_declare;
848 ntype.
draw_buttons = file_ns::node_shader_buts_tex_voronoi;
849 ntype.
initfunc = file_ns::node_shader_init_tex_voronoi;
852 ntype.
gpu_fn = file_ns::node_shader_gpu_tex_voronoi;
#define NODE_STORAGE_FUNCS(StorageT)
#define NODE_CLASS_TEXTURE
#define SH_NODE_TEX_VORONOI
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
constexpr bool is_empty() const
const Signature & signature() const
void set_signature(const Signature *signature)
void construct_and_set_matching_fn(Args &&...args)
void make_available(bNode &node) const
NodeDefaultInputType default_input_type
VoronoiDistToEdgeFunction(int dimensions, bool normalize)
ExecutionHints get_execution_hints() const override
void call(const IndexMask &mask, mf::Params mf_params, mf::Context) const override
static mf::Signature create_signature(int dimensions)
void hash_unique(UniqueHashBytes &hash) const override
ExecutionHints get_execution_hints() const override
void call(const IndexMask &mask, mf::Params mf_params, mf::Context) const override
static mf::Signature create_signature(int dimensions, int feature, int metric)
void hash_unique(UniqueHashBytes &hash) const override
VoronoiMetricFunction(int dimensions, int feature, int metric, bool normalize)
void call(const IndexMask &mask, mf::Params mf_params, mf::Context) const override
VoronoiNSphereFunction(int dimensions)
void hash_unique(UniqueHashBytes &hash) const override
static mf::Signature create_signature(int dimensions)
ExecutionHints get_execution_hints() const override
#define storage(slot, qualifiers)
VecBase< float, D > normalize(VecOp< float, D >) RET
float3x3 scale(float3x3 mat, float2 scale)
void node_register_type(bNodeType &ntype)
void node_type_storage(bNodeType &ntype, std::optional< StringRefNull > storagename, void(*freefunc)(bNode *node), void(*copyfunc)(bNodeTree *dest_ntree, bNode *dest_node, const bNode *src_node))
static const char * gpu_shader_get_name(const int feature, const int dimensions)
static void sh_node_tex_voronoi_declare(NodeDeclarationBuilder &b)
static void node_shader_buts_tex_voronoi(ui::Layout &layout, bContext *, PointerRNA *ptr)
static mf::MultiFunction::ExecutionHints voronoi_execution_hints
static void sh_node_voronoi_build_multi_function(NodeMultiFunctionBuilder &builder)
static int node_shader_gpu_tex_voronoi(GPUMaterial *mat, bNode *node, bNodeExecData *, GPUNodeStack *in, GPUNodeStack *out)
static void node_shader_init_tex_voronoi(bNodeTree *node_tree, bNode *node)
template VoronoiOutput fractal_voronoi_x_fx< float4 >(const VoronoiParams ¶ms, const float4 coord, const bool calc_color)
template float fractal_voronoi_distance_to_edge< float >(const VoronoiParams ¶ms, const float coord)
float voronoi_n_sphere_radius(const VoronoiParams ¶ms, const float coord)
template VoronoiOutput fractal_voronoi_x_fx< float3 >(const VoronoiParams ¶ms, const float3 coord, const bool calc_color)
float voronoi_distance(const float a, const float b)
template VoronoiOutput fractal_voronoi_x_fx< float >(const VoronoiParams ¶ms, const float coord, const bool calc_color)
template float fractal_voronoi_distance_to_edge< float3 >(const VoronoiParams ¶ms, const float3 coord)
template VoronoiOutput fractal_voronoi_x_fx< float2 >(const VoronoiParams ¶ms, const float2 coord, const bool calc_color)
template float fractal_voronoi_distance_to_edge< float4 >(const VoronoiParams ¶ms, const float4 coord)
template float fractal_voronoi_distance_to_edge< float2 >(const VoronoiParams ¶ms, const float2 coord)
@ ITEM_R_SPLIT_EMPTY_NAME
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
bool GPU_stack_link(GPUMaterial *mat, const bNode *node, const char *name, GPUNodeStack *in, GPUNodeStack *out,...)
int RNA_enum_get(PointerRNA *ptr, const char *name)
void register_node_type_sh_tex_voronoi()
VecBase< float, 4 > float4
GPUNodeLink * GPU_constant(const float *num)
VecBase< float, 2 > float2
void node_shader_gpu_tex_mapping(GPUMaterial *mat, bNode *node, GPUNodeStack *in, GPUNodeStack *)
void node_shader_gpu_default_tex_coord(GPUMaterial *mat, bNode *node, GPUNodeLink **link)
void BKE_texture_mapping_default(struct TexMapping *texmap, int type)
@ NODE_DEFAULT_INPUT_POSITION_FIELD
@ NODE_DEFAULT_INPUT_UNIFORM_IMAGE_COORDINATES
void node_copy_standard_storage(bNodeTree *, bNode *dest_node, const bNode *src_node)
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
@ SHD_VORONOI_DISTANCE_TO_EDGE
@ SHD_VORONOI_N_SPHERE_RADIUS
void node_free_standard_storage(bNode *node)
VecBase< float, 3 > float3
void BKE_texture_colormapping_default(struct ColorMapping *colormap)
void common_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
ColorMapping color_mapping
static constexpr int _160
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
std::string ui_description
NodeGPUExecFunction gpu_fn
NodeMultiFunctionBuildFunction build_multi_function
void(*) initfunc(bNodeTree *ntree, bNode *node)
const char * enum_name_legacy
NodeDeclareFunction declare
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)