Blender V5.3
grease_pencil_frames.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <algorithm>
10
11#include "BKE_curves.hh"
12
13#include "BLI_listbase.hh"
14#include "BLI_map.hh"
16#include "BLI_utildefines.hh"
17
18#include "BKE_context.hh"
19#include "BKE_grease_pencil.hh"
20#include "BKE_paint.hh"
21
22#include "DEG_depsgraph.hh"
23
24#include "DNA_scene_types.h"
25
26#include "ANIM_keyframing.hh"
27
28#include "ED_anim_api.hh"
29#include "ED_grease_pencil.hh"
30#include "ED_keyframes_edit.hh"
31#include "ED_markers.hh"
32
33#include "RNA_access.hh"
34#include "RNA_define.hh"
35
36#include "WM_api.hh"
37
38namespace blender {
39
40namespace ed::greasepencil {
41
43 const eBezTriple_KeyframeType key_type)
44{
45 for (GreasePencilFrame &frame : layer.frames_for_write().values()) {
46 if (frame.is_selected()) {
47 frame.type = key_type;
48 layer.tag_frames_map_changed();
49 }
50 }
51}
52
53static float get_snapped_frame_number(const float frame_number,
54 Scene &scene,
55 const eEditKeyframes_Snap mode)
56{
57 switch (mode) {
58 case SNAP_KEYS_CURFRAME: /* Snap to current frame. */
59 return scene.r.cfra;
60 case SNAP_KEYS_NEARSEC: /* Snap to nearest second. */
61 {
62 float secf = (scene.r.frs_sec / scene.r.frs_sec_base);
63 return floorf(frame_number / secf + 0.5f) * secf;
64 }
65 case SNAP_KEYS_NEARMARKER: /* Snap to nearest marker. */
66 return ED_markers_find_nearest_marker_time(&scene.markers, frame_number);
67 default:
68 break;
69 }
70 return frame_number;
71}
72
75 Scene &scene,
76 const eEditKeyframes_Snap mode)
77{
78 bool changed = false;
79 Map<int, int> frame_number_destinations;
80 for (auto [frame_number, frame] : layer.frames().items()) {
81 if (!frame.is_selected()) {
82 continue;
83 }
84 const int snapped = round_fl_to_int(
85 get_snapped_frame_number(float(frame_number), scene, mode));
86 if (snapped != frame_number) {
87 frame_number_destinations.add(frame_number, snapped);
88 changed = true;
89 }
90 }
91
92 if (changed) {
93 grease_pencil.move_frames(layer, frame_number_destinations);
94 }
95
96 return changed;
97}
98
99static int get_mirrored_frame_number(const int frame_number,
100 const Scene &scene,
101 const eEditKeyframes_Mirror mode,
102 const TimeMarker *first_selected_marker)
103{
104 switch (mode) {
105 case MIRROR_KEYS_CURFRAME: /* Mirror over current frame. */
106 return 2 * scene.r.cfra - frame_number;
108 case MIRROR_KEYS_YAXIS: /* Mirror over frame 0. */
109 return -frame_number;
110 case MIRROR_KEYS_MARKER: /* Mirror over marker. */
111 if (first_selected_marker == nullptr) {
112 break;
113 }
114 return 2 * first_selected_marker->frame - frame_number;
115 default:
116 break;
117 }
118 return frame_number;
119}
120
123 Scene &scene,
124 const eEditKeyframes_Mirror mode)
125{
126 bool changed = false;
127 Map<int, int> frame_number_destinations;
128
129 /* Pre-compute the first selected marker, so that we don't compute it for each frame. */
130 const TimeMarker *first_selected_marker = (mode == MIRROR_KEYS_MARKER) ?
132 nullptr;
133
134 for (auto [frame_number, frame] : layer.frames().items()) {
135 if (!frame.is_selected()) {
136 continue;
137 }
138
139 const int mirrored_frame_number = get_mirrored_frame_number(
140 frame_number, scene, mode, first_selected_marker);
141
142 if (mirrored_frame_number != frame_number) {
143 frame_number_destinations.add(frame_number, mirrored_frame_number);
144 changed = true;
145 }
146 }
147
148 if (changed) {
149 grease_pencil.move_frames(layer, frame_number_destinations);
150 }
151
152 return changed;
153}
154
156{
157 using namespace bke::greasepencil;
158 bool changed = false;
159 LayerTransformData &trans_data = layer.runtime->trans_data_;
160
161 for (auto [frame_number, frame] : layer.frames_for_write().items()) {
162 if (!frame.is_selected()) {
163 continue;
164 }
165
166 /* Create the duplicate drawing. */
167 const Drawing *drawing = grease_pencil.get_editable_drawing_at(layer, frame_number);
168 if (drawing == nullptr) {
169 continue;
170 }
171 const int duplicated_drawing_index = grease_pencil.drawings().size();
172 grease_pencil.add_duplicate_drawings(1, *drawing);
173
174 /* Make a copy of the frame in the duplicates. */
175 GreasePencilFrame frame_duplicate = frame;
176 frame_duplicate.drawing_index = duplicated_drawing_index;
177 trans_data.duplicated_frames_buffer.add_overwrite(frame_number, frame_duplicate);
178
179 /* Deselect the current frame, so that only the copy is selected. */
180 frame.flag ^= GP_FRAME_SELECTED;
181
182 changed = true;
183 }
184
185 if (changed) {
186 layer.tag_frames_map_changed();
187 }
188
189 return changed;
190}
191
193{
194 Vector<int> frames_to_remove;
195 for (auto [frame_number, frame] : layer.frames().items()) {
196 if (!frame.is_selected()) {
197 continue;
198 }
199 frames_to_remove.append(frame_number);
200 }
201 return grease_pencil.remove_frames(layer, frames_to_remove.as_span());
202}
203
204static void select_frame(GreasePencilFrame &frame, const short select_mode)
205{
206 switch (select_mode) {
207 case SELECT_ADD:
208 frame.flag |= GP_FRAME_SELECTED;
209 break;
210 case SELECT_SUBTRACT:
211 frame.flag &= ~GP_FRAME_SELECTED;
212 break;
213 case SELECT_INVERT:
214 frame.flag ^= GP_FRAME_SELECTED;
215 break;
216 }
217}
218
220 const int frame_number,
221 const short select_mode)
222{
223
224 GreasePencilFrame *frame = layer.frames_for_write().lookup_ptr(frame_number);
225 if (frame == nullptr) {
226 return false;
227 }
228 select_frame(*frame, select_mode);
229 layer.tag_frames_map_changed();
230 return true;
231}
232
234 const int frame_number,
235 const short select_mode)
236{
237 for (GreasePencilLayerTreeNode &node_ : layer_group.children.items_reversed()) {
238 bke::greasepencil::TreeNode &node = node_.wrap();
239 if (node.is_group()) {
240 select_frames_at(node.as_group(), frame_number, select_mode);
241 }
242 else if (node.is_layer()) {
243 select_frame_at(node.as_layer(), frame_number, select_mode);
244 }
245 }
246}
247
248void select_all_frames(bke::greasepencil::Layer &layer, const short select_mode)
249{
250 for (auto item : layer.frames_for_write().items()) {
251 select_frame(item.value, select_mode);
252 layer.tag_frames_map_changed();
253 }
254}
255
257{
258 for (const auto &[frame_number, frame] : layer.frames().items()) {
259 if (frame.is_selected()) {
260 return true;
261 }
262 }
263 return false;
264}
265
268 const short tool,
269 const short select_mode)
270{
271 if (node.is_layer()) {
272 for (auto [frame_number, frame] : node.as_layer().frames_for_write().items()) {
273 /* Construct a dummy point coordinate to do this testing with. */
274 const float2 pt(float(frame_number), ked->channel_y);
275
276 /* Check the necessary regions. */
277 if (tool == BEZT_OK_CHANNEL_LASSO) {
278 if (keyframe_region_lasso_test(static_cast<const KeyframeEdit_LassoData *>(ked->data), pt))
279 {
280 select_frame(frame, select_mode);
281 }
282 }
283 else if (tool == BEZT_OK_CHANNEL_CIRCLE) {
284 if (keyframe_region_circle_test(static_cast<const KeyframeEdit_CircleData *>(ked->data),
285 pt))
286 {
287 select_frame(frame, select_mode);
288 }
289 }
290
291 node.as_layer().tag_frames_map_changed();
292 }
293 }
294 else if (node.is_group()) {
295 for (GreasePencilLayerTreeNode &node_ : node.as_group().children.items_reversed()) {
296 select_frames_region(ked, node_.wrap(), tool, select_mode);
297 }
298 }
299}
300
302 const float min,
303 const float max,
304 const short select_mode)
305{
306 /* Only select those frames which are in bounds. */
307 if (node.is_layer()) {
308 for (auto [frame_number, frame] : node.as_layer().frames_for_write().items()) {
309 if (IN_RANGE(float(frame_number), min, max)) {
310 select_frame(frame, select_mode);
311 node.as_layer().tag_frames_map_changed();
312 }
313 }
314 }
315 else if (node.is_group()) {
316 for (GreasePencilLayerTreeNode &node_ : node.as_group().children.items_reversed()) {
317 select_frames_range(node_.wrap(), min, max, select_mode);
318 }
319 }
320}
321
323 const int frame_number,
324 const GreasePencilFrame &frame)
325{
326 CfraElem *ce = MEM_new_zeroed<CfraElem>(__func__);
327 ce->cfra = float(frame_number);
328 ce->sel = frame.is_selected();
329 BLI_addtail(&ked->cfra_elem_list, ce);
330}
331
334{
335 BLI_assert(ked != nullptr);
336
337 for (const auto &[frame_number, frame] : layer.frames().items()) {
338 if (frame.is_selected()) {
339 append_frame_to_key_edit_data(ked, frame_number, frame);
340 }
341 }
342}
343
347 const bool duplicate_previous_key,
348 bool &r_inserted_keyframe)
349{
350 const int current_frame = scene.r.cfra;
351 if (!layer.has_drawing_at(current_frame) && !animrig::is_autokey_on(&scene)) {
352 return false;
353 }
354
355 /* If auto-key is on and the drawing at the current frame starts before the current frame a new
356 * keyframe needs to be inserted. */
357 const bool is_first = layer.is_empty() || (layer.sorted_keys().first() > current_frame);
358 const std::optional<int> previous_key_frame_start = layer.start_frame_at(current_frame);
359 const bool has_previous_key = previous_key_frame_start.has_value();
360 const bool needs_new_drawing = is_first || !has_previous_key ||
361 (previous_key_frame_start < current_frame);
362 if (animrig::is_autokey_on(&scene) && needs_new_drawing) {
363 const bool use_additive_drawing = (scene.toolsettings->gpencil_flags &
365 if (has_previous_key && (use_additive_drawing || duplicate_previous_key)) {
366 /* We duplicate the frame that's currently visible and insert it at the current frame. */
367 grease_pencil.insert_duplicate_frame(layer, *previous_key_frame_start, current_frame, false);
368 }
369 else {
370 /* Otherwise we just insert a blank keyframe at the current frame. */
371 grease_pencil.insert_frame(layer, current_frame);
372 }
373 r_inserted_keyframe = true;
374 }
375 /* There should now always be a drawing at the current frame. */
376 BLI_assert(layer.has_drawing_at(current_frame));
377 return true;
378}
379
381{
382 using namespace blender::bke::greasepencil;
383 Scene *scene = CTX_data_scene(C);
385 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(object->data);
386 const int current_frame = scene->r.cfra;
387 const bool all_layers = RNA_boolean_get(op->ptr, "all_layers");
388 const int duration = 0 /* RNA_int_get(op->ptr, "duration") */;
389
390 bool changed = false;
391 if (all_layers) {
392 for (Layer *layer : grease_pencil.layers_for_write()) {
393 if (!layer->is_editable()) {
394 continue;
395 }
396 changed |= grease_pencil.insert_frame(*layer, current_frame, duration) != nullptr;
397 }
398 }
399 else {
400 if (!grease_pencil.has_active_layer()) {
401 return OPERATOR_CANCELLED;
402 }
403 changed |= grease_pencil.insert_frame(
404 *grease_pencil.get_active_layer(), current_frame, duration) != nullptr;
405 }
406
407 if (changed) {
411 }
412
413 return OPERATOR_FINISHED;
414}
415
417 const bke::GAttributeReader &attrs_b)
418{
419 return (attrs_a.varray.size() != attrs_b.varray.size() ||
420 attrs_a.varray.type() != attrs_b.varray.type());
421}
422
424 const bke::GAttributeReader &attrs_b)
425{
426 if (attrs_a.varray.is_span() && attrs_b.varray.is_span()) {
427 const GSpan attrs_span_a = attrs_a.varray.get_internal_span();
428 const GSpan attrs_span_b = attrs_b.varray.get_internal_span();
429
430 if (attrs_span_a.data() == attrs_span_b.data()) {
431 return true;
432 }
433 }
434
435 return false;
436}
437
438template<typename T>
439static bool attributes_elements_are_equal(const VArray<T> &attributes_a,
440 const VArray<T> &attributes_b)
441{
442 const std::optional<T> value_a = attributes_a.get_if_single();
443 const std::optional<T> value_b = attributes_b.get_if_single();
444 if (value_a.has_value() && value_b.has_value()) {
445 return value_a.value() == value_b.value();
446 }
447
448 const VArraySpan attrs_span_a = attributes_a;
449 const VArraySpan attrs_span_b = attributes_b;
450
451 return std::equal(
452 attrs_span_a.begin(), attrs_span_a.end(), attrs_span_b.begin(), attrs_span_b.end());
453}
454
456 const bke::CurvesGeometry &curves_b)
457{
458 using namespace blender::bke;
459
460 if (curves_a.is_empty() && curves_b.is_empty()) {
461 return true;
462 }
463
464 if (curves_a.curves_num() != curves_b.curves_num() ||
465 curves_a.points_num() != curves_b.points_num() || curves_a.offsets() != curves_b.offsets())
466 {
467 return false;
468 }
469
470 const AttributeAccessor attributes_a = curves_a.attributes();
471 const AttributeAccessor attributes_b = curves_b.attributes();
472
473 const Set<StringRefNull> names_a = attributes_a.all_names();
474 const Set<StringRefNull> names_b = attributes_b.all_names();
475 if (names_a != names_b) {
476 return false;
477 }
478
479 for (const StringRef name : names_a) {
480 GAttributeReader attrs_a = attributes_a.lookup(name);
481 GAttributeReader attrs_b = attributes_b.lookup(name);
482
483 if (attributes_varrays_not_equal(attrs_a, attrs_b)) {
484 return false;
485 }
486
487 if (attributes_varrays_span_data_equal(attrs_a, attrs_b)) {
488 continue;
489 }
490
491 bool attributes_are_equal = true;
492
493 attribute_math::to_static_type(attrs_a.varray.type(), [&]<typename T>() {
494 const VArray attributes_a = attrs_a.varray.typed<T>();
495 const VArray attributes_b = attrs_b.varray.typed<T>();
496
497 attributes_are_equal = attributes_elements_are_equal(attributes_a, attributes_b);
498 });
499
500 if (!attributes_are_equal) {
501 return false;
502 }
503 }
504
505 return true;
506}
507
509{
510 using namespace blender::bke::greasepencil;
512 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(object->data);
513 const bool selected = RNA_boolean_get(op->ptr, "selected");
514
515 bool changed = false;
516
517 for (Layer *layer : grease_pencil.layers_for_write()) {
518 if (!layer->is_editable()) {
519 continue;
520 }
521
522 Vector<int> start_frame_numbers;
523 for (const FramesMapKeyT key : layer->sorted_keys()) {
524 const GreasePencilFrame *frame = layer->frames().lookup_ptr(key);
525 if (selected && !frame->is_selected()) {
526 continue;
527 }
528 if (frame->is_end()) {
529 continue;
530 }
531 start_frame_numbers.append(int(key));
532 }
533
534 Vector<int> frame_numbers_to_delete;
535 for (const int i : start_frame_numbers.index_range().drop_back(1)) {
536 const int current = start_frame_numbers[i];
537 const int next = start_frame_numbers[i + 1];
538
539 Drawing *drawing = grease_pencil.get_drawing_at(*layer, current);
540 Drawing *drawing_next = grease_pencil.get_drawing_at(*layer, next);
541
542 if (!drawing || !drawing_next) {
543 continue;
544 }
545
547 bke::CurvesGeometry &curves_next = drawing_next->strokes_for_write();
548
549 if (!curves_geometry_is_equal(curves, curves_next)) {
550 continue;
551 }
552
553 frame_numbers_to_delete.append(next);
554 }
555
556 grease_pencil.remove_frames(*layer, frame_numbers_to_delete.as_span());
557
558 changed = true;
559 }
560
561 if (changed) {
565 }
566
567 return OPERATOR_FINISHED;
568}
569
571{
572 PropertyRNA *prop;
573
574 /* identifiers */
575 ot->name = "Insert Blank Frame";
576 ot->idname = "GREASE_PENCIL_OT_insert_blank_frame";
577 ot->description = "Insert a blank frame on the current scene frame";
578
579 /* callbacks */
582
584
585 /* properties */
586 prop = RNA_def_boolean(
587 ot->srna, "all_layers", false, "All Layers", "Insert a blank frame in all editable layers");
589 prop = RNA_def_int(ot->srna,
590 "duration",
591 0,
592 0,
593 MAXFRAME,
594 "Duration",
595 "WARNING: Has no effect currently, always behaves as if its value was `0`",
596 0,
597 100);
599}
600
602{
603 PropertyRNA *prop;
604
605 /* identifiers */
606 ot->name = "Delete Duplicate Frames";
607 ot->idname = "GREASE_PENCIL_OT_frame_clean_duplicate";
608 ot->description = "Remove any keyframe that is a duplicate of the previous one";
609
610 /* callbacks */
613
615
616 /* properties */
617 prop = RNA_def_boolean(
618 ot->srna, "selected", false, "Selected", "Only delete selected keyframes");
620}
621
623{
624 using namespace bke::greasepencil;
625
626 /* Clear buffer first. */
627 clipboard.clear();
628
629 /* Filter data. */
631 ListBaseT<bAnimListElem> anim_data = {nullptr, nullptr};
632
634 ac, &anim_data, eAnimFilter_Flags(filter), ac->data, eAnimCont_Types(ac->datatype));
635
636 for (bAnimListElem &ale : anim_data) {
637 /* This function only deals with grease pencil layer frames.
638 * This check is needed in the case of a call from the main dope-sheet. */
639 if (ale.type != ANIMTYPE_GREASE_PENCIL_LAYER) {
640 continue;
641 }
642
643 GreasePencil *grease_pencil = reinterpret_cast<GreasePencil *>(ale.id);
644 Layer *layer = reinterpret_cast<Layer *>(ale.data);
646 FramesMapKeyT layer_first_frame = std::numeric_limits<int>::max();
647 FramesMapKeyT layer_last_frame = std::numeric_limits<int>::min();
648 for (auto [frame_number, frame] : layer->frames().items()) {
649 if (frame.is_selected()) {
650 const Drawing *drawing = grease_pencil->get_drawing_at(*layer, frame_number);
651 const int duration = 0 /* layer->get_frame_duration_at(frame_number) */;
652 buf.append(
653 {frame_number, Drawing(*drawing), duration, eBezTriple_KeyframeType(frame.type)});
654
655 /* Check the range of this layer only. */
656 layer_first_frame = std::min(frame_number, layer_first_frame);
657 layer_last_frame = std::max(frame_number, layer_last_frame);
658 }
659 }
660 if (!buf.is_empty()) {
661 BLI_assert(!clipboard.copy_buffer.contains(layer->name()));
662 clipboard.copy_buffer.add_new(layer->name(), {buf, layer_first_frame, layer_last_frame});
663 /* Update the range of entire copy buffer. */
664 clipboard.first_frame = std::min(layer_first_frame, clipboard.first_frame);
665 clipboard.last_frame = std::max(layer_last_frame, clipboard.last_frame);
666 }
667 }
668
669 /* In case 'relative' paste method is used. */
670 clipboard.cfra = ac->scene->r.cfra;
671
672 /* Clean up. */
673 ANIM_animdata_freelist(&anim_data);
674
675 /* If nothing ended up in the buffer, copy failed. */
676 return !clipboard.copy_buffer.is_empty();
677}
678
679static int calculate_offset(const eKeyPasteOffset offset_mode,
680 const int cfra,
681 const KeyframeClipboard &clipboard)
682{
683 int offset = 0;
684 switch (offset_mode) {
686 offset = (cfra - clipboard.first_frame);
687 break;
689 offset = (cfra - clipboard.last_frame);
690 break;
692 offset = (cfra - clipboard.cfra);
693 break;
695 offset = 0;
696 break;
697 }
698 return offset;
699}
700
702 const eKeyPasteOffset offset_mode,
703 const eKeyMergeMode merge_mode,
704 const KeyframeClipboard &clipboard)
705{
706 using namespace bke::greasepencil;
707
708 /* Check if buffer is empty. */
709 if (clipboard.copy_buffer.is_empty()) {
710 return false;
711 }
712
713 const int offset = calculate_offset(offset_mode, ac->scene->r.cfra, clipboard);
714
715 /* Check if single channel in buffer (disregard names if so). */
716 const bool from_single_channel = clipboard.copy_buffer.size() == 1;
717 bool match_names = !from_single_channel;
718
719 ListBaseT<bAnimListElem> anim_data = {nullptr, nullptr};
720 /* Only paste into selected layers. */
724 ac, &anim_data, eAnimFilter_Flags(filter), ac->data, eAnimCont_Types(ac->datatype));
725 if (anim_data.is_empty()) {
726 /* If no layers are selected at all, make even unselected layers "targets" for pasting. */
730 ac, &anim_data, eAnimFilter_Flags(filter), ac->data, eAnimCont_Types(ac->datatype));
731 /* In this case, always match names though (otherwise we would paste from a single channel into
732 * all others). */
733 match_names = true;
734 }
735
736 for (bAnimListElem &ale : anim_data) {
737 /* Only deal with GPlayers (case of calls from general dope-sheet). */
738 if (ale.type != ANIMTYPE_GREASE_PENCIL_LAYER) {
739 continue;
740 }
741 GreasePencil *grease_pencil = reinterpret_cast<GreasePencil *>(ale.id);
742 Layer &layer = *reinterpret_cast<Layer *>(ale.data);
743 const std::string layer_name = layer.name();
744 if (match_names && !clipboard.copy_buffer.contains(layer_name)) {
745 continue;
746 }
747 const KeyframeClipboard::LayerBufferItem layer_buffer =
748 from_single_channel ? *clipboard.copy_buffer.values().begin() :
749 clipboard.copy_buffer.lookup(layer_name);
750 bool changed = false;
751
752 /* Mix mode with existing data. */
753 switch (merge_mode) {
755 /* Do nothing. */
756 break;
757
759 /* Remove all keys. */
760 Vector<int> frames_to_remove;
761 for (auto frame_number : layer.frames().keys()) {
762 frames_to_remove.append(frame_number);
763 }
764 grease_pencil->remove_frames(layer, frames_to_remove);
765 changed = true;
766 break;
767 }
770 int frame_min, frame_max;
771
772 if (merge_mode == KEYFRAME_PASTE_MERGE_OVER_RANGE) {
773 /* Entire range of this layer. */
774 frame_min = layer_buffer.first_frame + offset;
775 frame_max = layer_buffer.last_frame + offset;
776 }
777 else {
778 /* Entire range of all copied keys. */
779 frame_min = clipboard.first_frame + offset;
780 frame_max = clipboard.last_frame + offset;
781 }
782
783 /* Remove keys in range. */
784 if (frame_min < frame_max) {
785 Vector<int> frames_to_remove;
786 for (auto frame_number : layer.frames().keys()) {
787 if (frame_min < frame_number && frame_number < frame_max) {
788 frames_to_remove.append(frame_number);
789 }
790 }
791 grease_pencil->remove_frames(layer, frames_to_remove);
792 changed = true;
793 }
794 break;
795 }
796 }
797 for (const KeyframeClipboard::DrawingBufferItem &item : layer_buffer.drawing_buffers) {
798 const int target_frame_number = item.frame_number + offset;
799 if (layer.frames().contains(target_frame_number)) {
800 grease_pencil->remove_frames(layer, {target_frame_number});
801 }
802 Drawing &dst_drawing = *grease_pencil->insert_frame(
803 layer, target_frame_number, item.duration, item.keytype);
804 dst_drawing = item.drawing;
805 changed = true;
806 }
807
808 if (changed) {
810 }
811 }
812
813 /* Clean up. */
814 ANIM_animdata_freelist(&anim_data);
815
816 return true;
817}
818
820{
821 using namespace blender::bke::greasepencil;
822 Scene *scene = CTX_data_scene(C);
824 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(object->data);
825 const bool only_active = !RNA_boolean_get(op->ptr, "all");
826 const int current_frame = scene->r.cfra;
827 bool changed = false;
828
829 auto insert_duplicate_frame = [&](Layer &layer, std::optional<int> active_frame_number) {
830 if (!active_frame_number.has_value()) {
831 return false;
832 }
833 return grease_pencil.insert_duplicate_frame(
834 layer, active_frame_number.value(), current_frame, false);
835 };
836
837 if (only_active) {
838 if (!grease_pencil.has_active_layer()) {
839 return OPERATOR_CANCELLED;
840 }
841 Layer &active_layer = *grease_pencil.get_active_layer();
842 const std::optional<int> active_frame_number = active_layer.start_frame_at(current_frame);
843 changed |= insert_duplicate_frame(active_layer, active_frame_number);
844 }
845 else {
846 for (Layer *layer : grease_pencil.layers_for_write()) {
847 const std::optional<int> active_frame_number = layer->start_frame_at(current_frame);
848 changed |= insert_duplicate_frame(*layer, active_frame_number);
849 }
850 }
851
852 if (!changed) {
853 return OPERATOR_CANCELLED;
854 }
855
858
859 return OPERATOR_FINISHED;
860}
861
863{
864 /* identifiers */
865 ot->name = "Duplicate Active Frame(s)";
866 ot->idname = "GREASE_PENCIL_OT_frame_duplicate";
867 ot->description = "Make a copy of the active Grease Pencil frame(s)";
868
869 /* callback */
872
873 /* flags */
875
877 ot->srna, "all", false, "Duplicate all", "Duplicate active keyframes of all layer");
878}
879
881{
882 using namespace blender::bke::greasepencil;
883 Scene *scene = CTX_data_scene(C);
885 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(object->data);
886 const bool only_active = !RNA_boolean_get(op->ptr, "all");
887 const int current_frame = scene->r.cfra;
888 bool changed = false;
889
890 if (only_active) {
891 Layer *active_layer = grease_pencil.get_active_layer();
892 if ((active_layer == nullptr) || active_layer->is_locked()) {
893 return OPERATOR_CANCELLED;
894 }
895 if (std::optional<int> active_frame_number = active_layer->start_frame_at(current_frame)) {
896 changed |= grease_pencil.remove_frames(*active_layer, {active_frame_number.value()});
897 }
898 }
899 else {
900 for (Layer *layer : grease_pencil.layers_for_write()) {
901 if (layer->is_locked()) {
902 continue;
903 }
904 if (std::optional<int> active_frame_number = layer->start_frame_at(current_frame)) {
905 changed |= grease_pencil.remove_frames(*layer, {active_frame_number.value()});
906 }
907 }
908 }
909
910 if (!changed) {
911 return OPERATOR_CANCELLED;
912 }
913
916
917 return OPERATOR_FINISHED;
918}
919
921{
922 /* identifiers */
923 ot->name = "Delete Active Frame(s)";
924 ot->idname = "GREASE_PENCIL_OT_active_frame_delete";
925 ot->description = "Delete the active Grease Pencil frame(s)";
926
927 /* callback */
930
931 /* flags */
933
934 RNA_def_boolean(ot->srna, "all", false, "Delete all", "Delete active keyframes of all layers");
935}
936
938{
940 return false;
941 }
942 const Object &ob = *CTX_data_active_object(C);
943 const Scene &scene = *CTX_data_scene(C);
944
945 /* Ensure that there is a breakdown keyframe visible at the current frame. */
946 const GreasePencil &grease_pencil = *id_cast<GreasePencil *>(ob.data);
947 if (const bke::greasepencil::Layer *active_layer = grease_pencil.get_active_layer()) {
948 const GreasePencilFrame *frame = active_layer->frame_at(scene.r.cfra);
949 if (frame && frame->type == BEZT_KEYTYPE_BREAKDOWN) {
950 return true;
951 }
952 }
953 return false;
954}
955
957 wmOperator * /*op*/)
958{
959 const Object &ob = *CTX_data_active_object(C);
960 const Scene &scene = *CTX_data_scene(C);
961 GreasePencil &grease_pencil = *id_cast<GreasePencil *>(ob.data);
962 bke::greasepencil::Layer *active_layer = grease_pencil.get_active_layer();
963 const int current_frame = active_layer->start_frame_at(scene.r.cfra).value();
964
965 const Span<int> sorted_keys = active_layer->sorted_keys();
966 const int curr_frame_index = sorted_keys.first_index(current_frame);
967 Vector<int> frame_numbers_to_remove;
968
969 for (int i = curr_frame_index; i <= sorted_keys.size(); i++) {
970 int frame_number = sorted_keys[i];
971 GreasePencilFrame *frame = active_layer->frame_at(frame_number);
972 if (frame && frame->type == BEZT_KEYTYPE_BREAKDOWN) {
973 frame_numbers_to_remove.append(frame_number);
974 continue;
975 }
976 break;
977 }
978 for (int i = curr_frame_index - 1; i >= 0; i--) {
979 int frame_number = sorted_keys[i];
980 GreasePencilFrame *frame = active_layer->frame_at(frame_number);
981 if (frame && frame->type == BEZT_KEYTYPE_BREAKDOWN) {
982 frame_numbers_to_remove.append(frame_number);
983 continue;
984 }
985 break;
986 }
987
988 if (frame_numbers_to_remove.is_empty()) {
989 return OPERATOR_CANCELLED;
990 }
991
992 grease_pencil.remove_frames(*active_layer, frame_numbers_to_remove);
993
996
997 return OPERATOR_FINISHED;
998}
999
1001{
1002 /* identifiers */
1003 ot->name = "Delete Breakdown Frames";
1004 ot->idname = "GREASE_PENCIL_OT_delete_breakdown";
1005 ot->description =
1006 "Remove breakdown frames generated by interpolating between two Grease Pencil frames";
1007
1008 /* callback */
1011
1012 /* flags */
1014}
1015
1016} // namespace ed::greasepencil
1017
1027
1028} // namespace blender
Functions to insert, delete or modify keyframes.
Low-level operations for curves.
Low-level operations for grease pencil.
#define MAXFRAME
#define C
Definition RandGen.cpp:29
#define NC_GEOM
Definition WM_types.hh:406
#define ND_DATA
Definition WM_types.hh:552
#define NA_EDITED
Definition WM_types.hh:634
#define NC_GPENCIL
Definition WM_types.hh:412
#define IN_RANGE(a, b, c)
btScalar max
const void * data() const
constexpr IndexRange drop_back(int64_t n) const
bool add(const Key &key, const Value &value)
Definition BLI_map.hh:295
constexpr int64_t first_index(const T &search_value) const
Definition BLI_span.hh:381
constexpr int64_t size() const
Definition BLI_span.hh:256
std::optional< T > get_if_single() const
void append(const T &value)
bool is_empty() const
IndexRange index_range() const
Span< T > as_span() const
Set< StringRefNull > all_names() const
GAttributeReader lookup(const StringRef name) const
AttributeAccessor attributes() const
bke::CurvesGeometry & strokes_for_write()
const GreasePencilFrame * frame_at(const int frame_number) const
std::optional< int > start_frame_at(int frame_number) const
Span< FramesMapKeyT > sorted_keys() const
constexpr const T * begin() const
constexpr const T * end() const
#define layer
#define T
bool is_autokey_on(const Scene *scene)
void to_static_type(const CPPType &cpp_type, Fn &&fn)
void select_frames_at(bke::greasepencil::LayerGroup &layer_group, const int frame_number, const short select_mode)
bool active_grease_pencil_poll(bContext *C)
static void GREASE_PENCIL_OT_active_frame_delete(wmOperatorType *ot)
bool remove_all_selected_frames(GreasePencil &grease_pencil, bke::greasepencil::Layer &layer)
bool grease_pencil_copy_keyframes(bAnimContext *ac, KeyframeClipboard &clipboard)
bool grease_pencil_paste_keyframes(bAnimContext *ac, const eKeyPasteOffset offset_mode, const eKeyMergeMode merge_mode, const KeyframeClipboard &clipboard)
bool ensure_active_keyframe(const Scene &scene, GreasePencil &grease_pencil, bke::greasepencil::Layer &layer, const bool duplicate_previous_key, bool &r_inserted_keyframe)
static wmOperatorStatus grease_pencil_delete_breakdown_frames_exec(bContext *C, wmOperator *)
static wmOperatorStatus frame_clean_duplicate_exec(bContext *C, wmOperator *op)
static float get_snapped_frame_number(const float frame_number, Scene &scene, const eEditKeyframes_Snap mode)
static wmOperatorStatus insert_blank_frame_exec(bContext *C, wmOperator *op)
void set_selected_frames_type(bke::greasepencil::Layer &layer, const eBezTriple_KeyframeType key_type)
static wmOperatorStatus grease_pencil_frame_duplicate_exec(bContext *C, wmOperator *op)
bool mirror_selected_frames(GreasePencil &grease_pencil, bke::greasepencil::Layer &layer, Scene &scene, const eEditKeyframes_Mirror mode)
void select_frames_range(bke::greasepencil::TreeNode &node, const float min, const float max, const short select_mode)
static bool curves_geometry_is_equal(const bke::CurvesGeometry &curves_a, const bke::CurvesGeometry &curves_b)
static int get_mirrored_frame_number(const int frame_number, const Scene &scene, const eEditKeyframes_Mirror mode, const TimeMarker *first_selected_marker)
static void select_frame(GreasePencilFrame &frame, const short select_mode)
void create_keyframe_edit_data_selected_frames_list(KeyframeEditData *ked, const bke::greasepencil::Layer &layer)
void select_frames_region(KeyframeEditData *ked, bke::greasepencil::TreeNode &node, const short tool, const short select_mode)
bool has_any_frame_selected(const bke::greasepencil::Layer &layer)
static bool attributes_varrays_not_equal(const bke::GAttributeReader &attrs_a, const bke::GAttributeReader &attrs_b)
static void GREASE_PENCIL_OT_frame_clean_duplicate(wmOperatorType *ot)
static bool attributes_elements_are_equal(const VArray< T > &attributes_a, const VArray< T > &attributes_b)
bool editable_grease_pencil_poll(bContext *C)
void select_all_frames(bke::greasepencil::Layer &layer, const short select_mode)
static void append_frame_to_key_edit_data(KeyframeEditData *ked, const int frame_number, const GreasePencilFrame &frame)
static void GREASE_PENCIL_OT_insert_blank_frame(wmOperatorType *ot)
static void GREASE_PENCIL_OT_frame_duplicate(wmOperatorType *ot)
bool duplicate_selected_frames(GreasePencil &grease_pencil, bke::greasepencil::Layer &layer)
static int calculate_offset(const eKeyPasteOffset offset_mode, const int cfra, const KeyframeClipboard &clipboard)
static wmOperatorStatus grease_pencil_active_frame_delete_exec(bContext *C, wmOperator *op)
static bool grease_pencil_active_breakdown_frame_poll(bContext *C)
static void GREASE_PENCIL_OT_delete_breakdown(wmOperatorType *ot)
static bool attributes_varrays_span_data_equal(const bke::GAttributeReader &attrs_a, const bke::GAttributeReader &attrs_b)
bool select_frame_at(bke::greasepencil::Layer &layer, const int frame_number, const short select_mode)
bool snap_selected_frames(GreasePencil &grease_pencil, bke::greasepencil::Layer &layer, Scene &scene, const eEditKeyframes_Snap mode)
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ BEZT_KEYTYPE_BREAKDOWN
void WM_operatortype_append(void(*opfunc)(wmOperatorType *))
MINLINE int round_fl_to_int(float a)
void ED_operatortypes_grease_pencil_frames()
@ ANIMTYPE_GREASE_PENCIL_LAYER
@ KEYFRAME_PASTE_MERGE_OVER_RANGE_ALL
@ KEYFRAME_PASTE_MERGE_OVER_RANGE
@ KEYFRAME_PASTE_OFFSET_CFRA_START
@ KEYFRAME_PASTE_OFFSET_CFRA_RELATIVE
@ KEYFRAME_PASTE_OFFSET_CFRA_END
bool keyframe_region_lasso_test(const KeyframeEdit_LassoData *data_lasso, const float xy[2])
@ GP_TOOL_FLAG_RETAIN_LAST
VecBase< float, 2 > float2
size_t ANIM_animdata_filter(bAnimContext *ac, ListBaseT< bAnimListElem > *anim_data, const eAnimFilter_Flags filter_mode, void *data, const eAnimCont_Types datatype)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
@ ANIMFILTER_FOREDIT
@ ANIMFILTER_LIST_VISIBLE
@ ANIMFILTER_DATA_VISIBLE
@ ANIMFILTER_NODUPLIS
void DEG_id_tag_update(ID *id, unsigned int flags)
TimeMarker * ED_markers_get_first_selected(ListBaseT< TimeMarker > *markers)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, const int default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
bool keyframe_region_circle_test(const KeyframeEdit_CircleData *data_circle, const float xy[2])
int ED_markers_find_nearest_marker_time(ListBaseT< TimeMarker > *markers, float x)
void ANIM_animdata_freelist(ListBaseT< bAnimListElem > *anim_data)
Definition anim_deps.cc:472
@ ID_RECALC_GEOMETRY
Definition DNA_ID.h:1074
@ PROP_SKIP_SAVE
Definition RNA_types.hh:414
@ PROP_HIDDEN
Definition RNA_types.hh:408
Scene * CTX_data_scene(const bContext *C)
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
Object * CTX_data_active_object(const bContext *C)
#define floorf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
#define min(a, b)
Definition sort.cc:38
ListBaseT< GreasePencilLayerTreeNode > children
ListBaseT< CfraElem > cfra_elem_list
ListBaseT< TimeMarker > markers
struct RenderData r
struct ToolSettings * toolsettings
eGPencil_Flags gpencil_flags
eAnimCont_Types datatype
Map< int, GreasePencilFrame > duplicated_frames_buffer
Map< std::string, LayerBufferItem > copy_buffer
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165