Blender V5.3
grease_pencil_test.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
5#include "testing/testing.h"
6
7#include "BLI_string.hh"
8
9#include "BKE_curves.hh"
10#include "BKE_grease_pencil.hh"
12#include "BKE_gtest_base.hh"
13#include "BKE_idtype.hh"
14#include "BKE_lib_id.hh"
15#include "BKE_main.hh"
16
17namespace blender {
18
19using namespace blender::bke::greasepencil;
20
22
23/* --------------------------------------------------------------------------------------------- */
24/* Grease Pencil ID Tests. */
25
26/* NOTE: Using a struct with constructor and destructor instead of a fixture here, to have all the
27 * tests in the same group (`greasepencil`). */
28
30
43
44TEST_F(GreasePencilTest, create_grease_pencil_id)
45{
47
49 EXPECT_EQ(grease_pencil.drawings().size(), 0);
50 EXPECT_EQ(grease_pencil.root_group().num_nodes_total(), 0);
51}
52
53/* --------------------------------------------------------------------------------------------- */
54/* Drawing Array Tests. */
55
56TEST_F(GreasePencilTest, add_empty_drawings)
57{
60 grease_pencil.add_empty_drawings(3);
61 EXPECT_EQ(grease_pencil.drawings().size(), 3);
62}
63
64TEST_F(GreasePencilTest, remove_drawings)
65{
68 grease_pencil.add_empty_drawings(3);
69
70 GreasePencilDrawing *drawing = reinterpret_cast<GreasePencilDrawing *>(grease_pencil.drawing(1));
71 drawing->wrap().strokes_for_write().resize(0, 10);
72
73 Layer &layer1 = grease_pencil.add_layer("Layer1");
74 Layer &layer2 = grease_pencil.add_layer("Layer2");
75
76 layer1.add_frame(0)->drawing_index = 0;
77 layer1.add_frame(10)->drawing_index = 1;
78 layer1.add_frame(20)->drawing_index = 2;
79
80 layer2.add_frame(0)->drawing_index = 1;
81 drawing->wrap().add_user();
82
83 grease_pencil.remove_frames(layer1, {10});
84 grease_pencil.remove_frames(layer2, {0});
85 EXPECT_EQ(grease_pencil.drawings().size(), 2);
86
87 static int expected_frames_size[] = {2, 0};
88 static int expected_frames_pairs_layer0[][2] = {{0, 0}, {20, 1}};
89
90 Span<const Layer *> layers = grease_pencil.layers();
91 EXPECT_EQ(layers[0]->frames().size(), expected_frames_size[0]);
92 EXPECT_EQ(layers[1]->frames().size(), expected_frames_size[1]);
93 EXPECT_EQ(layers[0]->frames().lookup(expected_frames_pairs_layer0[0][0]).drawing_index,
94 expected_frames_pairs_layer0[0][1]);
95 EXPECT_EQ(layers[0]->frames().lookup(expected_frames_pairs_layer0[1][0]).drawing_index,
96 expected_frames_pairs_layer0[1][1]);
97}
98
99TEST_F(GreasePencilTest, remove_drawings_last_unused)
100{
102
103 /* Regression test for #129900: unused drawing at the end causes crash. */
104
105 grease_pencil->add_empty_drawings(2);
106 reinterpret_cast<const GreasePencilDrawing *>(grease_pencil->drawing(0))->wrap().remove_user();
107 reinterpret_cast<const GreasePencilDrawing *>(grease_pencil->drawing(1))->wrap().remove_user();
108
109 Layer &layer_a = grease_pencil->add_layer("LayerA");
110 layer_a.add_frame(10)->drawing_index = 0;
111 const GreasePencilDrawingBase *used_drawing = grease_pencil->drawings()[0];
112 grease_pencil->update_drawing_users_for_layer(layer_a);
113
114 EXPECT_EQ(layer_a.frames().size(), 1);
115 EXPECT_EQ(layer_a.frames().lookup(10).drawing_index, 0);
116 /* Test DNA storage data too. */
117 layer_a.prepare_for_dna_write();
118 EXPECT_EQ(layer_a.frames_storage.num, 1);
120
121 grease_pencil->remove_drawings_with_no_users();
122 EXPECT_EQ(grease_pencil->drawings().size(), 1);
123 EXPECT_EQ(grease_pencil->drawings()[0], used_drawing);
124
125 BKE_id_free(nullptr, grease_pencil);
126}
127
128/* --------------------------------------------------------------------------------------------- */
129/* Layer Tree Tests. */
130
133 {
134 this->root_group_ptr = MEM_new<greasepencil::LayerGroup>(__func__);
135 this->active_node = nullptr;
136
137 new (&this->attribute_storage.wrap()) bke::AttributeStorage();
138
139 this->drawing_array = nullptr;
140 this->drawing_array_num = 0;
141
142 this->runtime = MEM_new<GreasePencilRuntime>(__func__);
143 }
144
146 {
147 this->attribute_storage.wrap().~AttributeStorage();
148 MEM_delete(&this->root_group());
149 MEM_delete(this->runtime);
150 this->runtime = nullptr;
151 }
152};
153
154TEST_F(GreasePencilTest, layer_tree_empty)
155{
157 EXPECT_EQ(grease_pencil.root_group().num_nodes_total(), 0);
158}
159
160TEST_F(GreasePencilTest, layer_tree_build_simple)
161{
163
164 LayerGroup &group = grease_pencil.add_layer_group(grease_pencil.root_group(), "Group1");
165 grease_pencil.add_layer(group, "Layer1");
166 grease_pencil.add_layer(group, "Layer2");
167 EXPECT_EQ(grease_pencil.root_group().num_nodes_total(), 3);
168}
169
171 StringRefNull names[7] = {"Group1", "Layer1", "Layer2", "Group2", "Layer3", "Layer4", "Layer5"};
172 const bool is_layer[7] = {false, true, true, false, true, true, true};
174
176 {
177 LayerGroup &group = grease_pencil.add_layer_group(grease_pencil.root_group(), names[0]);
178 grease_pencil.add_layer(group, names[1]);
179 grease_pencil.add_layer(group, names[2]);
180
181 LayerGroup &group2 = grease_pencil.add_layer_group(group, names[3]);
182 grease_pencil.add_layer(group2, names[4]);
183 grease_pencil.add_layer(group2, names[5]);
184
185 grease_pencil.add_layer(names[6]);
186 }
187};
188
189TEST_F(GreasePencilTest, layer_tree_pre_order_iteration)
190{
192
193 Span<const TreeNode *> children = ex.grease_pencil.nodes();
194 for (const int i : children.index_range()) {
195 const TreeNode &child = *children[i];
196 EXPECT_STREQ(child.name().data(), ex.names[i].data());
197 }
198}
199
200TEST_F(GreasePencilTest, layer_tree_pre_order_iteration2)
201{
203
204 Span<const Layer *> layers = ex.grease_pencil.layers();
205 char name[64];
206 for (const int i : layers.index_range()) {
207 const Layer &layer = *layers[i];
208 SNPRINTF(name, "%s%d", "Layer", i + 1);
209 EXPECT_STREQ(layer.name().data(), name);
210 }
211}
212
213TEST_F(GreasePencilTest, layer_tree_total_size)
214{
216 EXPECT_EQ(ex.grease_pencil.root_group().num_nodes_total(), 7);
217}
218
219TEST_F(GreasePencilTest, layer_tree_node_types)
220{
222 Span<const TreeNode *> children = ex.grease_pencil.nodes();
223 for (const int i : children.index_range()) {
224 const TreeNode &child = *children[i];
225 EXPECT_EQ(child.is_layer(), ex.is_layer[i]);
226 EXPECT_EQ(child.is_group(), !ex.is_layer[i]);
227 }
228}
229
230TEST_F(GreasePencilTest, layer_tree_remove_active_node)
231{
233 TreeNode *node = ex.grease_pencil.find_node_by_name("Layer2");
234 ex.grease_pencil.set_active_node(node);
235
236 ex.grease_pencil.remove_layer(node->as_layer());
237 node = ex.grease_pencil.get_active_node();
238 EXPECT_TRUE(node != nullptr);
239 EXPECT_TRUE(node->is_layer());
240 EXPECT_TRUE(node->as_layer().name() == "Layer1");
241
242 ex.grease_pencil.remove_layer(node->as_layer());
243 node = ex.grease_pencil.get_active_node();
244 EXPECT_TRUE(node != nullptr);
245 EXPECT_TRUE(node->is_group());
246 EXPECT_TRUE(node->as_group().name() == "Group2");
247
248 ex.grease_pencil.remove_group(node->as_group());
249 node = ex.grease_pencil.get_active_node();
250 EXPECT_TRUE(node != nullptr);
251 EXPECT_TRUE(node->is_group());
252 EXPECT_TRUE(node->as_group().name() == "Group1");
253
254 ex.grease_pencil.remove_group(node->as_group());
255 node = ex.grease_pencil.get_active_node();
256 EXPECT_TRUE(node != nullptr);
257 EXPECT_TRUE(node->is_layer());
258 EXPECT_TRUE(node->as_layer().name() == "Layer5");
259
260 ex.grease_pencil.remove_layer(node->as_layer());
261 node = ex.grease_pencil.get_active_node();
262 EXPECT_TRUE(node == nullptr);
263}
264
265TEST_F(GreasePencilTest, layer_tree_is_child_of)
266{
268
269 EXPECT_FALSE(ex.grease_pencil.root_group().is_child_of(ex.grease_pencil.root_group()));
270
271 const LayerGroup &group1 = ex.grease_pencil.find_node_by_name("Group1")->as_group();
272 const LayerGroup &group2 = ex.grease_pencil.find_node_by_name("Group2")->as_group();
273 const Layer &layer1 = ex.grease_pencil.find_node_by_name("Layer1")->as_layer();
274 const Layer &layer3 = ex.grease_pencil.find_node_by_name("Layer3")->as_layer();
275 const Layer &layer5 = ex.grease_pencil.find_node_by_name("Layer5")->as_layer();
276
277 EXPECT_TRUE(layer1.is_child_of(ex.grease_pencil.root_group()));
278 EXPECT_TRUE(layer1.is_child_of(group1));
279 EXPECT_TRUE(layer3.is_child_of(group1));
280 EXPECT_FALSE(layer5.is_child_of(group1));
281
282 EXPECT_TRUE(layer3.is_child_of(group2));
283 EXPECT_FALSE(layer1.is_child_of(group2));
284
285 EXPECT_TRUE(layer5.is_child_of(ex.grease_pencil.root_group()));
286}
287
288TEST_F(GreasePencilTest, layer_tree_remove_group)
289{
290 /* Regression test for #130034. */
292 LayerGroup &group1 = grease_pencil.add_layer_group(grease_pencil.root_group(), "Group1");
293 LayerGroup &group2 = grease_pencil.add_layer_group(group1, "Group2");
294 LayerGroup &group3 = grease_pencil.add_layer_group(group2, "Group3");
295 grease_pencil.add_layer(group3, "Layer");
296 grease_pencil.add_layer("Layer2");
297
298 /* Remove Group with children. */
299 grease_pencil.remove_group(group1, false);
300 EXPECT_EQ(grease_pencil.nodes().size(), 1);
301 EXPECT_EQ(grease_pencil.layers().size(), 1);
302 EXPECT_TRUE(grease_pencil.find_node_by_name("Layer2") != nullptr);
303}
304
305/* --------------------------------------------------------------------------------------------- */
306/* Frames Tests. */
307
314 const FramesMapKeyT sorted_keys[5] = {0, 5, 10, 12, 16};
315 GreasePencilFrame sorted_values[5] = {{0}, {1}, {-1}, {2}, {-1}};
317
319 {
320 for (int i = 0; i < 5; i++) {
321 layer.frames_for_write().add(this->sorted_keys[i], this->sorted_values[i]);
322 }
323 /* Mark the first keyframe as an implicit hold. */
324 layer.frame_at(0)->flag |= GP_FRAME_IMPLICIT_HOLD;
325 }
326};
327
329{
331 EXPECT_TRUE(ex.layer.frames().lookup(10).is_end());
332}
333
334TEST_F(GreasePencilTest, frame_is_implicit_hold)
335{
337 EXPECT_TRUE(ex.layer.frames().lookup(0).is_implicit_hold());
338}
339
349
351{
353 EXPECT_FALSE(ex.layer.add_frame(0) != nullptr);
354 ex.layer.add_frame(10)->drawing_index = 3;
358}
359
360/* Frame duration is disabled currently. */
361#if 0
362TEST_F(GreasePencilTest, add_frame_duration_fail)
363{
364 GreasePencilLayerFramesExample ex;
365 EXPECT_FALSE(ex.layer.add_frame(0, 10) != nullptr);
366}
367
368TEST_F(GreasePencilTest, add_frame_duration_override_start_null_frame)
369{
370 GreasePencilLayerFramesExample ex;
371 ex.layer.add_frame(10, 2)->drawing_index = 3;
372 EXPECT_EQ(ex.layer.drawing_index_at(10), 3);
373 EXPECT_EQ(ex.layer.drawing_index_at(11), 3);
374 EXPECT_EQ(ex.layer.drawing_index_at(12), 2);
375}
376
377TEST_F(GreasePencilTest, add_frame_duration_check_duration)
378{
379 GreasePencilLayerFramesExample ex;
380 ex.layer.add_frame(17, 10)->drawing_index = 3;
381 Span<FramesMapKeyT> sorted_keys = ex.layer.sorted_keys();
382 EXPECT_EQ(sorted_keys.size(), 7);
383 EXPECT_EQ(sorted_keys[6] - sorted_keys[5], 10);
384}
385#endif
386
387TEST_F(GreasePencilTest, get_frame_duration_at)
388{
390 /* Before first frame. */
392 /* Implicit hold. */
395
398
399 /* No keyframe at frame 10. */
401
403
404 /* After last frame. */
407}
408
409/* Frame duration is disabled currently. */
410#if 0
411TEST_F(GreasePencilTest, add_frame_duration_override_null_frames)
412{
413 Layer layer;
414 layer.frames_for_write().add(0, {1});
415 layer.frames_for_write().add(1, {-1});
416 layer.frames_for_write().add(2, {-1});
417 layer.frames_for_write().add(3, {-1});
418
419 layer.add_frame(1, 10)->drawing_index = 3;
420 EXPECT_EQ(layer.drawing_index_at(0), 1);
421 EXPECT_EQ(layer.drawing_index_at(1), 3);
422 EXPECT_EQ(layer.drawing_index_at(11), -1);
423 Span<FramesMapKeyT> sorted_keys = layer.sorted_keys();
424 EXPECT_EQ(sorted_keys.size(), 3);
425 EXPECT_EQ(sorted_keys[0], 0);
426 EXPECT_EQ(sorted_keys[1], 1);
427 EXPECT_EQ(sorted_keys[2], 11);
428}
429#endif
430
431TEST_F(GreasePencilTest, remove_frame_single)
432{
433 Layer layer;
434 layer.add_frame(0)->drawing_index = 1;
435 layer.remove_frame(0);
436 EXPECT_EQ(layer.frames().size(), 0);
437}
438
439TEST_F(GreasePencilTest, remove_frame_first)
440{
441 Layer layer;
442 layer.add_frame(0)->drawing_index = 1;
443 layer.add_frame(5)->drawing_index = 2;
444 layer.remove_frame(0);
445 EXPECT_EQ(layer.frames().size(), 1);
446 EXPECT_EQ(layer.frames().lookup(5).drawing_index, 2);
447}
448
449TEST_F(GreasePencilTest, remove_frame_last)
450{
451 Layer layer;
452 layer.add_frame(0)->drawing_index = 1;
453 layer.add_frame(5)->drawing_index = 2;
454 layer.remove_frame(5);
455 EXPECT_EQ(layer.frames().size(), 1);
456 EXPECT_EQ(layer.frames().lookup(0).drawing_index, 1);
457}
458
459/* Frame duration is disabled currently. */
460#if 0
461TEST_F(GreasePencilTest, remove_frame_implicit_hold)
462{
463 Layer layer;
464 layer.add_frame(0, 4)->drawing_index = 1;
465 layer.add_frame(5)->drawing_index = 2;
466 layer.remove_frame(5);
467 EXPECT_EQ(layer.frames().size(), 2);
468 EXPECT_EQ(layer.frames().lookup(0).drawing_index, 1);
469 EXPECT_TRUE(layer.frames().lookup(4).is_end());
470}
471
472TEST_F(GreasePencilTest, remove_frame_fixed_duration_end)
473{
474 Layer layer;
475 layer.add_frame(0, 5)->drawing_index = 1;
476 layer.add_frame(5)->drawing_index = 2;
477 layer.remove_frame(0);
478 EXPECT_EQ(layer.frames().size(), 1);
479 EXPECT_EQ(layer.frames().lookup(5).drawing_index, 2);
480}
481
482TEST_F(GreasePencilTest, remove_frame_fixed_duration_overwrite_end)
483{
484 Layer layer;
485 layer.add_frame(0, 5)->drawing_index = 1;
486 layer.add_frame(5)->drawing_index = 2;
487 layer.remove_frame(5);
488 EXPECT_EQ(layer.frames().size(), 2);
489 EXPECT_EQ(layer.frames().lookup(0).drawing_index, 1);
490 EXPECT_TRUE(layer.frames().lookup(5).is_end());
491}
492#endif
493
494TEST_F(GreasePencilTest, remove_drawings_no_change)
495{
497
498 grease_pencil->add_empty_drawings(3);
499
500 Layer &layer_a = grease_pencil->add_layer("LayerA");
501 Layer &layer_b = grease_pencil->add_layer("LayerB");
502 layer_b.add_frame(10)->drawing_index = 0;
503 layer_b.add_frame(20)->drawing_index = 1;
504 layer_b.add_frame(30)->drawing_index = 2;
505
506 EXPECT_EQ(layer_a.frames().size(), 0);
507 EXPECT_EQ(layer_b.frames().size(), 3);
508 EXPECT_EQ(layer_b.frames().lookup(10).drawing_index, 0);
509 EXPECT_EQ(layer_b.frames().lookup(20).drawing_index, 1);
510 EXPECT_EQ(layer_b.frames().lookup(30).drawing_index, 2);
511 /* Test DNA storage data too. */
512 layer_a.prepare_for_dna_write();
513 layer_b.prepare_for_dna_write();
514 EXPECT_EQ(layer_a.frames_storage.num, 0);
515 EXPECT_EQ(layer_b.frames_storage.num, 3);
519
520 grease_pencil->remove_layer(layer_a);
521 EXPECT_EQ(layer_b.frames().size(), 3);
522 EXPECT_EQ(layer_b.frames().lookup(10).drawing_index, 0);
523 EXPECT_EQ(layer_b.frames().lookup(20).drawing_index, 1);
524 EXPECT_EQ(layer_b.frames().lookup(30).drawing_index, 2);
525 /* Test DNA storage data too. */
526 layer_b.prepare_for_dna_write();
527 EXPECT_EQ(layer_b.frames_storage.num, 3);
531
532 BKE_id_free(nullptr, grease_pencil);
533}
534
535TEST_F(GreasePencilTest, remove_drawings_with_no_users)
536{
538
539 /* Test drawing index correctness: Removing users from drawings should remove those drawings, and
540 * all index references should get updated to match the changed drawing indices. */
541
542 grease_pencil->add_empty_drawings(5);
543
544 Layer &layer_a = grease_pencil->add_layer("LayerA");
545 layer_a.add_frame(10)->drawing_index = 0;
546 layer_a.add_frame(20)->drawing_index = 1;
547 layer_a.add_frame(30)->drawing_index = 2;
548 Layer &layer_b = grease_pencil->add_layer("LayerB");
549 layer_b.add_frame(10)->drawing_index = 3;
550 layer_b.add_frame(30)->drawing_index = 4;
551
552 EXPECT_EQ(layer_a.frames().size(), 3);
553 EXPECT_EQ(layer_a.frames().lookup(10).drawing_index, 0);
554 EXPECT_EQ(layer_a.frames().lookup(20).drawing_index, 1);
555 EXPECT_EQ(layer_a.frames().lookup(30).drawing_index, 2);
556 EXPECT_EQ(layer_b.frames().size(), 2);
557 EXPECT_EQ(layer_b.frames().lookup(10).drawing_index, 3);
558 EXPECT_EQ(layer_b.frames().lookup(30).drawing_index, 4);
559 /* Test DNA storage data too. */
560 layer_a.prepare_for_dna_write();
561 layer_b.prepare_for_dna_write();
562 EXPECT_EQ(layer_a.frames_storage.num, 3);
566 EXPECT_EQ(layer_b.frames_storage.num, 2);
569
570 /* Drawings 0,1,2 get removed, drawings 3,4 move up (order changes). */
571 grease_pencil->remove_layer(layer_a);
572 EXPECT_EQ(layer_b.frames().size(), 2);
573 EXPECT_EQ(layer_b.frames().lookup(10).drawing_index, 1);
574 EXPECT_EQ(layer_b.frames().lookup(30).drawing_index, 0);
575 /* Test DNA storage data too. */
576 layer_b.prepare_for_dna_write();
577 EXPECT_EQ(layer_b.frames_storage.num, 2);
580
581 BKE_id_free(nullptr, grease_pencil);
582}
583
585{
586 {
587 Array<int> fill_ids;
588 std::optional<FillCache> fill_cache = fill_cache_from_fill_ids(
589 VArray<int>::from_span(fill_ids.as_span()));
590 EXPECT_FALSE(fill_cache.has_value());
591 }
592
593 {
594 Array<int> fill_ids(5, 0);
595 std::optional<FillCache> fill_cache = fill_cache_from_fill_ids(
596 VArray<int>::from_span(fill_ids.as_span()));
597 EXPECT_FALSE(fill_cache.has_value());
598 }
599
600 {
601 Array<int> fill_ids({0, 0, 0});
602 std::optional<FillCache> fill_cache = fill_cache_from_fill_ids(
603 VArray<int>::from_span(fill_ids.as_span()));
604 EXPECT_FALSE(fill_cache.has_value());
605 }
606
607 {
608 Array<int> fill_ids({1, 2, 3});
609 std::optional<FillCache> fill_cache = fill_cache_from_fill_ids(
610 VArray<int>::from_span(fill_ids.as_span()));
611 EXPECT_TRUE(fill_cache.has_value());
612
613 Array<int> expected_fill_map({0, 1, 2});
614 Array<int> expected_fill_offsets({0, 1, 2, 3});
615
616 EXPECT_EQ_SPAN<int>(expected_fill_map, fill_cache->fill_map);
617 EXPECT_EQ_SPAN<int>(expected_fill_offsets, fill_cache->fill_offsets);
618 }
619
620 {
621 Array<int> fill_ids({3, 2, 1});
622 std::optional<FillCache> fill_cache = fill_cache_from_fill_ids(
623 VArray<int>::from_span(fill_ids.as_span()));
624 EXPECT_TRUE(fill_cache.has_value());
625
626 Array<int> expected_fill_map({0, 1, 2});
627 Array<int> expected_fill_offsets({0, 1, 2, 3});
628
629 EXPECT_EQ_SPAN<int>(expected_fill_map, fill_cache->fill_map);
630 EXPECT_EQ_SPAN<int>(expected_fill_offsets, fill_cache->fill_offsets);
631 }
632
633 {
634 Array<int> fill_ids({1, 1, 2, 2, 3, 3});
635 std::optional<FillCache> fill_cache = fill_cache_from_fill_ids(
636 VArray<int>::from_span(fill_ids.as_span()));
637 EXPECT_TRUE(fill_cache.has_value());
638
639 Array<int> expected_fill_map({0, 1, 2, 3, 4, 5});
640 Array<int> expected_fill_offsets({0, 2, 4, 6});
641
642 EXPECT_EQ_SPAN<int>(expected_fill_map, fill_cache->fill_map);
643 EXPECT_EQ_SPAN<int>(expected_fill_offsets, fill_cache->fill_offsets);
644 }
645
646 {
647 Array<int> fill_ids({0, 0, 1, 0, 1, 4, 1, 3, 3});
648 std::optional<FillCache> fill_cache = fill_cache_from_fill_ids(
649 VArray<int>::from_span(fill_ids.as_span()));
650 EXPECT_TRUE(fill_cache.has_value());
651
652 Array<int> expected_fill_map({2, 4, 6, 5, 7, 8});
653 Array<int> expected_fill_offsets({0, 3, 4, 6});
654
655 EXPECT_EQ_SPAN<int>(expected_fill_map, fill_cache->fill_map);
656 EXPECT_EQ_SPAN<int>(expected_fill_offsets, fill_cache->fill_offsets);
657 }
658
659 {
660 Array<int> fill_ids({1, 1, 0, 3, 0, 1, 2, 0, 3});
661 std::optional<FillCache> fill_cache = fill_cache_from_fill_ids(
662 VArray<int>::from_span(fill_ids.as_span()));
663 EXPECT_TRUE(fill_cache.has_value());
664
665 Array<int> expected_fill_map({0, 1, 5, 3, 8, 6});
666 Array<int> expected_fill_offsets({0, 3, 5, 6});
667
668 EXPECT_EQ_SPAN<int>(expected_fill_map, fill_cache->fill_map);
669 EXPECT_EQ_SPAN<int>(expected_fill_offsets, fill_cache->fill_offsets);
670 }
671}
672
673} // namespace bke::greasepencil::tests
674} // namespace blender
Low-level operations for curves.
Low-level operations for grease pencil.
#define SNPRINTF(dst, format,...)
constexpr int64_t size() const
Definition BLI_span.hh:256
Span< T > as_span() const
Definition BLI_array.hh:254
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
static VArray from_span(Span< T > values)
const Map< FramesMapKeyT, GreasePencilFrame > & frames() const
GreasePencilFrame * add_frame(FramesMapKeyT key, int duration=0)
int drawing_index_at(const int frame_number) const
int get_frame_duration_at(const int frame_number) const
constexpr const char * data() const
#define layer
#define EXPECT_FALSE(result)
#define EXPECT_TRUE(result)
#define EXPECT_EQ(result, expect)
TEST_F(GreasePencilTest, create_grease_pencil_id)
std::optional< FillCache > fill_cache_from_fill_ids(const VArray< int > &fill_ids)
BMesh Iterators.
Main * BKE_main_new()
Definition main.cc:93
TEST_F(BrushTest, deep_copy)
Definition brush_test.cc:52
void BKE_id_free(Main *bmain, void *idv)
void BKE_main_free(Main *bmain)
Definition main.cc:202
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void * BKE_id_new_nomain(short type, const char *name)
Definition lib_id.cc:1617
void * BKE_id_new(Main *bmain, short type, const char *name)
Definition lib_id.cc:1612
GreasePencilLayerFramesMapStorage frames_storage