Blender V5.3
MOD_grease_pencil_util.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
8
10
11#include "BLI_set.hh"
12#include "BLI_vector_set.hh"
13
14#include "DNA_color_types.h"
16#include "DNA_material_types.h"
17#include "DNA_modifier_types.h"
18
19#include "BKE_colortools.hh"
20#include "BKE_curves.hh"
21#include "BKE_grease_pencil.hh"
22#include "BKE_lib_query.hh"
23#include "BKE_material.hh"
24
25#include "BLT_translation.hh"
26
27#include "BLO_read_write.hh"
28
29#include "RNA_access.hh"
30#include "RNA_prototypes.hh"
31
32#include "UI_interface.hh"
34
36
38
43
45 const bool has_custom_curve)
46{
47 if (has_custom_curve) {
48 influence_data->custom_curve = BKE_curvemapping_add(1, 0.0f, 0.0f, 1.0f, 1.0f);
49 BKE_curvemapping_init(influence_data->custom_curve);
50 }
51}
52
54 GreasePencilModifierInfluenceData *influence_data_dst,
55 const int /*flag*/)
56{
57 memcpy(influence_data_dst, influence_data_src, sizeof(GreasePencilModifierInfluenceData));
58 influence_data_dst->custom_curve = BKE_curvemapping_copy(influence_data_src->custom_curve);
59}
60
62{
63 if (influence_data->custom_curve) {
64 BKE_curvemapping_free(influence_data->custom_curve);
65 influence_data->custom_curve = nullptr;
66 }
67}
68
70 Object *ob,
71 IDWalkFunc walk,
72 void *user_data)
73{
74 walk(user_data, ob, reinterpret_cast<ID **>(&influence_data->material), IDWALK_CB_USER);
75}
76
78 const GreasePencilModifierInfluenceData *influence_data)
79{
80 if (influence_data->custom_curve) {
81 BKE_curvemapping_blend_write(writer, influence_data->custom_curve);
82 }
83}
84
87{
88 BLO_read_struct(reader, CurveMapping, &influence_data->custom_curve);
89 if (influence_data->custom_curve) {
90 BKE_curvemapping_blend_read(reader, influence_data->custom_curve);
91 /* Make sure the internal table exists. */
92 BKE_curvemapping_init(influence_data->custom_curve);
93 }
94}
95
96void draw_layer_filter_settings(const bContext * /*C*/, ui::Layout &layout, PointerRNA *ptr)
97{
98 PointerRNA ob_ptr = RNA_pointer_create_discrete(ptr->owner_id, RNA_Object, ptr->owner_id);
99 PointerRNA obj_data_ptr = RNA_pointer_get(&ob_ptr, "data");
100 const bool use_layer_pass = RNA_boolean_get(ptr, "use_layer_pass_filter");
101 const bool use_layer_group_filter = RNA_boolean_get(ptr, "use_layer_group_filter");
102
103 layout.use_property_split_set(true);
104
105 ui::Layout &col = layout.column(true);
106 ui::Layout *row = &col.row(true);
107 row->use_property_decorate_set(false);
108 if (use_layer_group_filter) {
109 row->prop_search(ptr,
110 "tree_node_filter",
111 &obj_data_ptr,
112 "layer_groups",
113 IFACE_("Group"),
114 ICON_GREASEPENCIL_LAYER_GROUP);
115 }
116 else {
117 row->prop_search(ptr,
118 "tree_node_filter",
119 &obj_data_ptr,
120 "layers",
121 std::nullopt,
122 ICON_OUTLINER_DATA_GP_LAYER);
123 }
124 ui::Layout *sub = &row->row(true);
125 sub->prop(ptr, "use_layer_group_filter", UI_ITEM_NONE, "", ICON_GREASEPENCIL_LAYER_GROUP);
126 sub->prop(ptr, "invert_layer_filter", UI_ITEM_NONE, "", ICON_ARROW_LEFTRIGHT);
127
128 row = &col.row(true, IFACE_("Layer Pass"));
129 row->use_property_decorate_set(false);
130 sub = &row->row(true);
131 sub->prop(ptr, "use_layer_pass_filter", UI_ITEM_NONE, "", ICON_NONE);
132 ui::Layout &subsub = sub->row(true);
133 subsub.active_set(use_layer_pass);
134 subsub.prop(ptr, "layer_pass_filter", UI_ITEM_NONE, "", ICON_NONE);
135 subsub.prop(ptr, "invert_layer_pass_filter", UI_ITEM_NONE, "", ICON_ARROW_LEFTRIGHT);
136}
137
139{
140 PointerRNA ob_ptr = RNA_pointer_create_discrete(ptr->owner_id, RNA_Object, ptr->owner_id);
141 PointerRNA obj_data_ptr = RNA_pointer_get(&ob_ptr, "data");
142 const bool use_material_pass = RNA_boolean_get(ptr, "use_material_pass_filter");
143
144 layout.use_property_split_set(true);
145
146 ui::Layout &col = layout.column(true);
147 ui::Layout *row = &col.row(true);
148 row->use_property_decorate_set(false);
149 row->prop_search(
150 ptr, "material_filter", &obj_data_ptr, "materials", std::nullopt, ICON_SHADING_TEXTURE);
151 ui::Layout *sub = &row->row(true);
152 sub->prop(ptr, "invert_material_filter", UI_ITEM_NONE, "", ICON_ARROW_LEFTRIGHT);
153
154 row = &col.row(true, IFACE_("Material Pass"));
155 row->use_property_decorate_set(false);
156 sub = &row->row(true);
157 sub->prop(ptr, "use_material_pass_filter", UI_ITEM_NONE, "", ICON_NONE);
158 ui::Layout &subsub = sub->row(true);
159 subsub.active_set(use_material_pass);
160 subsub.prop(ptr, "material_pass_filter", UI_ITEM_NONE, "", ICON_NONE);
161 subsub.prop(ptr, "invert_material_pass_filter", UI_ITEM_NONE, "", ICON_ARROW_LEFTRIGHT);
162}
163
165{
166 PointerRNA ob_ptr = RNA_pointer_create_discrete(ptr->owner_id, RNA_Object, ptr->owner_id);
167 bool has_vertex_group = RNA_string_length(ptr, "vertex_group_name") != 0;
168
169 layout.use_property_split_set(true);
170
171 ui::Layout &col = layout.column(true);
172 ui::Layout &row = col.row(true);
173 row.use_property_decorate_set(false);
174 row.prop_search(ptr, "vertex_group_name", &ob_ptr, "vertex_groups", std::nullopt, ICON_NONE);
175 ui::Layout &sub = row.row(true);
176 sub.active_set(has_vertex_group);
177 sub.use_property_decorate_set(false);
178 sub.prop(ptr, "invert_vertex_group", UI_ITEM_NONE, "", ICON_ARROW_LEFTRIGHT);
179}
180
182{
183 bool use_custom_curve = RNA_boolean_get(ptr, "use_custom_curve");
184
185 layout.use_property_split_set(true);
186 ui::Layout &row = layout.row(true);
187 row.use_property_decorate_set(false);
188 row.prop(ptr, "use_custom_curve", UI_ITEM_NONE, IFACE_("Custom Curve"), ICON_NONE);
189 if (use_custom_curve) {
190 template_curve_mapping(&layout, ptr, "custom_curve", 0, false, false, false, false, false);
191 }
192}
193
200{
201 short *totcol = BKE_object_material_len_p(const_cast<Object *>(ob));
202 Vector<int> result(*totcol, 0);
203 for (short i = 0; i < *totcol; i++) {
204 const Material *ma = BKE_object_material_get(const_cast<Object *>(ob), i + 1);
205 if (ma) {
206 /* Pass index of the grease pencil material. */
207 result[i] = ma->gp_style->index;
208 }
209 }
210 return result;
211}
212
214 const std::optional<StringRef> tree_node_name_filter,
215 const std::optional<int> layer_pass_filter,
216 const bool layer_filter_invert,
217 const bool layer_pass_filter_invert,
218 IndexMaskMemory &memory)
219{
220 const IndexMask full_mask = grease_pencil.layers().index_range();
221 if (!tree_node_name_filter && !layer_pass_filter) {
222 return full_mask;
223 }
224
225 bke::AttributeAccessor layer_attributes = grease_pencil.attributes();
226 const Span<const Layer *> layers = grease_pencil.layers();
227 const VArray<int> layer_passes =
228 layer_attributes.lookup_or_default<int>("pass_index", bke::AttrDomain::Layer, 0).varray;
229
230 const LayerGroup *filter_layer_group = nullptr;
231 if (tree_node_name_filter) {
232 for (const LayerGroup *group : grease_pencil.layer_groups()) {
233 if (group->name() == tree_node_name_filter.value()) {
234 filter_layer_group = group;
235 break;
236 }
237 }
238 }
239
240 IndexMask result = IndexMask::from_predicate(full_mask, memory, [&](const int64_t layer_i) {
241 if (tree_node_name_filter) {
242 const Layer *layer = layers[layer_i];
243 if (filter_layer_group) {
244 const bool match = layer->is_child_of(*filter_layer_group);
245 if (match == layer_filter_invert) {
246 return false;
247 }
248 }
249 else {
250 const bool match = (layer->name() == tree_node_name_filter.value());
251 if (match == layer_filter_invert) {
252 return false;
253 }
254 }
255 }
256 if (layer_pass_filter) {
257 const int layer_pass = layer_passes.get(layer_i);
258 const bool match = (layer_pass == layer_pass_filter.value());
259 if (match == layer_pass_filter_invert) {
260 return false;
261 }
262 }
263 return true;
264 });
265 return result;
266}
267
269 const GreasePencilModifierInfluenceData &influence_data,
270 IndexMaskMemory &memory)
271{
274 influence_data.layer_name[0] != '\0' ?
275 std::make_optional<StringRef>(influence_data.layer_name) :
276 std::nullopt,
278 std::make_optional<int>(influence_data.layer_pass) :
279 std::nullopt,
282 memory);
283}
284
287 const Material *material_filter,
288 const std::optional<int> material_pass_filter,
289 const bool material_filter_invert,
290 const bool material_pass_filter_invert,
291 IndexMaskMemory &memory)
292{
293 const IndexMask full_mask = curves.curves_range();
294 if (!material_filter && !material_pass_filter) {
295 return full_mask;
296 }
297
298 const int material_filter_index = BKE_object_material_index_get(
299 const_cast<Object *>(ob), const_cast<Material *>(material_filter));
300 const Vector<int> material_pass_by_index = get_grease_pencil_material_passes(ob);
301
302 bke::AttributeAccessor attributes = curves.attributes();
303 VArray<int> stroke_materials =
304 attributes.lookup_or_default<int>("material_index", bke::AttrDomain::Curve, 0).varray;
305
306 IndexMask result = IndexMask::from_predicate(full_mask, memory, [&](const int64_t stroke_i) {
307 const int material_index = stroke_materials.get(stroke_i);
308 if (material_filter != nullptr) {
309 const bool match = (material_index == material_filter_index);
310 if (match == material_filter_invert) {
311 return false;
312 }
313 }
314 if (material_pass_filter) {
315 const int material_pass = material_pass_by_index[material_index];
316 const bool match = (material_pass == material_pass_filter.value());
317 if (match == material_pass_filter_invert) {
318 return false;
319 }
320 }
321 return true;
322 });
323 return result;
324}
325
328 const GreasePencilModifierInfluenceData &influence_data,
329 IndexMaskMemory &memory)
330{
332 ob,
333 curves,
334 influence_data.material,
336 std::make_optional<int>(influence_data.material_pass) :
337 std::nullopt,
340 memory);
341}
342
344 const GreasePencilModifierInfluenceData &influence_data)
345{
346 if (influence_data.vertex_group_name[0] == '\0') {
347 /* If vertex group is not set, use full weight for all vertices. */
348 return VArray<float>::from_single(1.0f, curves.point_num);
349 }
350 /* Vertex group weights, with zero weight as a fallback. */
351 VArray<float> influence_weights = *curves.attributes().lookup_or_default<float>(
352 influence_data.vertex_group_name, bke::AttrDomain::Point, 0.0f);
353
355 Array<float> influence_weights_inverted(influence_weights.size());
357 influence_weights_inverted.index_range(), 8192, [&](const IndexRange range) {
358 for (const int i : range) {
359 influence_weights_inverted[i] = 1.0f - influence_weights[i];
360 }
361 });
362 return VArray<float>::from_container(influence_weights_inverted);
363 }
364
365 return influence_weights;
366}
367
369 const IndexMask &layer_mask,
370 const int frame)
371{
372 using namespace blender::bke::greasepencil;
373 VectorSet<Drawing *> drawings;
374 layer_mask.foreach_index([&](const int64_t layer_i) {
375 const Layer &layer = grease_pencil.layer(layer_i);
376 /* Set of owned drawings, ignore drawing references to other data blocks. */
377 if (Drawing *drawing = grease_pencil.get_drawing_at(layer, frame)) {
378 drawings.add(drawing);
379 }
380 });
381 return Vector<Drawing *>(drawings.as_span());
382}
383
385 const IndexMask &layer_mask,
386 const int frame)
387{
388 using namespace blender::bke::greasepencil;
389 Set<Drawing *> drawings;
390 Vector<LayerDrawingInfo> drawing_infos;
391 layer_mask.foreach_index([&](const int64_t layer_i) {
392 const Layer &layer = grease_pencil.layer(layer_i);
393 Drawing *drawing = grease_pencil.get_drawing_at(layer, frame);
394 if (drawing == nullptr) {
395 return;
396 }
397
398 if (!drawings.contains(drawing)) {
399 drawings.add_new(drawing);
400 drawing_infos.append({drawing, int(layer_i)});
401 }
402 });
403 return drawing_infos;
404}
405
407 const IndexMask &layer_mask,
408 const int frame)
409{
410 using namespace blender::bke::greasepencil;
411 Set<Drawing *> drawings;
412 Vector<FrameDrawingInfo> drawing_infos;
413 layer_mask.foreach_index([&](const int64_t layer_i) {
414 const Layer &layer = grease_pencil.layer(layer_i);
415 const std::optional<int> start_frame = layer.start_frame_at(frame);
416 if (!start_frame) {
417 return;
418 }
419 Drawing *drawing = grease_pencil.get_drawing_at(layer, *start_frame);
420 if (drawing == nullptr) {
421 return;
422 }
423
424 if (!drawings.contains(drawing)) {
425 drawings.add_new(drawing);
426 drawing_infos.append({drawing, *start_frame});
427 }
428 });
429 return drawing_infos;
430}
431
433{
434 const bke::CurvesGeometry &curves = drawing.strokes();
435 IndexMaskMemory memory;
436 const IndexMask bezier_selection = curves.indices_for_curve_type(CURVE_TYPE_BEZIER, memory);
437 if (bezier_selection.is_empty()) {
438 return;
439 }
440 drawing.strokes_for_write() = geometry::resample_to_evaluated(curves, bezier_selection);
441 drawing.tag_topology_changed();
442}
443
444} // namespace blender::modifier::greasepencil
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
#define BLO_read_struct(reader, struct_name, ptr_p)
#define IFACE_(msgid)
#define UI_ITEM_NONE
IndexRange index_range() const
Definition BLI_array.hh:371
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
bool contains(const Key &key) const
Definition BLI_set.hh:310
void add_new(const Key &key)
Definition BLI_set.hh:233
T get(const int64_t index) const
static VArray from_single(T value, const int64_t size)
static VArray from_container(ContainerT container)
bool add(const Key &key)
Span< Key > as_span() const
void append(const T &value)
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
#define layer
CurvesGeometry resample_to_evaluated(const CurvesGeometry &src_curves, const IndexMask &selection, const ResampleCurvesOutputAttributeIDs &output_ids={})
void read_influence_data(BlendDataReader *reader, GreasePencilModifierInfluenceData *influence_data)
void draw_custom_curve_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
void draw_material_filter_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
void init_influence_data(GreasePencilModifierInfluenceData *influence_data, const bool has_custom_curve)
Vector< LayerDrawingInfo > get_drawing_infos_by_layer(GreasePencil &grease_pencil, const IndexMask &layer_mask, const int frame)
Vector< FrameDrawingInfo > get_drawing_infos_by_frame(GreasePencil &grease_pencil, const IndexMask &layer_mask, const int frame)
static IndexMask get_filtered_stroke_mask(const Object *ob, const bke::CurvesGeometry &curves, const Material *material_filter, const std::optional< int > material_pass_filter, const bool material_filter_invert, const bool material_pass_filter_invert, IndexMaskMemory &memory)
void write_influence_data(BlendWriter *writer, const GreasePencilModifierInfluenceData *influence_data)
void draw_layer_filter_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
VArray< float > get_influence_vertex_weights(const bke::CurvesGeometry &curves, const GreasePencilModifierInfluenceData &influence_data)
static IndexMask get_filtered_layer_mask(const GreasePencil &grease_pencil, const std::optional< StringRef > tree_node_name_filter, const std::optional< int > layer_pass_filter, const bool layer_filter_invert, const bool layer_pass_filter_invert, IndexMaskMemory &memory)
Vector< bke::greasepencil::Drawing * > get_drawings_for_write(GreasePencil &grease_pencil, const IndexMask &layer_mask, const int frame)
static Vector< int > get_grease_pencil_material_passes(const Object *ob)
void draw_vertex_group_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
void free_influence_data(GreasePencilModifierInfluenceData *influence_data)
void foreach_influence_ID_link(GreasePencilModifierInfluenceData *influence_data, Object *ob, IDWalkFunc walk, void *user_data)
void copy_influence_data(const GreasePencilModifierInfluenceData *influence_data_src, GreasePencilModifierInfluenceData *influence_data_dst, const int)
void ensure_no_bezier_curves(Drawing &drawing)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
CurveMapping * BKE_curvemapping_add(int tot, float minx, float miny, float maxx, float maxy)
Definition colortools.cc:99
__int64 int64_t
Definition BKE_text.h:90
CurveMapping * BKE_curvemapping_copy(const CurveMapping *cumap)
short * BKE_object_material_len_p(Object *ob)
Material * BKE_object_material_get(Object *ob, short act)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
void BKE_curvemapping_blend_write(BlendWriter *writer, const CurveMapping *cumap)
@ GREASE_PENCIL_INFLUENCE_INVERT_MATERIAL_PASS_FILTER
@ GREASE_PENCIL_INFLUENCE_USE_LAYER_PASS_FILTER
@ GREASE_PENCIL_INFLUENCE_INVERT_LAYER_FILTER
@ GREASE_PENCIL_INFLUENCE_INVERT_MATERIAL_FILTER
@ GREASE_PENCIL_INFLUENCE_USE_MATERIAL_PASS_FILTER
@ GREASE_PENCIL_INFLUENCE_INVERT_VERTEX_GROUP
@ GREASE_PENCIL_INFLUENCE_INVERT_LAYER_PASS_FILTER
void BKE_curvemapping_free(CurveMapping *cumap)
void BKE_curvemapping_init(CurveMapping *cumap)
void BKE_curvemapping_blend_read(BlendDataReader *reader, CurveMapping *cumap)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
int BKE_object_material_index_get(Object *ob, const Material *ma)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
int RNA_string_length(PointerRNA *ptr, const char *name)
GreasePencilModifierInfluenceFlag flag
void prop_search(PointerRNA *ptr, PropertyRNA *prop, PointerRNA *searchptr, PropertyRNA *searchprop, PropertyRNA *item_searchpropname, std::optional< StringRefNull > name, int icon, bool results_are_suggestions)
void use_property_decorate_set(bool is_decorate)
void use_property_split_set(bool is_sep)
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)
void active_set(bool active)
Layout & column(bool align)
Layout & row(bool align)