Blender V5.3
MOD_grease_pencil_dash.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
9#include "BLI_array_utils.hh"
10#include "BLI_index_range.hh"
11#include "BLI_span.hh"
12#include "BLI_string.hh"
13#include "BLI_string_utf8.hh"
14
15#include "DNA_modifier_types.h"
16
17#include "BKE_curves.hh"
18#include "BKE_geometry_set.hh"
19#include "BKE_grease_pencil.hh"
20#include "BKE_instances.hh"
21#include "BKE_modifier.hh"
22#include "BKE_screen.hh"
23
24#include "BLO_read_write.hh"
25
26#include "UI_interface.hh"
28#include "UI_resources.hh"
29
30#include "BLT_translation.hh"
31
32#include "WM_api.hh"
33#include "WM_types.hh"
34
35#include "RNA_access.hh"
36#include "RNA_prototypes.hh"
37
39#include "MOD_ui_common.hh"
40
42
43namespace blender {
44
45static void init_data(ModifierData *md)
46{
47 auto *dmd = reinterpret_cast<GreasePencilDashModifierData *>(md);
48
50 modifier::greasepencil::init_influence_data(&dmd->influence, false);
51
52 GreasePencilDashModifierSegment *ds = MEM_new<GreasePencilDashModifierSegment>(__func__);
53 STRNCPY_UTF8(ds->name, DATA_("Segment"));
54 dmd->segments_array = ds;
55 dmd->segments_num = 1;
56}
57
58static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
59{
60 const auto *dmd = reinterpret_cast<const GreasePencilDashModifierData *>(md);
61 auto *tmmd = reinterpret_cast<GreasePencilDashModifierData *>(target);
62
64
65 BKE_modifier_copydata_generic(md, target, flag);
66 modifier::greasepencil::copy_influence_data(&dmd->influence, &tmmd->influence, flag);
67
68 tmmd->segments_array = static_cast<GreasePencilDashModifierSegment *>(
69 MEM_dupalloc(dmd->segments_array));
70}
71
72static void free_data(ModifierData *md)
73{
74 auto *dmd = reinterpret_cast<GreasePencilDashModifierData *>(md);
76
77 MEM_SAFE_DELETE(dmd->segments_array);
78}
79
80static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
81{
82 auto *dmd = reinterpret_cast<GreasePencilDashModifierData *>(md);
83 modifier::greasepencil::foreach_influence_ID_link(&dmd->influence, ob, walk, user_data);
84}
85
86static bool is_disabled(const Scene * /*scene*/, ModifierData *md, bool /*use_render_params*/)
87{
88 const auto *dmd = reinterpret_cast<GreasePencilDashModifierData *>(md);
89 /* Enable if at least one segment has non-zero length. */
90 for (const GreasePencilDashModifierSegment &dash_segment : dmd->segments()) {
91 if (dash_segment.dash + dash_segment.gap - 1 > 0) {
92 return false;
93 }
94 }
95 return true;
96}
97
98static int floored_modulo(const int a, const int b)
99{
100 return a - math::floor(float(a) / float(b)) * b;
101}
102
103/* Combined segment info used by all strokes. */
113
115{
116 PatternInfo info;
117 for (const GreasePencilDashModifierSegment &dash_segment : dmd.segments()) {
118 info.length += dash_segment.dash + dash_segment.gap;
119 }
120
121 info.segments.reinitialize(dmd.segments().size());
122 info.cyclic.reinitialize(dmd.segments().size());
123 info.material.reinitialize(dmd.segments().size());
124 info.radius.reinitialize(dmd.segments().size());
125 info.opacity.reinitialize(dmd.segments().size());
126 info.offset = floored_modulo(dmd.dash_offset, info.length);
127
128 /* Store segments as ranges. */
129 IndexRange dash_range(0);
130 IndexRange gap_range(0);
131 for (const int i : dmd.segments().index_range()) {
132 const GreasePencilDashModifierSegment &dash_segment = dmd.segments()[i];
133 dash_range = gap_range.after(dash_segment.dash);
134 gap_range = dash_range.after(dash_segment.gap);
135 info.segments[i] = dash_range;
136 info.cyclic[i] = dash_segment.flag & MOD_GREASE_PENCIL_DASH_USE_CYCLIC;
137 info.material[i] = dash_segment.mat_nr;
138 info.radius[i] = dash_segment.radius;
139 info.opacity[i] = dash_segment.opacity;
140 }
141 return info;
142}
143
144/* Returns the segment covering the given index, including repetitions. */
145static int find_dash_segment(const PatternInfo &pattern_info, const int index)
146{
147 const int repeat = index / pattern_info.length;
148 const int segments_num = pattern_info.segments.size();
149
150 const int local_index = index - repeat * pattern_info.length;
151 for (const int i : pattern_info.segments.index_range().drop_back(1)) {
152 const IndexRange segment = pattern_info.segments[i];
153 const IndexRange next_segment = pattern_info.segments[i + 1];
154 if (local_index >= segment.start() && local_index < next_segment.start()) {
155 return i + repeat * segments_num;
156 }
157 }
158 return segments_num - 1 + repeat * segments_num;
159}
160
166static void foreach_dash(const PatternInfo &pattern_info,
167 const IndexRange src_points,
168 const bool cyclic,
169 FunctionRef<void(IndexRange, bool, int, float, float)> fn)
170{
171 const int points_num = src_points.size();
172 const int segments_num = pattern_info.segments.size();
173
174 const int first_segment = find_dash_segment(pattern_info, pattern_info.offset);
175 const int last_segment = find_dash_segment(pattern_info, pattern_info.offset + points_num - 1);
176 BLI_assert(first_segment < segments_num);
177 BLI_assert(last_segment >= first_segment);
178
179 const IndexRange all_segments = IndexRange(first_segment, last_segment - first_segment + 1);
180 for (const int i : all_segments) {
181 const int repeat = i / segments_num;
182 const int segment_index = i - repeat * segments_num;
183 const IndexRange range = pattern_info.segments[segment_index].shift(repeat *
184 pattern_info.length);
185
186 const int64_t point_shift = src_points.start() - pattern_info.offset;
187 const int64_t min_point = src_points.start();
188 const int64_t max_point = cyclic ? src_points.one_after_last() : src_points.last();
189 const int64_t start = std::clamp(range.start() + point_shift, min_point, max_point);
190 const int64_t end = std::clamp(range.one_after_last() + point_shift, min_point, max_point + 1);
191
192 IndexRange points(start, end - start);
193 if (!points.is_empty()) {
194 fn(points,
195 pattern_info.cyclic[segment_index],
196 pattern_info.material[segment_index],
197 pattern_info.radius[segment_index],
198 pattern_info.opacity[segment_index]);
199 }
200 }
201}
202
204 const bke::CurvesGeometry &src_curves,
205 const IndexMask &curves_mask)
206{
207 const bke::AttributeAccessor src_attributes = src_curves.attributes();
208 const VArray<bool> src_cyclic = src_curves.cyclic();
209 const VArray<int> src_material = *src_attributes.lookup_or_default(
210 "material_index", bke::AttrDomain::Curve, 0);
211 const VArray<float> src_radius = *src_attributes.lookup_or_default<float>(
212 "radius", bke::AttrDomain::Point, 0.01f);
213 const VArray<float> src_opacity = *src_attributes.lookup_or_default<float>(
214 "opacity", bke::AttrDomain::Point, 1.0f);
215 const VArray<int> src_fill_ids = *src_attributes.lookup_or_default<int>(
216 "fill_id", bke::AttrDomain::Curve, 0);
217
218 /* Count new curves and points. */
219 int dst_point_num = 0;
220 int dst_curve_num = 0;
221 curves_mask.foreach_index([&](const int64_t src_curve_i) {
222 const IndexRange src_points = src_curves.points_by_curve()[src_curve_i];
223
224 foreach_dash(pattern_info,
225 src_points,
226 src_cyclic[src_curve_i],
227 [&](const IndexRange copy_points,
228 bool /*cyclic*/,
229 int /*material*/,
230 float /*radius*/,
231 float /*opacity*/) {
232 dst_point_num += copy_points.size();
233 dst_curve_num += 1;
234 });
235 });
236
237 bke::CurvesGeometry dst_curves(dst_point_num, dst_curve_num);
238 bke::MutableAttributeAccessor dst_attributes = dst_curves.attributes_for_write();
239 bke::SpanAttributeWriter<bool> dst_cyclic = dst_attributes.lookup_or_add_for_write_span<bool>(
240 "cyclic", bke::AttrDomain::Curve);
241 bke::SpanAttributeWriter<int> dst_fill_ids = dst_attributes.lookup_or_add_for_write_span<int>(
242 "fill_id", bke::AttrDomain::Curve);
243 bke::SpanAttributeWriter<int> dst_material = dst_attributes.lookup_or_add_for_write_span<int>(
244 "material_index", bke::AttrDomain::Curve);
245 bke::SpanAttributeWriter<float> dst_radius = dst_attributes.lookup_or_add_for_write_span<float>(
246 "radius", bke::AttrDomain::Point);
247 bke::SpanAttributeWriter<float> dst_opacity = dst_attributes.lookup_or_add_for_write_span<float>(
248 "opacity", bke::AttrDomain::Point);
249 /* Map each destination point and curve to its source. */
250 Array<int> src_point_indices(dst_point_num);
251 Array<int> src_curve_indices(dst_curve_num);
252
253 /* Start at `1` for the new geometry. */
254 int fill_id_to_set = 1;
255
256 {
257 /* Start at curve offset and add points for each dash. */
258 IndexRange dst_point_range(0);
259 int dst_curve_i = 0;
260 auto add_dash_curve = [&](const int src_curve,
261 const IndexRange src_points,
262 const IndexRange copy_points,
263 bool cyclic,
264 int material,
265 float radius,
266 float opacity) {
267 dst_point_range = dst_point_range.after(copy_points.size());
268 dst_curves.offsets_for_write()[dst_curve_i] = dst_point_range.start();
269
270 if (src_points.contains(copy_points.last())) {
271 array_utils::fill_index_range(src_point_indices.as_mutable_span().slice(dst_point_range),
272 int(copy_points.start()));
273 }
274 else {
275 /* Cyclic curve. */
277 src_point_indices.as_mutable_span().slice(dst_point_range.drop_back(1)),
278 int(copy_points.start()));
279 src_point_indices[dst_point_range.last()] = src_points.first();
280 }
281 src_curve_indices[dst_curve_i] = src_curve;
282 dst_cyclic.span[dst_curve_i] = cyclic;
283 dst_material.span[dst_curve_i] = material >= 0 ? material : src_material[src_curve];
284 for (const int i : dst_point_range) {
285 dst_radius.span[i] = src_radius[src_point_indices[i]] * radius;
286 }
287 if (dst_opacity) {
288 for (const int i : dst_point_range) {
289 dst_opacity.span[i] = src_opacity[src_point_indices[i]] * opacity;
290 }
291 }
292 if (src_fill_ids[src_curve] == 0) {
293 dst_fill_ids.span[dst_curve_i] = 0;
294 }
295 else {
296 dst_fill_ids.span[dst_curve_i] = fill_id_to_set;
297 fill_id_to_set++;
298 }
299
300 ++dst_curve_i;
301 };
302
303 curves_mask.foreach_index([&](const int64_t src_curve_i) {
304 const IndexRange src_points = src_curves.points_by_curve()[src_curve_i];
305 foreach_dash(pattern_info,
306 src_points,
307 src_cyclic[src_curve_i],
308 [&](const IndexRange copy_points,
309 bool cyclic,
310 int material,
311 float radius,
312 float opacity) {
313 add_dash_curve(
314 src_curve_i, src_points, copy_points, cyclic, material, radius, opacity);
315 });
316 });
317 if (dst_curve_i > 0) {
318 /* Last offset entry is total point count. */
319 dst_curves.offsets_for_write()[dst_curve_i] = dst_point_range.one_after_last();
320 }
321 }
322
323 bke::gather_attributes(src_attributes,
326 bke::attribute_filter_from_skip_ref({"radius", "opacity"}),
327 src_point_indices,
328 dst_attributes);
330 src_attributes,
333 bke::attribute_filter_from_skip_ref({"cyclic", "material_index", "fill_id"}),
334 src_curve_indices,
335 dst_attributes);
336
337 dst_cyclic.finish();
338 dst_material.finish();
339 dst_radius.finish();
340 dst_opacity.finish();
341 dst_fill_ids.finish();
342 dst_curves.update_curve_types();
343
344 return dst_curves;
345}
346
348 const ModifierEvalContext &ctx,
349 const PatternInfo &pattern_info,
351{
353 const bke::CurvesGeometry &src_curves = drawing.strokes();
354 if (src_curves.curve_num == 0) {
355 return;
356 }
357 /* Selected source curves. */
358 IndexMaskMemory curve_mask_memory;
360 ctx.object, src_curves, dmd.influence, curve_mask_memory);
361 const IndexMask unselected_mask = curves_mask.complement(src_curves.curves_range(),
362 curve_mask_memory);
364 src_curves, unselected_mask, {});
365
366 bke::CurvesGeometry dashed_curves = create_dashes(pattern_info, src_curves, curves_mask);
367
368 Curves *masked_curves_id = bke::curves_new_nomain(dashed_curves);
369 Curves *unselected_curves_id = bke::curves_new_nomain(unselected_curves);
370 bke::GeometrySet masked_geo = bke::GeometrySet::from_curves(masked_curves_id);
371 bke::GeometrySet unselected_geo = bke::GeometrySet::from_curves(unselected_curves_id);
372 bke::GeometrySet joined_geo = geometry::join_geometries({unselected_geo, masked_geo}, {});
373
374 if (!joined_geo.has_curves()) {
375 drawing.strokes_for_write() = {};
376 }
377 else {
378 drawing.strokes_for_write() = std::move(joined_geo.get_curves_for_write()->geometry.wrap());
379 }
380 drawing.tag_topology_changed();
381}
382
384 const ModifierEvalContext *ctx,
385 bke::GeometrySet *geometry_set)
386{
388
389 auto *dmd = reinterpret_cast<GreasePencilDashModifierData *>(md);
390
391 if (!geometry_set->has_grease_pencil()) {
392 return;
393 }
395 const int frame = grease_pencil.runtime->eval_frame;
396
397 const PatternInfo pattern_info = get_pattern_info(*dmd);
398
399 IndexMaskMemory mask_memory;
401 grease_pencil, dmd->influence, mask_memory);
402
404 grease_pencil, layer_mask, frame);
406 drawings, [&](Drawing *drawing) { modify_drawing(*dmd, *ctx, pattern_info, *drawing); });
407}
408
409static void panel_draw(const bContext *C, Panel *panel)
410{
411 ui::Layout &layout = *panel->layout;
412
413 PointerRNA ob_ptr;
415 auto *dmd = static_cast<GreasePencilDashModifierData *>(ptr->data);
416
417 layout.use_property_split_set(true);
418
419 layout.prop(ptr, "dash_offset", UI_ITEM_NONE, std::nullopt, ICON_NONE);
420
421 ui::Layout &row = layout.row(false);
422 row.use_property_split_set(false);
423
424 template_uilist(&row,
425 const_cast<bContext *>(C),
426 "MOD_UL_grease_pencil_dash_modifier_segments",
427 "",
428 ptr,
429 "segments",
430 ptr,
431 "segment_active_index",
432 nullptr,
433 3,
434 10,
435 0,
437
438 ui::Layout &col = row.column(false);
439 ui::Layout *sub = &col.column(true);
440 sub->op("OBJECT_OT_grease_pencil_dash_modifier_segment_add", "", ICON_ADD);
441 sub->op("OBJECT_OT_grease_pencil_dash_modifier_segment_remove", "", ICON_REMOVE);
442 col.separator();
443 sub = &col.column(true);
444 PointerRNA op_ptr = sub->op(
445 "OBJECT_OT_grease_pencil_dash_modifier_segment_move", "", ICON_TRIA_UP);
446 RNA_enum_set(&op_ptr, "type", /* ed::object::DashSegmentMoveDirection::Up */ -1);
447 op_ptr = sub->op("OBJECT_OT_grease_pencil_dash_modifier_segment_move", "", ICON_TRIA_DOWN);
448 RNA_enum_set(&op_ptr, "type", /* ed::object::DashSegmentMoveDirection::Down */ 1);
449
450 if (dmd->segment_active_index >= 0 && dmd->segment_active_index < dmd->segments_num) {
452 RNA_GreasePencilDashModifierSegment,
453 &dmd->segments()[dmd->segment_active_index]);
454
455 sub = &layout.column(true);
456 sub->prop(&ds_ptr, "dash", UI_ITEM_NONE, std::nullopt, ICON_NONE);
457 sub->prop(&ds_ptr, "gap", UI_ITEM_NONE, std::nullopt, ICON_NONE);
458
459 sub = &layout.column(false);
460 sub->prop(&ds_ptr, "radius", UI_ITEM_NONE, std::nullopt, ICON_NONE);
461 sub->prop(&ds_ptr, "opacity", UI_ITEM_NONE, std::nullopt, ICON_NONE);
462 sub->prop(&ds_ptr, "material_index", UI_ITEM_NONE, std::nullopt, ICON_NONE);
463 sub->prop(&ds_ptr, "use_cyclic", UI_ITEM_NONE, std::nullopt, ICON_NONE);
464 }
465
466 if (ui::Layout *influence_panel = layout.panel_prop(
467 C, ptr, "open_influence_panel", IFACE_("Influence")))
468 {
471 }
472
473 modifier_error_message_draw(layout, ptr);
474}
475
476static void segment_list_item_draw(uiList * /*ui_list*/,
477 const bContext * /*C*/,
478 ui::Layout &layout,
479 PointerRNA * /*idataptr*/,
480 PointerRNA *itemptr,
481 int /*icon*/,
482 PointerRNA * /*active_dataptr*/,
483 const char * /*active_propname*/,
484 int /*index*/,
485 int /*flt_flag*/)
486{
487 ui::Layout &row = layout.row(true);
488 row.prop(itemptr, "name", ui::ITEM_R_NO_BG, "", ICON_NONE);
489}
490
491static void panel_register(ARegionType *region_type)
492{
494
495 uiListType *list_type = MEM_new_zeroed<uiListType>("Grease Pencil Dash modifier segments");
496 STRNCPY(list_type->idname, "MOD_UL_grease_pencil_dash_modifier_segments");
498 WM_uilisttype_add(list_type);
499}
500
501static void blend_write(BlendWriter *writer, const ID * /*id_owner*/, const ModifierData *md)
502{
503 const auto *dmd = reinterpret_cast<const GreasePencilDashModifierData *>(md);
504
505 writer->write_struct(dmd);
506 modifier::greasepencil::write_influence_data(writer, &dmd->influence);
507
508 writer->write_struct_array(dmd->segments_num, dmd->segments_array);
509}
510
511static void blend_read(BlendDataReader *reader, ModifierData *md)
512{
513 auto *dmd = reinterpret_cast<GreasePencilDashModifierData *>(md);
514
515 modifier::greasepencil::read_influence_data(reader, &dmd->influence);
516
517 BLO_read_array_and_validate_size(reader, &dmd->segments_array, &dmd->segments_num);
518}
519
521 /*idname*/ "GreasePencilDash",
522 /*name*/ N_("Dot Dash"),
523 /*struct_name*/ "GreasePencilDashModifierData",
524 /*struct_size*/ sizeof(GreasePencilDashModifierData),
525 /*srna*/ &RNA_GreasePencilDashModifierData,
529 /*icon*/ ICON_MOD_DASH,
530
531 /*copy_data*/ copy_data,
532
533 /*deform_verts*/ nullptr,
534 /*deform_matrices*/ nullptr,
535 /*deform_verts_EM*/ nullptr,
536 /*deform_matrices_EM*/ nullptr,
537 /*modify_mesh*/ nullptr,
538 /*modify_geometry_set*/ modify_geometry_set,
539
540 /*init_data*/ init_data,
541 /*required_data_mask*/ nullptr,
542 /*free_data*/ free_data,
543 /*is_disabled*/ is_disabled,
544 /*update_depsgraph*/ nullptr,
545 /*depends_on_time*/ nullptr,
546 /*depends_on_normals*/ nullptr,
547 /*foreach_ID_link*/ foreach_ID_link,
548 /*foreach_tex_link*/ nullptr,
549 /*free_runtime_data*/ nullptr,
550 /*panel_register*/ panel_register,
551 /*blend_write*/ blend_write,
552 /*blend_read*/ blend_read,
553};
554
555Span<GreasePencilDashModifierSegment> GreasePencilDashModifierData::segments() const
556{
557 return {this->segments_array, this->segments_num};
558}
559
560MutableSpan<GreasePencilDashModifierSegment> GreasePencilDashModifierData::segments()
561{
562 return {this->segments_array, this->segments_num};
563}
564
565} // namespace blender
Low-level operations for curves.
Low-level operations for grease pencil.
#define STRNCPY_UTF8(dst, src)
#define IFACE_(msgid)
#define DATA_(msgid)
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define INIT_DEFAULT_STRUCT_AFTER(struct_dst, member)
void reinitialize(const int64_t new_size)
Definition BLI_array.hh:430
constexpr int64_t one_after_last() const
constexpr IndexRange drop_back(int64_t n) const
constexpr int64_t last(const int64_t n=0) const
constexpr int64_t size() const
constexpr bool is_empty() const
constexpr IndexRange()=default
constexpr IndexRange after(int64_t n) const
constexpr int64_t start() const
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
VArray< bool > cyclic() const
AttributeAccessor attributes() const
IndexRange curves_range() const
MutableSpan< int > offsets_for_write()
OffsetIndices< int > points_by_curve() const
MutableAttributeAccessor attributes_for_write()
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
bke::CurvesGeometry & strokes_for_write()
const bke::CurvesGeometry & strokes() const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
IndexMask complement(const IndexMask &universe, LinearAllocator<> &memory) const
void fill_index_range(MutableSpan< T > span, const T start=0)
CurvesGeometry curves_copy_curve_selection(const CurvesGeometry &curves, const IndexMask &curves_to_copy, const AttributeFilter &attribute_filter)
auto attribute_filter_from_skip_ref(const Span< StringRef > skip)
void gather_attributes(AttributeAccessor src_attributes, AttrDomain src_domain, AttrDomain dst_domain, const AttributeFilter &attribute_filter, const IndexMask &selection, MutableAttributeAccessor dst_attributes)
Curves * curves_new_nomain(int points_num, int curves_num)
bke::GeometrySet join_geometries(Span< bke::GeometrySet > geometries, const bke::AttributeFilter &attribute_filter, const std::optional< Span< bke::GeometryComponent::Type > > &component_types_to_join=std::nullopt, bool allow_merging_instance_references=true)
T floor(const T &a)
void read_influence_data(BlendDataReader *reader, GreasePencilModifierInfluenceData *influence_data)
void draw_material_filter_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
void init_influence_data(GreasePencilModifierInfluenceData *influence_data, const bool has_custom_curve)
void write_influence_data(BlendWriter *writer, const GreasePencilModifierInfluenceData *influence_data)
void draw_layer_filter_settings(const bContext *, ui::Layout &layout, PointerRNA *ptr)
IndexMask get_filtered_layer_mask(const GreasePencil &grease_pencil, const GreasePencilModifierInfluenceData &influence_data, IndexMaskMemory &memory)
Vector< bke::greasepencil::Drawing * > get_drawings_for_write(GreasePencil &grease_pencil, const IndexMask &layer_mask, const int frame)
IndexMask get_filtered_stroke_mask(const Object *ob, const bke::CurvesGeometry &curves, const GreasePencilModifierInfluenceData &influence_data, IndexMaskMemory &memory)
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_each(Range &&range, const Function &function)
Definition BLI_task.hh:31
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static int floored_modulo(const int a, const int b)
static void copy_data(const ModifierData *md, ModifierData *target, const int flag)
__int64 int64_t
Definition BKE_text.h:90
char * STRNCPY(char(&dst)[N], const char *src)
static void blend_write(BlendWriter *writer, const ID *, const ModifierData *md)
Definition MOD_bevel.cc:454
PointerRNA * modifier_panel_get_property_pointers(Panel *panel, PointerRNA *r_ob_ptr)
@ eModifierType_GreasePencilDash
static void init_data(ModifierData *md)
void(*)(void *user_data, Object *ob, ID **idpoin, LibraryForeachIDCallbackFlag cb_flag) IDWalkFunc
static void foreach_ID_link(ModifierData *md, Object *ob, IDWalkFunc walk, void *user_data)
void RNA_enum_set(PointerRNA *ptr, const char *name, int value)
static void modify_geometry_set(ModifierData *md, const ModifierEvalContext *ctx, bke::GeometrySet *geometry_set)
void modifier_error_message_draw(ui::Layout &layout, PointerRNA *ptr)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
static void free_data(ModifierData *md)
static void segment_list_item_draw(uiList *, const bContext *, ui::Layout &layout, PointerRNA *, PointerRNA *itemptr, int, PointerRNA *, const char *, int, int)
static void panel_register(ARegionType *region_type)
static void foreach_dash(const PatternInfo &pattern_info, const IndexRange src_points, const bool cyclic, FunctionRef< void(IndexRange, bool, int, float, float)> fn)
static bke::CurvesGeometry create_dashes(const PatternInfo &pattern_info, const bke::CurvesGeometry &src_curves, const IndexMask &curves_mask)
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
@ eModifierTypeFlag_SupportsMapping
@ eModifierTypeFlag_AcceptsGreasePencil
@ eModifierTypeFlag_EnableInEditmode
@ eModifierTypeFlag_SupportsEditmode
static void modify_drawing(const GreasePencilArrayModifierData &mmd, const ModifierEvalContext &ctx, bke::greasepencil::Drawing &drawing)
void BLO_read_array_and_validate_size(BlendDataReader *reader, T **ptr_p, SizeT *array_size, const int elems=1)
static void blend_read(BlendDataReader *, ModifierData *md)
ModifierTypeInfo modifierType_GreasePencilDash
bool WM_uilisttype_add(uiListType *ult)
PanelType * modifier_panel_register(ARegionType *region_type, ModifierType type, PanelDrawFn draw)
static void panel_draw(const bContext *, Panel *panel)
static int find_dash_segment(const PatternInfo &pattern_info, const int index)
static PatternInfo get_pattern_info(const GreasePencilDashModifierData &dmd)
static bool is_disabled(const Scene *, ModifierData *md, bool)
@ MOD_GREASE_PENCIL_DASH_USE_CYCLIC
void BKE_modifier_copydata_generic(const ModifierData *md, ModifierData *md_dst, int flag)
void write_struct(const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
void write_struct_array(const int64_t array_size, const T *data, BlendStructWriterTypedFn< T > fn=nullptr)
GreasePencilDashModifierSegment * segments_array
GreasePencilModifierInfluenceData influence
ui::Layout * layout
static GeometrySet from_curves(Curves *curves, GeometryOwnershipType ownership=GeometryOwnershipType::Owned)
GreasePencil * get_grease_pencil_for_write()
char idname[BKE_ST_MAXNAME]
uiListDrawItemFunc draw_item
void use_property_split_set(bool is_sep)
PointerRNA op(wmOperatorType *ot, std::optional< StringRef > name, int icon, wm::OpCallContext context, eUI_Item_Flag flag)
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)
Layout & column(bool align)
void separator(float factor=1.0f, LayoutSeparatorType type=LayoutSeparatorType::Auto)
PanelLayout panel_prop(const bContext *C, PointerRNA *open_prop_owner, StringRefNull open_prop_name)
Layout & row(bool align)
#define N_(msgid)