Blender V5.3
node_geo_grease_pencil_to_curves.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#include "BLI_array_utils.hh"
6
7#include "BKE_curves.hh"
9#include "BKE_instances.hh"
10
12
13#include "node_geometry_util.hh"
14
16
18{
19 b.add_input<decl::Geometry>("Grease Pencil"_ustr)
21 .description("Grease Pencil data to convert to curves");
22 b.add_input<decl::Bool>("Selection"_ustr)
23 .default_value(true)
24 .hide_value()
25 .evaluated_geometry_field()
26 .description("Select the layers to convert");
27 b.add_input<decl::Bool>("Layers as Instances"_ustr)
28 .default_value(true)
29 .description("Create a separate curve instance for every layer");
30 b.add_output<decl::Geometry>("Curves"_ustr).propagate_all_geometry();
31}
32
34{
35 GeometrySet grease_pencil_geometry = params.extract_input<GeometrySet>("Grease Pencil"_ustr);
36 const GreasePencil *grease_pencil = grease_pencil_geometry.get_grease_pencil();
37 if (!grease_pencil) {
39 return;
40 }
41
43 const int layers_num = layers.size();
44
45 const bke::GreasePencilFieldContext field_context{*grease_pencil};
46 const Field<bool> selection_field = params.extract_input<Field<bool>>("Selection"_ustr);
47 FieldEvaluator evaluator{field_context, layers_num};
48 evaluator.set_selection(selection_field);
49 evaluator.evaluate();
50 const IndexMask layer_selection = evaluator.get_evaluated_selection_as_mask();
51
52 const int instances_num = layer_selection.size();
53 if (instances_num == 0) {
55 return;
56 }
57
58 auto instances = std::make_unique<bke::Instances>(layer_selection.size());
59 MutableSpan<int> handles = instances->reference_handles_for_write();
60 MutableSpan<float4x4> transforms = instances->transforms_for_write();
61
62 std::optional<int> empty_geometry_handle;
63
64 layer_selection.foreach_index([&](const int layer_i, const int pos) {
65 const bke::greasepencil::Layer &layer = *layers[layer_i];
66 const bke::greasepencil::Drawing *drawing = grease_pencil->get_eval_drawing(layer);
67 const float4x4 transform = layer.local_transform();
68 if (!drawing) {
69 if (!empty_geometry_handle.has_value()) {
70 empty_geometry_handle = instances->add_reference(bke::InstanceReference());
71 }
72 handles[pos] = *empty_geometry_handle;
73 transforms[pos] = transform;
74 return;
75 }
76 const bke::CurvesGeometry &layer_strokes = drawing->strokes();
77 Curves *curves_id = bke::curves_new_nomain(layer_strokes);
78 curves_id->mat = MEM_dupalloc(grease_pencil->material_array);
79 curves_id->totcol = grease_pencil->material_array_num;
80 GeometrySet curves_geometry = GeometrySet::from_curves(curves_id);
81 curves_geometry.set_name(layer.name());
82 handles[pos] = instances->add_reference(std::move(curves_geometry));
83 transforms[pos] = transform;
84 });
85
86 const bke::AttributeAccessor grease_pencil_attributes = grease_pencil->attributes();
87 bke::MutableAttributeAccessor instances_attributes = instances->attributes_for_write();
88 grease_pencil_attributes.foreach_attribute([&](const bke::AttributeIter &iter) {
89 if (ELEM(iter.name, "opacity")) {
90 return;
91 }
92 if (iter.data_type == bke::AttrType::String) {
93 return;
94 }
95 const GAttributeReader src_attribute = iter.get();
96 if (!src_attribute) {
97 return;
98 }
99 if (src_attribute.varray.is_span() && src_attribute.sharing_info) {
100 /* Try reusing existing attribute array. */
101 instances_attributes.add(
102 iter.name,
103 AttrDomain::Instance,
104 iter.data_type,
105 bke::AttributeInitShared{src_attribute.varray.get_internal_span().data(),
106 *src_attribute.sharing_info});
107 return;
108 }
109 if (!instances_attributes.add(
110 iter.name, AttrDomain::Instance, iter.data_type, bke::AttributeInitConstruct()))
111 {
112 return;
113 }
114 bke::GSpanAttributeWriter dst_attribute = instances_attributes.lookup_for_write_span(
115 iter.name);
116 array_utils::gather(src_attribute.varray, layer_selection, dst_attribute.span);
117 dst_attribute.finish();
118 });
119
120 {
121 /* Manually propagate "opacity" data, because it's not a layer attribute on grease pencil
122 * yet. */
123 if (SpanAttributeWriter<float> opacity_attribute =
124 instances_attributes.lookup_or_add_for_write_only_span<float>("opacity",
125 AttrDomain::Instance))
126 {
127 layer_selection.foreach_index([&](const int layer_i, const int instance_i) {
128 opacity_attribute.span[instance_i] = grease_pencil->layer(layer_i).opacity;
129 });
130 opacity_attribute.finish();
131 }
132 }
133
134 GeometrySet curves_geometry = GeometrySet::from_instances(std::move(instances));
135 curves_geometry.set_name(grease_pencil_geometry.name());
136 curves_geometry.copy_bundle_from(grease_pencil_geometry);
137
138 const bool layers_as_instances = params.extract_input<bool>("Layers as Instances"_ustr);
139 if (!layers_as_instances) {
141 const NodeAttributeFilter attribute_filter = params.get_attribute_filter("Curves"_ustr);
142 options.attribute_filter = attribute_filter;
143 curves_geometry = geometry::realize_instances(curves_geometry, options).geometry;
144 }
145
146 params.set_output("Curves"_ustr, std::move(curves_geometry));
147}
148
149static void node_register()
150{
151 static bke::bNodeType ntype;
153 &ntype, "GeometryNodeGreasePencilToCurves"_ustr, GEO_NODE_GREASE_PENCIL_TO_CURVES);
154 ntype.ui_name = "Grease Pencil to Curves";
155 ntype.ui_description = "Convert Grease Pencil layers into curve instances";
156 ntype.enum_name_legacy = "GREASE_PENCIL_TO_CURVES";
159 ntype.declare = node_declare;
161
163}
165
166} // namespace blender::nodes::node_geo_grease_pencil_to_curves_cc
Low-level operations for curves.
Low-level operations for grease pencil.
#define NODE_CLASS_GEOMETRY
Definition BKE_node.hh:492
#define GEO_NODE_GREASE_PENCIL_TO_CURVES
#define NOD_REGISTER_NODE(REGISTER_FUNC)
#define ELEM(...)
constexpr int64_t size() const
Definition BLI_span.hh:256
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
GAttributeReader get() const
bool add(const StringRef name, const AttrDomain domain, const AttrType data_type, const AttributeInit &initializer)
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
GSpanAttributeWriter lookup_for_write_span(StringRef name)
const bke::CurvesGeometry & strokes() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
NodeAttributeFilter get_attribute_filter(const UString output_identifier) const
T extract_input(const UString identifier)
void set_output(const UString identifier, T &&value)
CCL_NAMESPACE_BEGIN struct Options options
#define layer
void gather(const GVArray &src, const IndexMask &indices, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
void node_register_type(bNodeType &ntype)
Definition node.cc:2920
Curves * curves_new_nomain(int points_num, int curves_num)
RealizeInstancesResult realize_instances(bke::GeometrySet geometry_set, const RealizeInstancesOptions &options)
MatBase< float, 4, 4 > float4x4
void geo_node_type_base(bke::bNodeType *ntype, UString idname, const std::optional< int16_t > legacy_type)
const ImplicitSharingInfo * sharing_info
StringRefNull name() const
void set_name(std::string name)
const GreasePencil * get_grease_pencil() const
void copy_bundle_from(const GeometrySet &other)
static constexpr int _180
Definition BKE_node.hh:247
Defines a node type.
Definition BKE_node.hh:265
std::string ui_description
Definition BKE_node.hh:271
NodeGeometryExecFunction geometry_node_execute
Definition BKE_node.hh:385
const char * enum_name_legacy
Definition BKE_node.hh:274
NodeDeclareFunction declare
Definition BKE_node.hh:393
static GeometrySet from_curves(Curves *curves, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
static GeometrySet from_instances(std::unique_ptr< Instances > instances)