34 b.use_custom_socket_order();
35 b.allow_any_socket_order();
36 b.add_default_layout();
39 if (
node !=
nullptr) {
41 b.add_input(data_type,
"Value"_ustr)
42 .structure_type(StructureType::Field)
44 .is_default_link_socket();
45 b.add_output(data_type,
"Value"_ustr)
46 .structure_type(StructureType::Field)
47 .propagate_references()
48 .align_with_previous();
53 .
description(
"How many times to blur the values for all elements");
59 .structure_type(StructureType::Field)
60 .description(
"Relative mix weight of neighboring elements");
83 if (!new_node_type.has_value()) {
102 bNode &
node = params.add_node(node_type);
103 node.custom1 = fixed_data_type;
104 params.update_and_connect_available_socket(
node,
"Value"_ustr);
116 for (
const int vert : range) {
133 edges, verts_num, vert_to_edge_offset_data, vert_to_edge_indices);
138 for (const int edge_i : range) {
139 const int2 edge = edges[edge_i];
140 r_offsets[edge_i] = vert_to_edge_offsets[edge[0]].size() - 1 +
141 vert_to_edge_offsets[edge[1]].size() - 1;
148 for (const int edge_i : range) {
149 const int2 edge = edges[edge_i];
150 MutableSpan<int> neighbors = r_indices.as_mutable_span().slice(offsets[edge_i]);
152 for (const Span<int> neighbor_edges : {vert_to_edge[edge[0]], vert_to_edge[edge[1]]}) {
153 for (const int neighbor_edge : neighbor_edges) {
154 if (neighbor_edge != edge_i) {
155 neighbors[count] = neighbor_edge;
173 faces, corner_edges, edges_num, edge_to_face_offset_data, edge_to_face_indices);
178 for (const int face_i : range) {
179 for (const int edge : corner_edges.slice(faces[face_i])) {
181 r_offsets[face_i] += edge_to_face_offsets[edge].size() - 1;
189 for (const int face_i : range) {
190 MutableSpan<int> neighbors = r_indices.as_mutable_span().slice(offsets[face_i]);
191 if (neighbors.is_empty()) {
195 for (const int edge : corner_edges.slice(faces[face_i])) {
196 for (const int neighbor : edge_to_face_map[edge]) {
197 if (neighbor != face_i) {
198 neighbors[count] = neighbor;
210 const int corners_num,
216 for (const int face : range) {
217 for (const int corner : faces[face]) {
218 const int vert = corner_verts[corner];
219 constexpr int self_corner = -1;
220 constexpr int prev_and_next_corners = 2;
221 r_offsets[corner] += vert_to_corner_map.offsets[vert].size() + self_corner +
222 prev_and_next_corners;
230 for (const int face : range) {
231 for (const int corner : faces[face]) {
232 const int vert = corner_verts[corner];
233 const int prev_corner = bke::mesh::face_corner_prev(faces[face], corner);
234 const int next_corner = bke::mesh::face_corner_next(faces[face], corner);
236 MutableSpan<int> neighbors = r_indices.as_mutable_span().slice(offsets[corner]);
238 MutableSpan<int> vert_neighbors = neighbors.drop_back(1);
239 vert_neighbors.copy_from(vert_to_corner_map[vert]);
241 int *self_corner = std::find(vert_neighbors.begin(), vert_neighbors.end(), corner);
242 *self_corner = prev_corner;
244 neighbors.last() = next_corner;
256 case AttrDomain::Point:
259 case AttrDomain::Edge:
262 case AttrDomain::Face:
264 mesh.faces(),
mesh.corner_edges(),
mesh.edges_num, r_offsets, r_indices);
266 case AttrDomain::Corner:
284 const int iterations,
297 for (const int64_t index : range) {
298 const Span<int> neighbors = neighbors_map[index];
299 const float neighbor_weight = neighbor_weights[index];
300 mixer.set(index, src[index], 1.0f);
301 for (const int neighbor : neighbors) {
302 mixer.mix_in(index, src[neighbor], neighbor_weight);
305 mixer.finalize(range);
319 const int iterations,
327 mesh, domain, neighbor_offsets, neighbor_indices);
331 using T = decltype(dummy);
332 result_buffer = blur_on_mesh_exec<T>(
333 neighbor_weights, neighbors_map, iterations, buffer_a.typed<T>(), buffer_b.typed<T>());
335 return result_buffer;
341 const int iterations,
351 for ([[maybe_unused]]
const int iteration :
IndexRange(iterations)) {
355 for (const int curve_i : range) {
356 const IndexRange points = points_by_curve[curve_i];
357 if (points.size() == 1) {
359 const int point_i = points[0];
360 mixer.set(point_i, src[point_i], 1.0f);
364 for (const int point_i : points.drop_front(1).drop_back(1)) {
365 const float neighbor_weight = neighbor_weights[point_i];
366 mixer.set(point_i, src[point_i], 1.0f);
367 mixer.mix_in(point_i, src[point_i - 1], neighbor_weight);
368 mixer.mix_in(point_i, src[point_i + 1], neighbor_weight);
370 const int first_i = points[0];
371 const float first_neighbor_weight = neighbor_weights[first_i];
372 const int last_i = points.last();
373 const float last_neighbor_weight = neighbor_weights[last_i];
376 mixer.set(first_i, src[first_i], 1.0f);
377 mixer.mix_in(first_i, src[first_i + 1], first_neighbor_weight);
379 mixer.set(last_i, src[last_i], 1.0f);
380 mixer.mix_in(last_i, src[last_i - 1], last_neighbor_weight);
382 if (cyclic[curve_i]) {
384 mixer.mix_in(first_i, src[last_i], first_neighbor_weight);
386 mixer.mix_in(last_i, src[first_i], last_neighbor_weight);
389 mixer.finalize(points_by_curve[range]);
397 const int iterations,
404 using T = decltype(dummy);
405 result_buffer = blur_on_curve_exec<T>(
406 curves, neighbor_weights, iterations, buffer_a.typed<T>(), buffer_b.typed<T>());
408 return result_buffer;
414 const GField value_field_;
415 const int iterations_;
420 weight_field_(std::move(weight_field)),
421 value_field_(std::move(value_field)),
422 iterations_(iterations)
429 const int64_t domain_size = context.attributes()->domain_size(context.domain());
436 evaluator.
add(weight_field_);
440 if (domain_size <= 1) {
444 if (iterations_ <= 0) {
452 switch (context.type()) {
454 if (
ELEM(context.domain(),
460 if (
const Mesh *
mesh = context.mesh()) {
462 *
mesh, context.domain(), iterations_, neighbor_weights, buffer_a, buffer_b);
468 if (context.domain() == AttrDomain::Point) {
471 *
curves, iterations_, neighbor_weights, buffer_a, buffer_b);
480 if (result_buffer.
data() == buffer_a.
data()) {
494 static constexpr int8_t id = 0;
496 hash.add(deep_hash_cache.
ensure(weight_field_));
497 hash.add(deep_hash_cache.
ensure(value_field_));
498 hash.add(iterations_);
509 const int iterations = params.
extract_input<
int>(
"Iterations"_ustr);
515 std::move(weight_field), std::move(value_field), iterations));
540 ntype.
ui_name =
"Blur Attribute";
541 ntype.
ui_description =
"Mix attribute values of neighboring elements";
Low-level operations for curves.
#define NODE_CLASS_ATTRIBUTE
#define GEO_NODE_BLUR_ATTRIBUTE
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_inline_enum_accessors(member)
#define BLI_assert_unreachable()
MutableSpan< T > as_mutable_span()
void to_static_type(Fn &&fn) const
GMutableSpan as_mutable_span()
const void * data() const
const CPPType & type() const
const void * data() const
static GVArray from_garray(GArray<> array)
constexpr IndexRange()=default
constexpr IndexRange index_range() const
constexpr int64_t size() const
constexpr IndexRange index_range() const
int add(GField field, GVArray *varray_ptr)
int add_with_destination(GField field, GVMutableArray dst)
const GVArray & get_evaluated(const int field_index) const
static GField from_input(Args &&...args)
const bke::bNodeType & node_type() const
void add_item(std::string socket_name, SocketLinkOperation::LinkSocketFn fn, int weight=0)
const bNodeSocket & other_socket() const
T extract_input(const UString identifier)
void set_output(const UString identifier, T &&value)
Vector< SocketDeclaration * > inputs
IndexRange index_range() const
typename DefaultMixerStruct< T >::type DefaultMixer
int edge_other_vert(const int2 edge, const int vert)
GroupedSpan< int > build_edge_to_face_map(OffsetIndices< int > faces, Span< int > corner_edges, int edges_num, Array< int > &r_offsets, Array< int > &r_indices)
GroupedSpan< int > build_vert_to_edge_map(Span< int2 > edges, int verts_num, Array< int > &r_offsets, Array< int > &r_indices)
std::optional< AttrDomain > try_detect_field_domain(const GeometryComponent &component, const fn::GField &field)
void node_register_type(bNodeType &ntype)
std::optional< eCustomDataType > socket_type_to_custom_data_type(eNodeSocketDatatype type)
static void node_geo_exec(GeoNodeExecParams params)
static Span< T > blur_on_curve_exec(const bke::CurvesGeometry &curves, const Span< float > neighbor_weights, const int iterations, const MutableSpan< T > buffer_a, const MutableSpan< T > buffer_b)
static void build_corner_to_corner_by_vert_map(const GroupedSpan< int > vert_to_corner_map, const OffsetIndices< int > faces, const Span< int > corner_verts, const int corners_num, Array< int > &r_offsets, Array< int > &r_indices)
static void node_gather_link_searches(GatherLinkSearchOpParams ¶ms)
static void build_vert_to_vert_by_edge_map(const Span< int2 > edges, const int verts_num, Array< int > &r_offsets, Array< int > &r_indices)
static void to_static_type_for_blur(const CPPType &type, const Func &func)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void node_rna(StructRNA *srna)
static GSpan blur_on_mesh(const Mesh &mesh, const AttrDomain domain, const int iterations, const Span< float > neighbor_weights, const GMutableSpan buffer_a, const GMutableSpan buffer_b)
static void node_register()
static GSpan blur_on_curves(const bke::CurvesGeometry &curves, const int iterations, const Span< float > neighbor_weights, const GMutableSpan buffer_a, const GMutableSpan buffer_b)
static GroupedSpan< int > create_mesh_map(const Mesh &mesh, const AttrDomain domain, Array< int > &r_offsets, Array< int > &r_indices)
static void build_face_to_face_by_edge_map(const OffsetIndices< int > faces, const Span< int > corner_edges, const int edges_num, Array< int > &r_offsets, Array< int > &r_indices)
static void build_edge_to_edge_by_vert_map(const Span< int2 > edges, const int verts_num, Array< int > &r_offsets, Array< int > &r_indices)
static void node_init(bNodeTree *, bNode *node)
static void node_declare(NodeDeclarationBuilder &b)
static Span< T > blur_on_mesh_exec(const Span< float > neighbor_weights, const GroupedSpan< int > neighbors_map, const int iterations, const MutableSpan< T > buffer_a, const MutableSpan< T > buffer_b)
void search_link_ops_for_declarations(GatherLinkSearchOpParams ¶ms, Span< SocketDeclaration * > declarations)
PropertyRNA * RNA_def_node_enum(StructRNA *srna, const char *identifier, const char *ui_name, const char *ui_description, const EnumPropertyItem *static_items, const EnumRNAAccessors accessors, std::optional< int > default_value, const EnumPropertyItemFunc item_func, const bool allow_animation)
const EnumPropertyItem * enum_items_filter(const EnumPropertyItem *original_item_array, FunctionRef< bool(const EnumPropertyItem &item)> fn)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
const EnumPropertyItem rna_enum_attribute_type_items[]
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
VecBase< float, 3 > float3
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
void(*) draw_buttons(ui::Layout &, bContext *C, PointerRNA *ptr)
std::string ui_description
NodeGeometryExecFunction geometry_node_execute
void(*) initfunc(bNodeTree *ntree, bNode *node)
const char * enum_name_legacy
NodeGatherSocketLinkOperationsFunction gather_link_search_ops
NodeDeclareFunction declare
nodes::NodeDeclaration * static_declaration
UniqueHash ensure(const GFieldRef &field)
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)