31 N_(
"Scale elements by the same factor in every direction")},
36 N_(
"Scale elements in a single direction")},
37 {0,
nullptr, 0,
nullptr,
nullptr},
42 b.use_custom_socket_order();
43 b.allow_any_socket_order();
44 b.add_default_layout();
48 b.add_output<
decl::Geometry>(
"Geometry"_ustr).propagate_all_geometry().align_with_previous();
52 .evaluated_geometry_field();
57 .evaluated_geometry_field();
60 .evaluated_geometry_field()
63 "Origin of the scaling for each element. If multiple elements are connected, their "
64 "center is averaged");
70 .default_value({1.0f, 0.0f, 0.0f})
71 .evaluated_geometry_field()
72 .
description(
"Direction in which to scale the element")
89 using MeanAccumulator = std::pair<T, int>;
90 const auto join_accumulators = [](
const MeanAccumulator a,
91 const MeanAccumulator
b) -> MeanAccumulator {
92 return {(a.first +
b.first) / (a.second +
b.second), 1};
100 MeanAccumulator(
T(), 0),
101 [&](
const IndexRange range, MeanAccumulator other) -> MeanAccumulator {
103 for (
const int i : indices.
slice(range)) {
106 return join_accumulators({value, int(range.
size())}, other);
109 value = accumulator.first / accumulator.second;
118 for (const int group : range) {
119 means[group] = gather_mean<T>(values, groups[group]);
142 const float3 new_position = center + scaled_diff;
159 for (const int island_index : range) {
160 const Span<int> vert_island = vert_islands[island_index];
161 const float scale = scales[island_index];
162 const float3 center = centers[island_index];
163 threading::parallel_for(vert_island.index_range(), 2048, [&](const IndexRange range) {
164 for (const int vert_i : vert_island.slice(range)) {
165 positions[vert_i] = transform_with_uniform_scale(positions[vert_i], center, scale);
171 return elem_islands.offsets[range].size() + vert_islands.offsets[range].size();
197 base_change.
x_axis() = x_axis;
198 base_change.
y_axis() = y_axis;
199 base_change.
z_axis() = z_axis;
205 scale_transform[0][0] =
scale;
230 for (const int island_index : range) {
231 const Span<int> vert_island = vert_islands[island_index];
232 const float scale = scales[island_index];
233 const float3 center = centers[island_index];
234 const float3 axis = axes[island_index];
235 const float3 fixed_axis = math::is_zero(axis) ? float3(1.0f, 0.0f, 0.0f) : axis;
236 const float4x4 transform = create_single_axis_transform(center, fixed_axis, scale);
237 threading::parallel_for(vert_island.index_range(), 2048, [&](const IndexRange range) {
238 for (const int vert_i : vert_island.slice(range)) {
239 positions[vert_i] = math::transform_point(transform, positions[vert_i]);
245 return vert_islands.offsets[range].size() + elem_islands.offsets[range].size();
262 [&](
const int face_i) {
263 const Span<int> verts = face_verts[face_i];
264 const int v1 = verts_pos[verts.
first()];
265 for (
const int vert_i : verts.
drop_front(1)) {
266 const int v2 = verts_pos[vert_i];
267 disjoint_set.
join(v1,
v2);
275 [&](
const int face_i,
const int face_pos) {
276 const int face_vert_i = face_verts[face_i].first();
277 const int vert_pos = verts_pos[face_vert_i];
278 const int vert_island = vert_island_indices[vert_pos];
279 face_island_indices[face_pos] = vert_island;
295 mesh.face_offsets(), face_mask,
mesh.corner_verts(),
mesh.verts_num, memory);
300 mesh, face_mask, vert_mask, face_island_indices, vert_island_indices);
304 vert_island_indices, total_islands, r_vert_offsets, r_vert_indices);
306 face_island_indices, total_islands, r_item_offsets, r_item_indices);
309 if (face_mask.
size() !=
mesh.faces_num) {
315 if (vert_mask.
size() !=
mesh.verts_num) {
336 [&](
const int edge_i) {
337 const int2 edge = edges[edge_i];
338 const int v1 = verts_pos[edge[0]];
339 const int v2 = verts_pos[edge[1]];
340 disjoint_set.
join(v1,
v2);
347 [&](
const int edge_i,
const int edge_pos) {
348 const int2 edge = edges[edge_i];
349 const int edge_vert_i = edge[0];
350 const int vert_pos = verts_pos[edge_vert_i];
351 const int vert_island = vert_island_indices[vert_pos];
352 edge_island_indices[edge_pos] = vert_island;
368 mesh.edges(), edge_mask,
mesh.verts_num, memory);
373 mesh, edge_mask, vert_mask, edge_island_indices, vert_island_indices);
377 vert_island_indices, total_islands, r_vert_offsets, r_vert_indices);
379 edge_island_indices, total_islands, r_item_offsets, r_item_indices);
382 if (edge_mask.
size() !=
mesh.edges_num) {
388 if (vert_mask.
size() !=
mesh.verts_num) {
413 evaluator.
add(scale_field);
414 evaluator.
add(center_field);
420 if (
mask.is_empty()) {
431 case AttrDomain::Face:
434 case AttrDomain::Edge:
447 switch (scale_mode) {
454 item_islands, vert_islands, scale_varray, center_varray, axis_varray, *
mesh);
458 mesh->tag_positions_changed();
468 {int(AttrDomain::Face),
472 "Scale individual faces or neighboring face islands"},
473 {int(AttrDomain::Edge),
477 "Scale individual edges or neighboring edge islands"},
478 {0,
nullptr, 0,
nullptr,
nullptr},
484 "Element type to transform",
487 int(AttrDomain::Face));
495 ntype.
ui_name =
"Scale Elements";
496 ntype.
ui_description =
"Scale groups of connected edges and faces";
#define NODE_CLASS_GEOMETRY
#define GEO_NODE_SCALE_ELEMENTS
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define NOD_inline_enum_accessors(member)
#define BLI_assert_unreachable()
Span< T > as_span() const
MutableSpan< T > as_mutable_span()
int calc_reduced_ids(MutableSpan< int > result) const
constexpr int64_t size() const
constexpr Span drop_front(int64_t n) const
constexpr Span slice(int64_t start, int64_t size) const
constexpr const T & first() const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
std::optional< T > get_if_single() const
void set_selection(Field< bool > selection)
int add(GField field, GVArray *varray_ptr)
IndexMask get_evaluated_selection_as_mask() const
const GVArray & get_evaluated(const int field_index) const
void foreach_index_optimized(Fn &&fn, Mode mode=exec_mode::serial) const
void to_indices(MutableSpan< T > r_indices) const
int64_t min_array_size() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
T extract_input(const UString identifier)
T get_input(const UString identifier) const
const bNode & node() const
void set_output(const UString identifier, T &&value)
NodeDefaultInputType default_input_type
IMETHOD Vector diff(const Vector &a, const Vector &b, double dt)
float3x3 scale(float3x3 mat, float2 scale)
void gather(const GVArray &src, const IndexMask &indices, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
void node_register_type(bNodeType &ntype)
constexpr ParallelGrainSize grain_size(int grain_size)
void foreach_real_geometry(bke::GeometrySet &geometry, FunctionRef< void(bke::GeometrySet &geometry_set)> fn)
IndexMask vert_selection_from_face(OffsetIndices< int > faces, const IndexMask &face_mask, Span< int > corner_verts, int verts_num, IndexMaskMemory &memory)
IndexMask vert_selection_from_edge(Span< int2 > edges, const IndexMask &edge_mask, int verts_num, IndexMaskMemory &memory)
void build_reverse_map(const IndexMask &mask, MutableSpan< T > r_map)
MatBase< T, NumCol, NumRow > transpose(const MatBase< T, NumRow, NumCol > &mat)
AxisSigned cross(const AxisSigned a, const AxisSigned b)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
static int face_to_vert_islands(const Mesh &mesh, const IndexMask &face_mask, const IndexMask &vert_mask, MutableSpan< int > face_island_indices, MutableSpan< int > vert_island_indices)
static void node_rna(StructRNA *srna)
static float3 transform_with_uniform_scale(const float3 &position, const float3 ¢er, const float scale)
static T gather_mean(const VArray< T > &values, const Span< int > indices)
static void node_register()
static int edge_to_vert_islands(const Mesh &mesh, const IndexMask &edge_mask, const IndexMask &vert_mask, MutableSpan< int > edge_island_indices, MutableSpan< int > vert_island_indices)
static const EnumPropertyItem scale_mode_items[]
static void node_declare(NodeDeclarationBuilder &b)
static void node_init(bNodeTree *, bNode *node)
static void scale_on_axis(const GroupedSpan< int > elem_islands, const GroupedSpan< int > vert_islands, const VArray< float > &scale_varray, const VArray< float3 > ¢er_varray, const VArray< float3 > &axis_varray, Mesh &mesh)
static void gather_edge_islands(const Mesh &mesh, const IndexMask &edge_mask, Array< int > &r_item_offsets, Array< int > &r_item_indices, Array< int > &r_vert_offsets, Array< int > &r_vert_indices)
static void gather_face_islands(const Mesh &mesh, const IndexMask &face_mask, Array< int > &r_item_offsets, Array< int > &r_item_indices, Array< int > &r_vert_offsets, Array< int > &r_vert_indices)
static float4x4 create_single_axis_transform(const float3 ¢er, const float3 &axis, const float scale)
static void node_geo_exec(GeoNodeExecParams params)
static void gather_means(const VArray< T > &values, GroupedSpan< int > groups, MutableSpan< T > means)
static void node_layout(ui::Layout &layout, bContext *, PointerRNA *ptr)
static void scale_uniformly(const GroupedSpan< int > elem_islands, const GroupedSpan< int > vert_islands, const VArray< float > &scale_varray, const VArray< float3 > ¢er_varray, Mesh &mesh)
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)
GroupedSpan< int > build_groups_from_indices(Span< int > indices, int groups_num, Array< int > &offset_data, Array< int > &index_data)
Value parallel_deterministic_reduce(IndexRange range, int64_t grain_size, const Value &identity, const Function &function, const Reduction &reduction)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
auto accumulated_task_sizes(Fn &&fn)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void devirtualize_varray(const VArray< T > &varray, const Func &func, bool enable=true)
MatBase< float, 4, 4 > float4x4
VecBase< int32_t, 2 > int2
ATTR_WARN_UNUSED_RESULT const BMVert * v2
GeometryNodeScaleElementsMode
@ GEO_NODE_SCALE_ELEMENTS_UNIFORM
@ GEO_NODE_SCALE_ELEMENTS_SINGLE_AXIS
@ NODE_DEFAULT_INPUT_POSITION_FIELD
VecBase< float, 3 > float3
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
static MatBase identity()
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
NodeDeclareFunction declare
IndexRange index_range() const
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)