Blender V5.3
grease_pencil_convert_legacy.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 <optional>
10
11#include <fmt/format.h>
12
13#include "BKE_action.hh"
14#include "BKE_anim_data.hh"
15#include "BKE_attribute.hh"
17#include "BKE_colortools.hh"
18#include "BKE_curves.hh"
19#include "BKE_deform.hh"
20#include "BKE_fcurve.hh"
21#include "BKE_grease_pencil.hh"
24#include "BKE_idprop.hh"
25#include "BKE_lib_id.hh"
26#include "BKE_lib_remap.hh"
27#include "BKE_main.hh"
28#include "BKE_material.hh"
29#include "BKE_modifier.hh"
30#include "BKE_node.hh"
32#include "BKE_object.hh"
33#include "BKE_screen.hh"
34
35#include "BLO_read_write.hh"
36#include "BLO_readfile.hh"
37
38#include "BLI_color_types.hh"
39#include "BLI_function_ref.hh"
40#include "BLI_listbase.hh"
41#include "BLI_map.hh"
42#include "BLI_math_matrix.hh"
43#include "BLI_math_matrix_c.hh"
45#include "BLI_string.hh"
46#include "BLI_string_utf8.hh"
47#include "BLI_string_utils.hh"
48#include "BLI_vector.hh"
49
50#include "BLT_translation.hh"
51
52#include "DNA_anim_types.h"
53#include "DNA_brush_types.h"
57#include "DNA_meshdata_types.h"
58#include "DNA_modifier_types.h"
59#include "DNA_screen_types.h"
60#include "DNA_space_types.h"
61
62#include "DEG_depsgraph.hh"
64
65#include "ANIM_action.hh"
67
69
86
87/* -------------------------------------------------------------------- */
93
94using FCurveConvertCB = void(FCurve &fcurve);
95
122
142 ConversionData &conversion_data;
143
144 ID &id_src;
145 ID &id_dst;
146 AnimData *animdata_src;
147 AnimData *animdata_dst;
148
150 const bool is_transfer_between_ids;
156 const bool skip_nla;
157
166 const Array<AnimDataFCurveConvertor> fcurve_convertors;
167
168 public:
173 std::string root_path_src;
174 std::string root_path_dst;
175
176 private:
183 Vector<FCurve *> fcurves_from_src_main_action = {};
184 Vector<FCurve *> fcurves_from_src_tmp_action = {};
185 Vector<FCurve *> fcurves_from_src_drivers = {};
190 bool has_changes = false;
191
192 public:
195 ID &id_src,
196 const Array<AnimDataFCurveConvertor> fcurve_convertors = {})
197 : conversion_data(conversion_data),
198 id_src(id_src),
199 id_dst(id_src),
200 animdata_src(BKE_animdata_from_id(&id_src)),
201 animdata_dst(BKE_animdata_from_id(&id_dst)),
202 is_transfer_between_ids(false),
203 skip_nla(false),
204 fcurve_convertors(fcurve_convertors)
205 {
206 }
207
209 ID &id_dst,
210 ID &id_src,
211 const Array<AnimDataFCurveConvertor> fcurve_convertors = {})
212 : conversion_data(conversion_data),
213 id_src(id_src),
214 id_dst(id_dst),
215 animdata_src(BKE_animdata_from_id(&id_src)),
216 animdata_dst(BKE_animdata_from_id(&id_dst)),
217 is_transfer_between_ids(true),
218 skip_nla(true),
219 fcurve_convertors(fcurve_convertors)
220 {
221 }
223
224 private:
225 using FCurveCallback = bool(bAction *owner_action, FCurve &fcurve);
226 using ActionCallback = bool(bAction &action);
227
232 bool is_valid() const
233 {
234 return this->animdata_src != nullptr;
235 }
236
237 /* Basic common check to decide whether a legacy fcurve should be processed or not. */
238 bool legacy_fcurves_is_valid_for_root_path(FCurve &fcurve, StringRefNull legacy_root_path) const
239 {
240 const StringRefNull rna_path = fcurve.rna_path();
241 if (!rna_path.startswith(legacy_root_path)) {
242 return false;
243 }
244 return true;
245 }
246
251 bool animation_fcurve_is_valid(bAction *owner_action, FCurve &fcurve) const
252 {
253 if (!this->is_valid()) {
254 return false;
255 }
256 /* Only take into account drivers (nullptr `action_owner`), and Actions directly assigned
257 * to the animdata, not the NLA ones. */
258 if (owner_action &&
259 !ELEM(owner_action, this->animdata_src->action, this->animdata_src->tmpact))
260 {
261 return false;
262 }
263 if (!legacy_fcurves_is_valid_for_root_path(fcurve, this->root_path_src)) {
264 return false;
265 }
266 return true;
267 }
268
269 /* Iterator over all FCurves in a given animation data. */
270
271 bool fcurve_foreach_in_action(bAction *owner_action, FunctionRef<FCurveCallback> callback) const
272 {
273 bool is_changed = false;
274 animrig::foreach_fcurve_in_action(owner_action->wrap(), [&](FCurve &fcurve) {
275 const bool local_is_changed = callback(owner_action, fcurve);
276 is_changed = is_changed || local_is_changed;
277 });
278
279 return is_changed;
280 }
281
282 bool fcurve_foreach_in_listbase(ListBaseT<FCurve> &fcurves,
283 FunctionRef<FCurveCallback> callback) const
284 {
285 bool is_changed = false;
286 for (FCurve &fcurve : fcurves) {
287 const bool local_is_changed = callback(nullptr, fcurve);
288 is_changed = is_changed || local_is_changed;
289 }
290 return is_changed;
291 }
292
293 bool nla_strip_fcurve_foreach(NlaStrip &nla_strip, FunctionRef<FCurveCallback> callback) const
294 {
295 bool is_changed = false;
296 if (nla_strip.act) {
297 if (this->fcurve_foreach_in_action(nla_strip.act, callback)) {
298 DEG_id_tag_update(&nla_strip.act->id, ID_RECALC_ANIMATION);
299 is_changed = true;
300 }
301 }
302 for (NlaStrip &nla_strip_children : nla_strip.strips) {
303 const bool local_is_changed = this->nla_strip_fcurve_foreach(nla_strip_children, callback);
304 is_changed = is_changed || local_is_changed;
305 }
306 return is_changed;
307 }
308
309 bool animdata_fcurve_foreach(AnimData &anim_data, FunctionRef<FCurveCallback> callback) const
310 {
311 bool is_changed = false;
312 if (anim_data.action) {
313 if (this->fcurve_foreach_in_action(anim_data.action, callback)) {
314 DEG_id_tag_update(&anim_data.action->id, ID_RECALC_ANIMATION);
315 is_changed = true;
316 }
317 }
318 if (anim_data.tmpact) {
319 if (this->fcurve_foreach_in_action(anim_data.tmpact, callback)) {
320 DEG_id_tag_update(&anim_data.tmpact->id, ID_RECALC_ANIMATION);
321 is_changed = true;
322 }
323 }
324
325 {
326 const bool local_is_changed = this->fcurve_foreach_in_listbase(anim_data.drivers, callback);
327 is_changed = is_changed || local_is_changed;
328 }
329
330 /* NOTE: New layered actions system can be ignored here, it did not exist together with GPv2.
331 */
332
333 if (this->skip_nla) {
334 return is_changed;
335 }
336
337 for (NlaTrack &nla_track : anim_data.nla_tracks) {
338 for (NlaStrip &nla_strip : nla_track.strips) {
339 const bool local_is_changed = this->nla_strip_fcurve_foreach(nla_strip, callback);
340 is_changed = is_changed || local_is_changed;
341 }
342 }
343 return is_changed;
344 }
345
346 bool action_process(bAction &action, FunctionRef<ActionCallback> callback) const
347 {
348 if (callback(action)) {
350 return true;
351 }
352 return false;
353 }
354
355 bool nla_strip_action_foreach(NlaStrip &nla_strip, FunctionRef<ActionCallback> callback) const
356 {
357 bool is_changed = false;
358 if (nla_strip.act) {
359 is_changed = action_process(*nla_strip.act, callback);
360 }
361 for (NlaStrip &nla_strip_children : nla_strip.strips) {
362 is_changed = is_changed || this->nla_strip_action_foreach(nla_strip_children, callback);
363 }
364 return is_changed;
365 }
366
367 bool animdata_action_foreach(AnimData &anim_data, FunctionRef<ActionCallback> callback) const
368 {
369 bool is_changed = false;
370
371 if (anim_data.action) {
372 is_changed = is_changed || action_process(*anim_data.action, callback);
373 }
374 if (anim_data.tmpact) {
375 is_changed = is_changed || action_process(*anim_data.tmpact, callback);
376 }
377
378 /* NOTE: New layered actions system can be ignored here, it did not exist together with GPv2.
379 */
380
381 if (this->skip_nla) {
382 return is_changed;
383 }
384
385 for (NlaTrack &nla_track : anim_data.nla_tracks) {
386 for (NlaStrip &nla_strip : nla_track.strips) {
387 is_changed = is_changed || this->nla_strip_action_foreach(nla_strip, callback);
388 }
389 }
390 return is_changed;
391 }
392
393 public:
399 {
400 if (!this->is_valid()) {
401 return false;
402 }
403
404 if (id_src.id_type() != id_dst.id_type()) {
405 return true;
406 }
407
408 bool has_animation = false;
409 auto animation_detection_cb = [&](bAction *owner_action, FCurve &fcurve) -> bool {
410 /* Early out if we already know that the target data is animated. */
411 if (has_animation) {
412 return false;
413 }
414 if (!this->animation_fcurve_is_valid(owner_action, fcurve)) {
415 return false;
416 }
417 if (this->fcurve_convertors.is_empty()) {
418 has_animation = true;
419 return false;
420 }
421 const StringRefNull rna_path = fcurve.rna_path();
422 for (const AnimDataFCurveConvertor &fcurve_convertor : this->fcurve_convertors) {
423 const std::string rna_path_src = fmt::format(
424 "{}{}", this->root_path_src, fcurve_convertor.relative_rna_path_src);
425 if (rna_path == rna_path_src) {
426 has_animation = true;
427 return false;
428 }
429 }
430 return false;
431 };
432
433 this->animdata_fcurve_foreach(*this->animdata_src, animation_detection_cb);
434 return has_animation;
435 }
436
444 {
445 if (!this->is_valid()) {
446 return;
447 }
448
449 auto fcurve_convert_cb = [&](const AnimDataFCurveConvertor *fcurve_convertor,
450 bAction *owner_action,
451 FCurve &fcurve,
452 const std::string &rna_path_dst) {
453 fcurve.rna_path_set(rna_path_dst);
454 if (fcurve_convertor && fcurve_convertor->convert_cb) {
455 fcurve_convertor->convert_cb(fcurve);
456 }
457 this->has_changes = true;
458
459 if (!this->is_transfer_between_ids) {
460 return;
461 }
462 if (owner_action) {
463 if (owner_action == this->animdata_src->action) {
464 this->fcurves_from_src_main_action.append(&fcurve);
465 }
466 else if (owner_action == this->animdata_src->tmpact) {
467 this->fcurves_from_src_tmp_action.append(&fcurve);
468 }
469 }
470 else { /* Driver */
471 this->fcurves_from_src_drivers.append(&fcurve);
472 }
473 };
474
475 /* Update all FCurves which RNA path starts with the #root_path_src. */
476 if (this->fcurve_convertors.is_empty()) {
477 auto fcurve_root_path_convert_cb = [&](bAction *owner_action, FCurve &fcurve) -> bool {
478 if (!legacy_fcurves_is_valid_for_root_path(fcurve, this->root_path_src)) {
479 return false;
480 }
481 const StringRefNull rna_path = fcurve.rna_path();
482 const std::string rna_path_dst = fmt::format(
483 "{}{}", this->root_path_dst, rna_path.substr(int64_t(this->root_path_src.size())));
484 fcurve_convert_cb(nullptr, owner_action, fcurve, rna_path_dst);
485 return true;
486 };
487
488 this->animdata_fcurve_foreach(*(this->animdata_src), fcurve_root_path_convert_cb);
489 return;
490 }
491
492 /* Update all FCurves which RNA path starts with the #root_path_src, and remains of the path
493 * matches one of the entries in #fcurve_convertors. */
494 auto fcurve_full_path_convert_cb = [&](bAction *owner_action, FCurve &fcurve) -> bool {
495 if (!animation_fcurve_is_valid(owner_action, fcurve)) {
496 return false;
497 }
498 const StringRefNull rna_path = fcurve.rna_path();
499 for (const AnimDataFCurveConvertor &fcurve_convertor : this->fcurve_convertors) {
500 const std::string rna_path_src = fmt::format(
501 "{}{}", this->root_path_src, fcurve_convertor.relative_rna_path_src);
502 if (rna_path == rna_path_src) {
503 const std::string rna_path_dst = fmt::format(
504 "{}{}", this->root_path_dst, fcurve_convertor.relative_rna_path_dst);
505 fcurve_convert_cb(&fcurve_convertor, owner_action, fcurve, rna_path_dst);
506 return true;
507 }
508 }
509 return false;
510 };
511
512 this->animdata_fcurve_foreach(*(this->animdata_src), fcurve_full_path_convert_cb);
513 }
514
526 {
527 if (!this->is_valid()) {
528 return;
529 }
530
531 if (&id_src == &id_dst) {
532 if (this->has_changes) {
534 DEG_relations_tag_update(&this->conversion_data.bmain);
535 }
536 return;
537 }
538
539 if (this->fcurves_from_src_main_action.is_empty() &&
540 this->fcurves_from_src_tmp_action.is_empty() && this->fcurves_from_src_drivers.is_empty())
541 {
542 return;
543 }
544 if (!this->animdata_dst) {
545 this->animdata_dst = BKE_animdata_ensure_id(&this->id_dst);
546 }
547
548 auto fcurves_move = [&](bAction *action_dst,
549 const animrig::slot_handle_t slot_handle_dst,
550 bAction *action_src,
551 const Span<FCurve *> fcurves) {
552 for (FCurve *fcurve : fcurves) {
554 action_dst->wrap(), slot_handle_dst, action_src->wrap(), *fcurve);
555 }
556 };
557
558 auto fcurves_move_between_listbases = [&](ListBaseT<FCurve> &fcurves_dst,
559 ListBaseT<FCurve> &fcurves_src,
560 const Span<FCurve *> fcurves) {
561 for (FCurve *fcurve : fcurves) {
562 BLI_assert(BLI_findindex(&fcurves_src, fcurve) >= 0);
563 BLI_remlink(&fcurves_src, fcurve);
564 BLI_addtail(&fcurves_dst, fcurve);
565 }
566 };
567
568 if (!this->fcurves_from_src_main_action.is_empty()) {
569 if (!this->animdata_dst->action) {
570 /* Create a new action. */
572 this->conversion_data.bmain,
573 this->animdata_src->action ? this->animdata_src->action->id.name + 2 : "");
574 action.slot_add_for_id(this->id_dst);
575
576 const bool ok = animrig::assign_action(&action, {this->id_dst, *this->animdata_dst});
577 BLI_assert_msg(ok, "Expecting action assignment to work when converting Grease Pencil");
579 }
580 fcurves_move(this->animdata_dst->action,
581 this->animdata_dst->slot_handle,
582 this->animdata_src->action,
583 this->fcurves_from_src_main_action);
584 this->fcurves_from_src_main_action.clear();
585 }
586 if (!this->fcurves_from_src_tmp_action.is_empty()) {
587 if (!this->animdata_dst->tmpact) {
588 /* Create a new tmpact. */
590 this->conversion_data.bmain,
591 this->animdata_src->tmpact ? this->animdata_src->tmpact->id.name + 2 : "");
592 tmpact.slot_add_for_id(this->id_dst);
593
594 const bool ok = animrig::assign_tmpaction(&tmpact, {this->id_dst, *this->animdata_dst});
595 BLI_assert_msg(ok, "Expecting tmpact assignment to work when converting Grease Pencil");
597 }
598 fcurves_move(this->animdata_dst->tmpact,
599 this->animdata_dst->tmp_slot_handle,
600 this->animdata_src->tmpact,
601 this->fcurves_from_src_tmp_action);
602 this->fcurves_from_src_tmp_action.clear();
603 }
604 if (!this->fcurves_from_src_drivers.is_empty()) {
605 fcurves_move_between_listbases(this->animdata_dst->drivers,
606 this->animdata_src->drivers,
607 this->fcurves_from_src_drivers);
608 this->fcurves_from_src_drivers.clear();
609 }
610
613 DEG_relations_tag_update(&this->conversion_data.bmain);
614 }
615};
616
618
625static void find_used_vertex_groups(const bGPDframe &gpf,
626 const ListBaseT<bDeformGroup> &vertex_group_names,
627 const int num_vertex_groups,
628 ListBaseT<bDeformGroup> &r_vertex_group_names,
629 Array<int> &r_indices)
630{
631 Array<int> is_group_used(num_vertex_groups, false);
632 for (bGPDstroke &gps : gpf.strokes) {
633 if (!gps.dvert) {
634 continue;
635 }
636 Span<MDeformVert> dverts = {gps.dvert, gps.totpoints};
637 for (const MDeformVert &dvert : dverts) {
638 for (const MDeformWeight &weight : Span<MDeformWeight>{dvert.dw, dvert.totweight}) {
639 if (weight.def_nr >= num_vertex_groups) {
640 /* Ignore invalid deform weight group indices. */
641 continue;
642 }
643 is_group_used[weight.def_nr] = true;
644 }
645 }
646 }
647 r_vertex_group_names.clear_no_delete();
648 r_indices.reinitialize(num_vertex_groups);
649 int new_group_i = 0;
650
651 for (const auto [old_group_i, def_group] : vertex_group_names.enumerate()) {
652 if (!is_group_used[old_group_i]) {
653 r_indices[old_group_i] = -1;
654 continue;
655 }
656 r_indices[old_group_i] = new_group_i++;
657
658 bDeformGroup *def_group_copy = MEM_dupalloc(&def_group);
659 BLI_addtail(&r_vertex_group_names, def_group_copy);
660 }
661}
662
663/*
664 * This takes the legacy UV transforms and returns the stroke-space to texture-space matrix.
665 */
667 const float uv_rotation,
668 const float2 uv_scale)
669{
670 /* Bounding box data. */
671 const float2 minv = float2(-1.0f, -1.0f);
672 const float2 maxv = float2(1.0f, 1.0f);
673 /* Center of rotation. */
674 const float2 center = float2(0.5f, 0.5f);
675
676 const float2 uv_scale_inv = math::safe_rcp(uv_scale);
677 const float2 diagonal = maxv - minv;
678 const float sin_rotation = sin(uv_rotation);
679 const float cos_rotation = cos(uv_rotation);
680 const float2x2 rotation = float2x2(float2(cos_rotation, sin_rotation),
681 float2(-sin_rotation, cos_rotation));
682
683 float3x2 texture_matrix = float3x2::identity();
684
685 /* Apply bounding box re-scaling. */
686 texture_matrix[2] -= minv;
687 texture_matrix = math::from_scale<float2x2>(1.0f / diagonal) * texture_matrix;
688
689 /* Apply translation. */
690 texture_matrix[2] += uv_translation;
691
692 /* Apply rotation. */
693 texture_matrix[2] -= center;
694 texture_matrix = rotation * texture_matrix;
695 texture_matrix[2] += center;
696
697 /* Apply scale. */
698 texture_matrix = math::from_scale<float2x2>(uv_scale_inv) * texture_matrix;
699
700 return texture_matrix;
701}
702
703/*
704 * This gets the legacy layer-space to stroke-space matrix.
705 */
707{
708 using namespace blender::math;
709
710 const bGPDspoint *points = gps->points;
711 const int totpoints = gps->totpoints;
712
713 if (totpoints < 2) {
714 return float4x2::identity();
715 }
716
717 const bGPDspoint *point0 = &points[0];
718 const bGPDspoint *point1 = &points[1];
719 const bGPDspoint *point3 = &points[int(totpoints * 0.75f)];
720
721 const float3 pt0 = float3(point0->x, point0->y, point0->z);
722 const float3 pt1 = float3(point1->x, point1->y, point1->z);
723 const float3 pt3 = float3(point3->x, point3->y, point3->z);
724
725 /* Local X axis (p0 -> p1) */
726 const float3 local_x = normalize(pt1 - pt0);
727
728 /* Point vector at 3/4 */
729 const float3 local_3 = (totpoints == 2) ? (pt3 * 0.001f) - pt0 : pt3 - pt0;
730
731 /* Vector orthogonal to polygon plane. */
732 const float3 normal = cross(local_x, local_3);
733
734 /* Local Y axis (cross to normal/x axis). */
735 const float3 local_y = normalize(cross(normal, local_x));
736
737 /* Get local space using first point as origin. */
738 const float4x2 mat = transpose(
739 float2x4(float4(local_x, -dot(pt0, local_x)), float4(local_y, -dot(pt0, local_y))));
740
741 return mat;
742}
743
745{
746 const float3x2 texture_matrix = get_legacy_stroke_to_texture_matrix(
747 float2(gps->uv_translation), gps->uv_rotation, float2(gps->uv_scale));
748
749 const float4x2 strokemat = get_legacy_layer_to_stroke_matrix(gps);
750 float4x3 strokemat4x3 = float4x3(strokemat);
751 /*
752 * We need the diagonal of ones to start from the bottom right instead top left to properly apply
753 * the two matrices.
754 *
755 * i.e.
756 * # # # # # # # #
757 * We need # # # # Instead of # # # #
758 * 0 0 0 1 0 0 1 0
759 *
760 */
761 strokemat4x3[2][2] = 0.0f;
762 strokemat4x3[3][2] = 1.0f;
763
764 return texture_matrix * strokemat4x3;
765}
766
768 const bGPDframe &gpf, const ListBaseT<bDeformGroup> &vertex_group_names)
769{
770 /* Create a new empty drawing. */
771 Drawing drawing;
772
773 /* Get the number of points, number of strokes and the offsets for each stroke. */
774 Vector<int> offsets;
775 Vector<int8_t> curve_types;
776 offsets.append(0);
777 int num_strokes = 0;
778 int num_points = 0;
779 bool has_bezier_stroke = false;
780 for (bGPDstroke &gps : gpf.strokes) {
781 /* Check for a valid edit curve. This is only the case when the `editcurve` exists and wasn't
782 * tagged for a stroke update. This tag indicates that the stroke points have changed,
783 * invalidating the edit curve. */
784 if (gps.editcurve != nullptr && (gps.editcurve->flag & GP_CURVE_NEEDS_STROKE_UPDATE) == 0) {
785 if (gps.editcurve->tot_curve_points == 0) {
786 continue;
787 }
788 has_bezier_stroke = true;
789 num_points += gps.editcurve->tot_curve_points;
790 curve_types.append(CURVE_TYPE_BEZIER);
791 }
792 else {
793 if (gps.totpoints == 0) {
794 continue;
795 }
796 num_points += gps.totpoints;
797 curve_types.append(CURVE_TYPE_POLY);
798 }
799 num_strokes++;
800 offsets.append(num_points);
801 }
802
803 /* Return if the legacy frame contains no strokes (or zero points). */
804 if (num_strokes == 0) {
805 return drawing;
806 }
807
808 /* Resize the CurvesGeometry. */
810 curves.resize(num_points, num_strokes);
811 curves.offsets_for_write().copy_from(offsets);
812
813 OffsetIndices<int> points_by_curve = curves.points_by_curve();
814 MutableAttributeAccessor attributes = curves.attributes_for_write();
815
816 if (!has_bezier_stroke) {
817 /* All strokes are poly curves. */
818 curves.fill_curve_types(CURVE_TYPE_POLY);
819 }
820 else {
821 curves.curve_types_for_write().copy_from(curve_types);
822 curves.update_curve_types();
823 }
824
825 /* Find used vertex groups in this drawing. */
826 ListBaseT<bDeformGroup> stroke_vertex_group_names;
827 Array<int> stroke_def_nr_map;
828 const int num_vertex_groups = vertex_group_names.count();
830 gpf, vertex_group_names, num_vertex_groups, stroke_vertex_group_names, stroke_def_nr_map);
831 BLI_assert(curves.vertex_group_names.is_empty());
832 curves.vertex_group_names = stroke_vertex_group_names;
833 const bool use_dverts = !curves.vertex_group_names.is_empty();
834
835 /* Copy vertex weights and map the vertex group indices. */
836 auto copy_dvert = [&](const MDeformVert &src_dvert, MDeformVert &dst_dvert) {
837 dst_dvert = src_dvert;
838 dst_dvert.dw = MEM_dupalloc(src_dvert.dw);
839 const MutableSpan<MDeformWeight> vertex_weights = {dst_dvert.dw, dst_dvert.totweight};
840 for (MDeformWeight &weight : vertex_weights) {
841 if (weight.def_nr >= num_vertex_groups) {
842 /* Ignore invalid deform weight group indices. */
843 continue;
844 }
845 /* Map def_nr to the reduced vertex group list. */
846 weight.def_nr = stroke_def_nr_map[weight.def_nr];
847 }
848 };
849
850 /* Point Attributes. */
851 MutableSpan<float3> positions = curves.positions_for_write();
852 MutableSpan<float3> handle_positions_left = has_bezier_stroke ?
853 curves.handle_positions_left_for_write() :
855 MutableSpan<float3> handle_positions_right = has_bezier_stroke ?
856 curves.handle_positions_right_for_write() :
858 MutableSpan<float> radii = drawing.radii_for_write();
859 MutableSpan<float> opacities = drawing.opacities_for_write();
860 /* Note: Since we *know* the drawing are created from scratch, we assume that the following
861 * `lookup_or_add_for_write_span` calls always return valid writers. */
862 SpanAttributeWriter<float> delta_times = attributes.lookup_or_add_for_write_span<float>(
863 "delta_time", AttrDomain::Point);
864 SpanAttributeWriter<float> rotations = attributes.lookup_or_add_for_write_span<float>(
865 "rotation", AttrDomain::Point);
867 SpanAttributeWriter<bool> selection = attributes.lookup_or_add_for_write_span<bool>(
868 ".selection", AttrDomain::Point);
869 MutableSpan<MDeformVert> dverts = use_dverts ? curves.wrap().deform_verts_for_write() :
871
872 /* Curve Attributes. */
873 SpanAttributeWriter<bool> stroke_cyclic = attributes.lookup_or_add_for_write_span<bool>(
874 "cyclic", AttrDomain::Curve);
875 SpanAttributeWriter<float> stroke_init_times = attributes.lookup_or_add_for_write_span<float>(
876 "init_time", AttrDomain::Curve);
878 "start_cap", AttrDomain::Curve);
880 "end_cap", AttrDomain::Curve);
881 SpanAttributeWriter<float> stroke_softness = attributes.lookup_or_add_for_write_span<float>(
882 "softness", AttrDomain::Curve);
883 SpanAttributeWriter<float> stroke_point_aspect_ratios =
884 attributes.lookup_or_add_for_write_span<float>("aspect_ratio", AttrDomain::Curve);
885 MutableSpan<ColorGeometry4f> stroke_fill_colors = drawing.fill_colors_for_write();
886 SpanAttributeWriter<int> stroke_materials = attributes.lookup_or_add_for_write_span<int>(
887 "material_index", AttrDomain::Curve);
888
889 Array<float4x2> legacy_texture_matrices(num_strokes);
890
891 int stroke_i = 0;
892 for (bGPDstroke &gps : gpf.strokes) {
893 /* In GPv2 strokes with 0 points could technically be represented. In `CurvesGeometry` this is
894 * not the case and would be a bug. So we explicitly make sure to skip over strokes with no
895 * points. */
896 if (gps.totpoints == 0 || (gps.editcurve != nullptr && gps.editcurve->tot_curve_points == 0)) {
897 continue;
898 }
899
900 stroke_cyclic.span[stroke_i] = (gps.flag & GP_STROKE_CYCLIC) != 0;
901 /* Truncating time in ms to uint32 then we don't lose precision in lower bits. */
902 const uint32_t clamped_init_time = uint32_t(
903 std::clamp(gps.inittime * 1e3, 0.0, double(std::numeric_limits<uint32_t>::max())));
904 stroke_init_times.span[stroke_i] = float(clamped_init_time) / float(1e3);
905 stroke_start_caps.span[stroke_i] = int8_t(gps.caps[0]);
906 stroke_end_caps.span[stroke_i] = int8_t(gps.caps[1]);
907 stroke_softness.span[stroke_i] = 1.0f - gps.hardness;
908 stroke_point_aspect_ratios.span[stroke_i] = gps.aspect_ratio[0] /
909 max_ff(gps.aspect_ratio[1], 1e-8);
910 stroke_fill_colors[stroke_i] = ColorGeometry4f(gps.vert_color_fill);
911 stroke_materials.span[stroke_i] = gps.mat_nr;
912
913 const IndexRange points = points_by_curve[stroke_i];
914
915 const float stroke_thickness = float(gps.thickness) * LEGACY_RADIUS_CONVERSION_FACTOR;
916 MutableSpan<float3> dst_positions = positions.slice(points);
917 MutableSpan<float3> dst_handle_positions_left = has_bezier_stroke ?
918 handle_positions_left.slice(points) :
920 MutableSpan<float3> dst_handle_positions_right = has_bezier_stroke ?
921 handle_positions_right.slice(points) :
923 MutableSpan<float> dst_radii = radii.slice(points);
924 MutableSpan<float> dst_opacities = opacities.slice(points);
925 MutableSpan<float> dst_deltatimes = delta_times.span.slice(points);
926 MutableSpan<float> dst_rotations = rotations.span.slice(points);
927 MutableSpan<ColorGeometry4f> dst_vertex_colors = vertex_colors.slice(points);
928 MutableSpan<bool> dst_selection = selection.span.slice(points);
929 MutableSpan<MDeformVert> dst_dverts = use_dverts ? dverts.slice(points) :
931
932 if (curve_types[stroke_i] == CURVE_TYPE_POLY) {
933 BLI_assert(points.size() == gps.totpoints);
934 const Span<bGPDspoint> src_points{gps.points, gps.totpoints};
935 threading::parallel_for(src_points.index_range(), 4096, [&](const IndexRange range) {
936 for (const int point_i : range) {
937 const bGPDspoint &pt = src_points[point_i];
938 dst_positions[point_i] = float3(pt.x, pt.y, pt.z);
939 dst_radii[point_i] = stroke_thickness * pt.pressure;
940 dst_opacities[point_i] = pt.strength;
941 dst_deltatimes[point_i] = pt.time;
942 dst_rotations[point_i] = pt.uv_rot;
943 dst_vertex_colors[point_i] = ColorGeometry4f(pt.vert_color);
944 dst_selection[point_i] = (pt.flag & GP_SPOINT_SELECT) != 0;
945 if (use_dverts && gps.dvert) {
946 copy_dvert(gps.dvert[point_i], dst_dverts[point_i]);
947 }
948 }
949 });
950 }
951 else if (curve_types[stroke_i] == CURVE_TYPE_BEZIER) {
952 BLI_assert(gps.editcurve != nullptr);
953 BLI_assert(points.size() == gps.editcurve->tot_curve_points);
954 Span<bGPDcurve_point> src_curve_points{gps.editcurve->curve_points,
956
957 threading::parallel_for(src_curve_points.index_range(), 4096, [&](const IndexRange range) {
958 for (const int point_i : range) {
959 const bGPDcurve_point &cpt = src_curve_points[point_i];
960 dst_positions[point_i] = float3(cpt.bezt.vec[1]);
961 dst_handle_positions_left[point_i] = float3(cpt.bezt.vec[0]);
962 dst_handle_positions_right[point_i] = float3(cpt.bezt.vec[2]);
963 dst_radii[point_i] = stroke_thickness * cpt.pressure;
964 dst_opacities[point_i] = cpt.strength;
965 dst_rotations[point_i] = cpt.uv_rot;
966 dst_vertex_colors[point_i] = ColorGeometry4f(cpt.vert_color);
967 dst_selection[point_i] = (cpt.flag & GP_CURVE_POINT_SELECT) != 0;
968 if (use_dverts && gps.dvert) {
969 copy_dvert(gps.dvert[point_i], dst_dverts[point_i]);
970 }
971 }
972 });
973 }
974 else {
975 /* Unknown curve type. */
977 }
978
979 const float4x2 legacy_texture_matrix = get_legacy_texture_matrix(&gps);
980 legacy_texture_matrices[stroke_i] = legacy_texture_matrix;
981
982 stroke_i++;
983 }
984
985 /* Ensure that the normals are up to date. */
986 curves.tag_normals_changed();
987 drawing.set_texture_matrices(legacy_texture_matrices.as_span(), curves.curves_range());
988
989 delta_times.finish();
990 rotations.finish();
991 selection.finish();
992
993 stroke_cyclic.finish();
994 stroke_init_times.finish();
995 stroke_start_caps.finish();
996 stroke_end_caps.finish();
997 stroke_softness.finish();
998 stroke_point_aspect_ratios.finish();
999 stroke_materials.finish();
1000
1001 return drawing;
1002}
1003
1006 bGPdata &gpd)
1007{
1008 using namespace blender::bke::greasepencil;
1009
1010 if (gpd.id.flag & ID_FLAG_FAKEUSER) {
1012 }
1013
1014 BLI_assert(!grease_pencil.id.properties);
1015 if (gpd.id.properties) {
1016 grease_pencil.id.properties = IDP_CopyProperty(gpd.id.properties);
1017 grease_pencil.id.system_properties = IDP_CopyProperty(gpd.id.properties);
1018 }
1019
1024 (gpd.flag & GP_DATA_AUTOLOCK_LAYERS) != 0,
1028
1029 for (const auto [layer_idx, gpl] : gpd.layers.enumerate()) {
1030 /* Create a new layer. */
1031 Layer &new_layer = grease_pencil.add_layer(StringRefNull(gpl.info, STRNLEN(gpl.info)));
1032
1033 /* Flags. */
1034 new_layer.set_visible((gpl.flag & GP_LAYER_HIDE) == 0);
1035 new_layer.set_locked((gpl.flag & GP_LAYER_LOCKED) != 0);
1036 new_layer.set_selected((gpl.flag & GP_LAYER_SELECT) != 0);
1038 new_layer.base.flag, (gpl.flag & GP_LAYER_FRAMELOCK) != 0, GP_LAYER_TREE_NODE_MUTE);
1040 new_layer.base.flag, (gpl.flag & GP_LAYER_USE_LIGHTS) != 0, GP_LAYER_TREE_NODE_USE_LIGHTS);
1041 SET_FLAG_FROM_TEST(new_layer.base.flag,
1042 (gpl.onion_flag & GP_LAYER_ONIONSKIN) == 0,
1045 new_layer.base.flag, (gpl.flag & GP_LAYER_USE_MASK) == 0, GP_LAYER_TREE_NODE_HIDE_MASKS);
1046
1047 /* Copy Dope-sheet channel color. */
1048 copy_v3_v3(new_layer.base.color, gpl.color);
1049 new_layer.blend_mode = GreasePencilLayerBlendMode(gpl.blend_mode);
1050
1051 new_layer.parent = gpl.parent;
1052 new_layer.set_parent_bone_name(gpl.parsubstr);
1053 /* GPv2 parent inverse matrix is only valid when parent is set. */
1054 if (gpl.parent) {
1055 copy_m4_m4(new_layer.parentinv, gpl.inverse);
1056 }
1057
1058 copy_v3_v3(new_layer.translation, gpl.location);
1059 copy_v3_v3(new_layer.rotation, gpl.rotation);
1060 copy_v3_v3(new_layer.scale, gpl.scale);
1061
1062 new_layer.set_view_layer_name(gpl.viewlayername);
1063 SET_FLAG_FROM_TEST(new_layer.base.flag,
1064 (gpl.flag & GP_LAYER_DISABLE_MASKS_IN_VIEWLAYER) != 0,
1066
1067 /* Convert the layer masks. */
1068 for (bGPDlayer_Mask &mask : gpl.mask_layers) {
1069 LayerMask *new_mask = MEM_new<LayerMask>(__func__, mask.name);
1070 new_mask->flag = GreasePencilLayerMaskFlag(mask.flag);
1071 BLI_addtail(&new_layer.masks, new_mask);
1072 }
1073 new_layer.opacity = gpl.opacity;
1074
1075 for (bGPDframe &gpf : gpl.frames) {
1076 Drawing *dst_drawing = grease_pencil.insert_frame(
1077 new_layer, gpf.framenum, 0, eBezTriple_KeyframeType(gpf.key_type));
1078 if (dst_drawing == nullptr) {
1079 /* Might fail because GPv2 technically allowed overlapping keyframes on the same frame
1080 * (very unlikely to occur in real world files). In GPv3, keyframes always have to be on
1081 * different frames. In this case we can't create a keyframe and have to skip it. */
1082 continue;
1083 }
1084 /* Convert the frame to a drawing. */
1086
1087 /* This frame was just inserted above, so it should always exist. */
1088 GreasePencilFrame &new_frame = *new_layer.frame_at(gpf.framenum);
1090 }
1091
1092 if ((gpl.flag & GP_LAYER_ACTIVE) != 0) {
1093 grease_pencil.set_active_layer(&new_layer);
1094 }
1095 }
1096
1097 /* Second loop, to write to layer attributes after all layers were created. */
1098 MutableAttributeAccessor layer_attributes = grease_pencil.attributes_for_write();
1099 /* NOTE: Layer Adjustments like the tint and the radius offsets are deliberately ignored here!
1100 * These are converted to modifiers at the bottom of the stack to keep visual compatibility with
1101 * GPv2. */
1102 SpanAttributeWriter<int> layer_passes = layer_attributes.lookup_or_add_for_write_span<int>(
1103 "pass_index", bke::AttrDomain::Layer);
1104
1105 for (const auto [layer_idx, gpl] : gpd.layers.enumerate()) {
1106 layer_passes.span[layer_idx] = int(gpl.pass_index);
1107 }
1108
1109 layer_passes.finish();
1110
1111 /* Copy vertex group names and settings. */
1112 BKE_defgroup_copy_list(&grease_pencil.vertex_group_names, &gpd.vertex_group_names);
1113 grease_pencil.vertex_group_active_index = gpd.vertex_group_active_index;
1114
1115 /* Convert the onion skinning settings. */
1116 GreasePencilOnionSkinningSettings &settings = grease_pencil.onion_skinning_settings;
1117 settings.opacity = gpd.onion_factor;
1119 SET_FLAG_FROM_TEST(settings.flag,
1120 ((gpd.onion_flag & GP_ONION_GHOST_PREVCOL) != 0 &&
1121 (gpd.onion_flag & GP_ONION_GHOST_NEXTCOL) != 0),
1127 /* Convert keytype filter to a bit flag. */
1128 if (gpd.onion_keytype == -1) {
1130 }
1131 else {
1133 }
1134 settings.num_frames_before = gpd.gstep;
1135 settings.num_frames_after = gpd.gstep_next;
1136 copy_v3_v3(settings.color_before, gpd.gcolor_prev);
1137 copy_v3_v3(settings.color_after, gpd.gcolor_next);
1138
1139 BKE_id_materials_copy(&conversion_data.bmain, &gpd.id, &grease_pencil.id);
1140
1141 /* Copy animation data from legacy GP data.
1142 *
1143 * Note that currently, Actions IDs are not duplicated. They may be needed ultimately, but for
1144 * the time being, assuming invalid fcurves/drivers are fine here. */
1145 if (AnimData *gpd_animdata = BKE_animdata_from_id(&gpd.id)) {
1147 &conversion_data.bmain, gpd.id.lib, gpd_animdata, LIB_ID_COPY_DEFAULT);
1148
1149 /* Some property was renamed between legacy GP layers and new GreasePencil ones. */
1150 AnimDataConvertor animdata_gpdata_transfer(
1151 conversion_data, grease_pencil.id, gpd.id, {{".location", ".translation"}});
1152 for (const Layer *layer_iter : grease_pencil.layers()) {
1153 /* Data comes from versioned GPv2 layers, which have a fixed max length. */
1154 char layer_name_esc[sizeof((bGPDlayer{}).info) * 2];
1155 BLI_str_escape(layer_name_esc, layer_iter->name().c_str(), sizeof(layer_name_esc));
1156 std::string layer_root_path = fmt::format("layers[\"{}\"]", layer_name_esc);
1157 animdata_gpdata_transfer.root_path_dst = layer_root_path;
1158 animdata_gpdata_transfer.root_path_src = layer_root_path;
1159 animdata_gpdata_transfer.fcurves_convert();
1160 }
1161 animdata_gpdata_transfer.fcurves_convert_finalize();
1162 }
1163}
1164
1165constexpr const char *OFFSET_RADIUS_NODETREE_NAME = "Offset Radius GPv3 Conversion";
1167{
1168 /* NOTE: DO NOT translate this ID name, it is used to find a potentially already existing
1169 * node-tree. */
1171 &conversion_data.bmain, library, OFFSET_RADIUS_NODETREE_NAME, "GeometryNodeTree");
1172
1173 if (!group->geometry_node_asset_traits) {
1174 group->geometry_node_asset_traits = MEM_new<GeometryNodeAssetTraits>(__func__);
1175 }
1177
1178 group->tree_interface.add_socket(
1179 DATA_("Geometry"), "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_INPUT, nullptr);
1180 group->tree_interface.add_socket(
1181 DATA_("Geometry"), "", "NodeSocketGeometry", NODE_INTERFACE_SOCKET_OUTPUT, nullptr);
1182
1183 bNodeTreeInterfaceSocket *radius_offset = group->tree_interface.add_socket(
1184 DATA_("Offset"), "", "NodeSocketFloat", NODE_INTERFACE_SOCKET_INPUT, nullptr);
1185 auto &radius_offset_data = *static_cast<bNodeSocketValueFloat *>(radius_offset->socket_data);
1186 radius_offset_data.subtype = PROP_DISTANCE;
1187 radius_offset_data.min = -FLT_MAX;
1188 radius_offset_data.max = FLT_MAX;
1189
1190 group->tree_interface.add_socket(
1191 DATA_("Layer"), "", "NodeSocketString", NODE_INTERFACE_SOCKET_INPUT, nullptr);
1192
1193 bNode *group_output = bke::node_add_node(nullptr, *group, "NodeGroupOutput"_ustr);
1194 group_output->location[0] = 800;
1195 group_output->location[1] = 160;
1196 bNode *group_input = bke::node_add_node(nullptr, *group, "NodeGroupInput"_ustr);
1197 group_input->location[0] = 0;
1198 group_input->location[1] = 160;
1199
1200 bNode *set_curve_radius = bke::node_add_node(nullptr, *group, "GeometryNodeSetCurveRadius"_ustr);
1201 set_curve_radius->location[0] = 600;
1202 set_curve_radius->location[1] = 160;
1203 bNode *named_layer_selection = bke::node_add_node(
1204 nullptr, *group, "GeometryNodeInputNamedLayerSelection"_ustr);
1205 named_layer_selection->location[0] = 200;
1206 named_layer_selection->location[1] = 100;
1207 bNode *input_radius = bke::node_add_node(nullptr, *group, "GeometryNodeInputRadius"_ustr);
1208 input_radius->location[0] = 0;
1209 input_radius->location[1] = 0;
1210
1211 bNode *add = bke::node_add_node(nullptr, *group, "ShaderNodeMath"_ustr);
1212 add->custom1 = NODE_MATH_ADD;
1213 add->location[0] = 200;
1214 add->location[1] = 0;
1215
1216 bNode *clamp_radius = bke::node_add_node(nullptr, *group, "ShaderNodeClamp"_ustr);
1217 clamp_radius->location[0] = 400;
1218 clamp_radius->location[1] = 0;
1219 bNodeSocket *sock_max = bke::node_find_socket(*clamp_radius, SOCK_IN, "Max"_ustr);
1220 static_cast<bNodeSocketValueFloat *>(sock_max->default_value)->value = FLT_MAX;
1221
1222 bke::node_add_link(*group,
1223 *group_input,
1224 *bke::node_find_socket(*group_input, SOCK_OUT, "Socket_0"_ustr),
1225 *set_curve_radius,
1226 *bke::node_find_socket(*set_curve_radius, SOCK_IN, "Curve"_ustr));
1227 bke::node_add_link(*group,
1228 *set_curve_radius,
1229 *bke::node_find_socket(*set_curve_radius, SOCK_OUT, "Curve"_ustr),
1230 *group_output,
1231 *bke::node_find_socket(*group_output, SOCK_IN, "Socket_1"_ustr));
1232
1233 bke::node_add_link(*group,
1234 *group_input,
1235 *bke::node_find_socket(*group_input, SOCK_OUT, "Socket_3"_ustr),
1236 *named_layer_selection,
1237 *bke::node_find_socket(*named_layer_selection, SOCK_IN, "Name"_ustr));
1238 bke::node_add_link(*group,
1239 *named_layer_selection,
1240 *bke::node_find_socket(*named_layer_selection, SOCK_OUT, "Selection"_ustr),
1241 *set_curve_radius,
1242 *bke::node_find_socket(*set_curve_radius, SOCK_IN, "Selection"_ustr));
1243
1244 bke::node_add_link(*group,
1245 *group_input,
1246 *bke::node_find_socket(*group_input, SOCK_OUT, "Socket_2"_ustr),
1247 *add,
1248 *bke::node_find_socket(*add, SOCK_IN, "Value"_ustr));
1249 bke::node_add_link(*group,
1250 *input_radius,
1251 *bke::node_find_socket(*input_radius, SOCK_OUT, "Radius"_ustr),
1252 *add,
1253 *bke::node_find_socket(*add, SOCK_IN, "Value_001"_ustr));
1254 bke::node_add_link(*group,
1255 *add,
1256 *bke::node_find_socket(*add, SOCK_OUT, "Value"_ustr),
1257 *clamp_radius,
1258 *bke::node_find_socket(*clamp_radius, SOCK_IN, "Value"_ustr));
1259 bke::node_add_link(*group,
1260 *clamp_radius,
1261 *bke::node_find_socket(*clamp_radius, SOCK_OUT, "Result"_ustr),
1262 *set_curve_radius,
1263 *bke::node_find_socket(*set_curve_radius, SOCK_IN, "Radius"_ustr));
1264
1265 for (bNode &node : group->nodes) {
1267 }
1268
1269 return group;
1270}
1271
1273 bGPdata &src_object_data,
1274 Object &dst_object)
1275{
1276 AnimDataConvertor animdata_thickness_transfer(
1277 conversion_data, dst_object.id, src_object_data.id, {{"pixel_factor", ".thickness_factor"}});
1278 animdata_thickness_transfer.root_path_src = "";
1279
1280 const float thickness_factor = src_object_data.pixfactor;
1281 const bool has_thickness_factor_animation =
1282 animdata_thickness_transfer.source_has_animation_to_convert();
1283 const bool has_thickness_factor = thickness_factor != 1.0f || has_thickness_factor_animation;
1284
1285 if (!has_thickness_factor) {
1286 return;
1287 }
1288
1290 GreasePencilThickModifierData *tmd = reinterpret_cast<GreasePencilThickModifierData *>(md);
1291
1292 tmd->thickness_fac = thickness_factor;
1293
1294 STRNCPY_UTF8(md->name, DATA_("Thickness"));
1295 BKE_modifier_unique_name(&dst_object.modifiers, md);
1296
1297 BLI_addtail(&dst_object.modifiers, md);
1298 BKE_modifiers_persistent_uid_init(dst_object, *md);
1299
1300 if (has_thickness_factor_animation) {
1301 char modifier_name_esc[MAX_NAME * 2];
1302 BLI_str_escape(modifier_name_esc, md->name, sizeof(modifier_name_esc));
1303 animdata_thickness_transfer.root_path_dst = fmt::format("modifiers[\"{}\"]",
1304 modifier_name_esc);
1305
1306 animdata_thickness_transfer.fcurves_convert();
1307 }
1308
1309 animdata_thickness_transfer.fcurves_convert_finalize();
1310}
1311
1313{
1314 if (fcurve.bezt) {
1315 for (uint i = 0; i < fcurve.totvert; i++) {
1316 BezTriple &bezier_triple = fcurve.bezt[i];
1317 bezier_triple.vec[0][1] *= LEGACY_RADIUS_CONVERSION_FACTOR;
1318 bezier_triple.vec[1][1] *= LEGACY_RADIUS_CONVERSION_FACTOR;
1319 bezier_triple.vec[2][1] *= LEGACY_RADIUS_CONVERSION_FACTOR;
1320 }
1321 }
1322 if (fcurve.fpt) {
1323 for (uint i = 0; i < fcurve.totvert; i++) {
1324 FPoint &fpoint = fcurve.fpt[i];
1326 }
1327 }
1328 fcurve.flag &= ~FCURVE_INT_VALUES;
1330}
1331
1333 Object &object)
1334{
1335 if (BKE_animdata_from_id(&object.id) == nullptr) {
1336 return;
1337 }
1338
1339 /* NOTE: At this point, the animation was already transferred to the destination object. Now we
1340 * just need to convert the fcurve data to be in the right space. */
1341 AnimDataConvertor animdata_convert_thickness(
1342 conversion_data,
1343 object.id,
1344 object.id,
1345 {{".thickness", ".thickness", fcurve_convert_thickness_cb}});
1346
1347 for (ModifierData &tmd : object.modifiers) {
1349 continue;
1350 }
1351
1352 char modifier_name[MAX_NAME * 2];
1353 BLI_str_escape(modifier_name, tmd.name, sizeof(modifier_name));
1354 animdata_convert_thickness.root_path_src = fmt::format("modifiers[\"{}\"]", modifier_name);
1355 animdata_convert_thickness.root_path_dst = fmt::format("modifiers[\"{}\"]", modifier_name);
1356
1357 if (!animdata_convert_thickness.source_has_animation_to_convert()) {
1358 continue;
1359 }
1360 animdata_convert_thickness.fcurves_convert();
1361 }
1362
1363 animdata_convert_thickness.fcurves_convert_finalize();
1364 DEG_relations_tag_update(&conversion_data.bmain);
1365}
1366
1368 bGPdata &src_object_data,
1369 Object &dst_object)
1370{
1371 /* Handling of animation here is a bit complex, since paths needs to be updated, but also
1372 * FCurves need to be transferred from legacy GPData animation to Object animation. */
1373 AnimDataConvertor animdata_tint_transfer(
1374 conversion_data,
1375 dst_object.id,
1376 src_object_data.id,
1377 {{".tint_color", ".color"}, {".tint_factor", ".factor"}});
1378
1379 AnimDataConvertor animdata_thickness_transfer(
1380 conversion_data,
1381 dst_object.id,
1382 src_object_data.id,
1383 {{".line_change", "[\"Socket_2\"]", fcurve_convert_thickness_cb}});
1384
1385 /* Replace layer adjustments with modifiers. */
1386 for (bGPDlayer &gpl : src_object_data.layers) {
1387 const float3 tint_color = float3(gpl.tintcolor);
1388 const float tint_factor = gpl.tintcolor[3];
1389 const int thickness_px = gpl.line_change;
1390
1391 char layer_name_esc[sizeof(gpl.info) * 2];
1392 BLI_str_escape(layer_name_esc, gpl.info, sizeof(layer_name_esc));
1393 animdata_tint_transfer.root_path_src = fmt::format("layers[\"{}\"]", layer_name_esc);
1394 animdata_thickness_transfer.root_path_src = fmt::format("layers[\"{}\"]", layer_name_esc);
1395
1396 const bool has_tint_adjustment_animation =
1397 animdata_tint_transfer.source_has_animation_to_convert();
1398 const bool has_thickness_adjustment_animation =
1399 animdata_thickness_transfer.source_has_animation_to_convert();
1400
1401 /* If tint or thickness are animated, relevant modifiers also need to be created. */
1402 const bool has_tint_adjustment = tint_factor > 0.0f || has_tint_adjustment_animation;
1403 const bool has_thickness_adjustment = thickness_px != 0 || has_thickness_adjustment_animation;
1404
1405 /* Tint adjustment. */
1406 if (has_tint_adjustment) {
1408 GreasePencilTintModifierData *tmd = reinterpret_cast<GreasePencilTintModifierData *>(md);
1409
1410 copy_v3_v3(tmd->color, tint_color);
1411 tmd->factor = tint_factor;
1413
1414 char modifier_name[MAX_NAME];
1415 SNPRINTF_UTF8(modifier_name, "Tint %s", gpl.info);
1416 STRNCPY_UTF8(md->name, modifier_name);
1417 BKE_modifier_unique_name(&dst_object.modifiers, md);
1418
1419 BLI_addtail(&dst_object.modifiers, md);
1420 BKE_modifiers_persistent_uid_init(dst_object, *md);
1421
1422 if (has_tint_adjustment_animation) {
1423 char modifier_name_esc[MAX_NAME * 2];
1424 BLI_str_escape(modifier_name_esc, md->name, sizeof(modifier_name_esc));
1425 animdata_tint_transfer.root_path_dst = fmt::format("modifiers[\"{}\"]", modifier_name_esc);
1426
1427 animdata_tint_transfer.fcurves_convert();
1428 }
1429 }
1430 /* Thickness adjustment. */
1431 if (has_thickness_adjustment) {
1432 /* Convert the "pixel" offset value into a radius value.
1433 * GPv2 used a conversion of 1 "px" = 0.001. */
1434 /* NOTE: this offset may be negative. */
1435 const float uniform_object_scale = math::average(float3(dst_object.scale));
1436 const float radius_offset = math::safe_divide(
1437 float(thickness_px) * LEGACY_RADIUS_CONVERSION_FACTOR, uniform_object_scale);
1438
1439 const auto offset_radius_ntree_ensure = [&](Library *owner_library) {
1440 if (bNodeTree **ntree = conversion_data.offset_radius_ntree_by_library.lookup_ptr(
1441 owner_library))
1442 {
1443 /* Node tree has already been found/created for this versioning call. */
1444 return *ntree;
1445 }
1446 /* Try to find an existing group added by previous versioning to avoid adding duplicates.
1447 */
1448 for (bNodeTree &ntree_iter : conversion_data.bmain.nodetrees) {
1449 if (ntree_iter.id.lib != owner_library) {
1450 continue;
1451 }
1452 if (STREQ(ntree_iter.id.name + 2, OFFSET_RADIUS_NODETREE_NAME)) {
1453 conversion_data.offset_radius_ntree_by_library.add_new(owner_library, &ntree_iter);
1454 return &ntree_iter;
1455 }
1456 }
1457 bNodeTree *new_ntree = offset_radius_node_tree_add(conversion_data, owner_library);
1458 /* Remove the default user. The count is tracked manually when assigning to modifiers. */
1459 id_us_min(&new_ntree->id);
1460 conversion_data.offset_radius_ntree_by_library.add_new(owner_library, new_ntree);
1461 BKE_ntree_update_after_single_tree_change(conversion_data.bmain, *new_ntree);
1462 return new_ntree;
1463 };
1464 bNodeTree *offset_radius_node_tree = offset_radius_ntree_ensure(dst_object.id.lib);
1465
1466 auto *md = reinterpret_cast<NodesModifierData *>(BKE_modifier_new(eModifierType_Nodes));
1467
1468 char modifier_name[MAX_NAME];
1469 SNPRINTF_UTF8(modifier_name, "Thickness %s", gpl.info);
1470 STRNCPY_UTF8(md->modifier.name, modifier_name);
1471 BKE_modifier_unique_name(&dst_object.modifiers, &md->modifier);
1472 md->node_group = offset_radius_node_tree;
1473
1474 BLI_addtail(&dst_object.modifiers, md);
1475 BKE_modifiers_persistent_uid_init(dst_object, md->modifier);
1476
1477 md->settings_legacy.properties =
1478 bke::idprop::create_group("Nodes Modifier Settings").release();
1479 IDProperty *radius_offset_prop =
1480 bke::idprop::create(DATA_("Socket_2"), radius_offset).release();
1481 auto *ui_data = reinterpret_cast<IDPropertyUIDataFloat *>(
1482 IDP_ui_data_ensure(radius_offset_prop));
1483 ui_data->soft_min = 0.0;
1484 ui_data->base.rna_subtype = PROP_TRANSLATION;
1485 IDP_AddToGroup(md->settings_legacy.properties, radius_offset_prop);
1486 IDP_AddToGroup(md->settings_legacy.properties,
1487 bke::idprop::create(DATA_("Socket_3"), gpl.info).release());
1488
1489 if (has_thickness_adjustment_animation) {
1490 char modifier_name_esc[MAX_NAME * 2];
1491 BLI_str_escape(modifier_name_esc, md->modifier.name, sizeof(modifier_name_esc));
1492 animdata_thickness_transfer.root_path_dst = fmt::format("modifiers[\"{}\"]",
1493 modifier_name_esc);
1494
1495 animdata_thickness_transfer.fcurves_convert();
1496 }
1497 }
1498 }
1499
1500 animdata_tint_transfer.fcurves_convert_finalize();
1501 animdata_thickness_transfer.fcurves_convert_finalize();
1502
1503 DEG_relations_tag_update(&conversion_data.bmain);
1504}
1505
1507 Object &object,
1508 const ModifierType type,
1509 GpencilModifierData &legacy_md)
1510{
1511 /* TODO: Copy of most of #ed::object::modifier_add, this should be a BKE_modifiers function
1512 * actually. */
1513 const ModifierTypeInfo *mti = BKE_modifier_get_info(type);
1514
1515 ModifierData &new_md = *BKE_modifier_new(type);
1516
1518 ModifierData *md;
1519 for (md = object.modifiers.first();
1521 md = md->next)
1522 {
1523 ;
1524 }
1525 BLI_insertlinkbefore(&object.modifiers, md, &new_md);
1526 }
1527 else {
1528 BLI_addtail(&object.modifiers, &new_md);
1529 }
1530
1531 /* Generate new persistent UID and best possible unique name. */
1532 BKE_modifiers_persistent_uid_init(object, new_md);
1533 if (legacy_md.name[0]) {
1534 STRNCPY_UTF8(new_md.name, legacy_md.name);
1535 }
1536 BKE_modifier_unique_name(&object.modifiers, &new_md);
1537
1538 /* Handle common modifier data. */
1539 new_md.mode = ModifierMode(legacy_md.mode);
1540 new_md.flag |= ModifierFlag(int(legacy_md.flag) &
1542
1543 /* Attempt to copy UI state (panels) as best as possible. */
1544 new_md.ui_expand_flag = legacy_md.ui_expand_flag;
1545
1546 /* Convert animation data if needed. */
1547 if (BKE_animdata_from_id(&object.id)) {
1548 AnimDataConvertor anim_convertor(conversion_data, object.id);
1549
1550 char legacy_name_esc[MAX_NAME * 2];
1551 BLI_str_escape(legacy_name_esc, legacy_md.name, sizeof(legacy_name_esc));
1552 anim_convertor.root_path_src = fmt::format("grease_pencil_modifiers[\"{}\"]", legacy_name_esc);
1553
1554 char new_name_esc[MAX_NAME * 2];
1555 BLI_str_escape(new_name_esc, new_md.name, sizeof(new_name_esc));
1556 anim_convertor.root_path_dst = fmt::format("modifiers[\"{}\"]", new_name_esc);
1557
1558 anim_convertor.fcurves_convert();
1559 anim_convertor.fcurves_convert_finalize();
1560 }
1561
1562 return new_md;
1563}
1564
1566 StringRef layername,
1567 const int layer_pass,
1568 const bool invert_layer,
1569 const bool invert_layer_pass,
1570 Material **material,
1571 const int material_pass,
1572 const bool invert_material,
1573 const bool invert_material_pass,
1574 StringRef vertex_group_name,
1575 const bool invert_vertex_group,
1576 CurveMapping **custom_curve,
1577 const bool use_custom_curve)
1578{
1580
1581 layername.copy_utf8_truncated(influence.layer_name);
1582 if (invert_layer) {
1584 }
1585 influence.layer_pass = layer_pass;
1586 if (layer_pass > 0) {
1588 }
1589 if (invert_layer_pass) {
1591 }
1592
1593 if (material) {
1594 influence.material = *material;
1595 *material = nullptr;
1596 }
1597 if (invert_material) {
1599 }
1600 influence.material_pass = material_pass;
1601 if (material_pass > 0) {
1603 }
1604 if (invert_material_pass) {
1606 }
1607
1608 vertex_group_name.copy_utf8_truncated(influence.vertex_group_name);
1609 if (invert_vertex_group) {
1611 }
1612
1613 if (custom_curve) {
1614 if (influence.custom_curve) {
1616 }
1617 influence.custom_curve = *custom_curve;
1618 *custom_curve = nullptr;
1619 }
1620 if (use_custom_curve) {
1622 }
1623}
1624
1626 Object &object,
1627 GpencilModifierData &legacy_md)
1628{
1630 conversion_data, object, eModifierType_GreasePencilArmature, legacy_md);
1631 auto &md_armature = reinterpret_cast<GreasePencilArmatureModifierData &>(md);
1632 auto &legacy_md_armature = reinterpret_cast<ArmatureGpencilModifierData &>(legacy_md);
1633
1634 md_armature.object = legacy_md_armature.object;
1635 legacy_md_armature.object = nullptr;
1636 md_armature.deformflag = legacy_md_armature.deformflag;
1637
1638 legacy_object_modifier_influence(md_armature.influence,
1639 "",
1640 0,
1641 false,
1642 false,
1643 nullptr,
1644 0,
1645 false,
1646 false,
1647 legacy_md_armature.vgname,
1648 legacy_md_armature.deformflag & ARM_DEF_INVERT_VGROUP,
1649 nullptr,
1650 false);
1651}
1652
1654 Object &object,
1655 GpencilModifierData &legacy_md)
1656{
1658 conversion_data, object, eModifierType_GreasePencilArray, legacy_md);
1659 auto &md_array = reinterpret_cast<GreasePencilArrayModifierData &>(md);
1660 auto &legacy_md_array = reinterpret_cast<ArrayGpencilModifierData &>(legacy_md);
1661
1662 md_array.object = legacy_md_array.object;
1663 legacy_md_array.object = nullptr;
1664 md_array.count = legacy_md_array.count;
1666 if (legacy_md_array.flag & GP_ARRAY_UNIFORM_RANDOM_SCALE) {
1668 }
1669 if (legacy_md_array.flag & GP_ARRAY_USE_OB_OFFSET) {
1671 }
1672 if (legacy_md_array.flag & GP_ARRAY_USE_OFFSET) {
1673 md_array.flag |= MOD_GREASE_PENCIL_ARRAY_USE_OFFSET;
1674 }
1675 if (legacy_md_array.flag & GP_ARRAY_USE_RELATIVE) {
1676 md_array.flag |= MOD_GREASE_PENCIL_ARRAY_USE_RELATIVE;
1677 }
1678 copy_v3_v3(md_array.offset, legacy_md_array.offset);
1679 copy_v3_v3(md_array.shift, legacy_md_array.shift);
1680 copy_v3_v3(md_array.rnd_offset, legacy_md_array.rnd_offset);
1681 copy_v3_v3(md_array.rnd_rot, legacy_md_array.rnd_rot);
1682 copy_v3_v3(md_array.rnd_scale, legacy_md_array.rnd_scale);
1683 md_array.seed = legacy_md_array.seed;
1684 md_array.mat_rpl = legacy_md_array.mat_rpl;
1685
1686 legacy_object_modifier_influence(md_array.influence,
1687 legacy_md_array.layername,
1688 legacy_md_array.layer_pass,
1689 legacy_md_array.flag & GP_ARRAY_INVERT_LAYER,
1690 legacy_md_array.flag & GP_ARRAY_INVERT_LAYERPASS,
1691 &legacy_md_array.material,
1692 legacy_md_array.pass_index,
1693 legacy_md_array.flag & GP_ARRAY_INVERT_MATERIAL,
1694 legacy_md_array.flag & GP_ARRAY_INVERT_PASS,
1695 "",
1696 false,
1697 nullptr,
1698 false);
1699}
1700
1702 Object &object,
1703 GpencilModifierData &legacy_md)
1704{
1706 conversion_data, object, eModifierType_GreasePencilColor, legacy_md);
1707 auto &md_color = reinterpret_cast<GreasePencilColorModifierData &>(md);
1708 auto &legacy_md_color = reinterpret_cast<ColorGpencilModifierData &>(legacy_md);
1709
1710 switch (eModifyColorGpencil_Flag(legacy_md_color.modify_color)) {
1712 md_color.color_mode = MOD_GREASE_PENCIL_COLOR_BOTH;
1713 break;
1715 md_color.color_mode = MOD_GREASE_PENCIL_COLOR_STROKE;
1716 break;
1718 md_color.color_mode = MOD_GREASE_PENCIL_COLOR_FILL;
1719 break;
1721 md_color.color_mode = MOD_GREASE_PENCIL_COLOR_HARDNESS;
1722 break;
1723 }
1724 copy_v3_v3(md_color.hsv, legacy_md_color.hsv);
1725
1726 legacy_object_modifier_influence(md_color.influence,
1727 legacy_md_color.layername,
1728 legacy_md_color.layer_pass,
1729 legacy_md_color.flag & GP_COLOR_INVERT_LAYER,
1730 legacy_md_color.flag & GP_COLOR_INVERT_LAYERPASS,
1731 &legacy_md_color.material,
1732 legacy_md_color.pass_index,
1733 legacy_md_color.flag & GP_COLOR_INVERT_MATERIAL,
1734 legacy_md_color.flag & GP_COLOR_INVERT_PASS,
1735 "",
1736 false,
1737 &legacy_md_color.curve_intensity,
1738 legacy_md_color.flag & GP_COLOR_CUSTOM_CURVE);
1739}
1740
1741static void legacy_object_modifier_dash(ConversionData &conversion_data,
1742 Object &object,
1743 GpencilModifierData &legacy_md)
1744{
1746 conversion_data, object, eModifierType_GreasePencilDash, legacy_md);
1747 auto &md_dash = reinterpret_cast<GreasePencilDashModifierData &>(md);
1748 auto &legacy_md_dash = reinterpret_cast<DashGpencilModifierData &>(legacy_md);
1749
1750 md_dash.dash_offset = legacy_md_dash.dash_offset;
1751 md_dash.segment_active_index = legacy_md_dash.segment_active_index;
1752 md_dash.segments_num = legacy_md_dash.segments_len;
1753 MEM_SAFE_DELETE(md_dash.segments_array);
1754 md_dash.segments_array = MEM_new_array<GreasePencilDashModifierSegment>(
1755 legacy_md_dash.segments_len, __func__);
1756 for (const int i : IndexRange(md_dash.segments_num)) {
1757 GreasePencilDashModifierSegment &dst_segment = md_dash.segments_array[i];
1758 const DashGpencilModifierSegment &src_segment = legacy_md_dash.segments[i];
1759 STRNCPY(dst_segment.name, src_segment.name);
1760 dst_segment.flag = GreasePencilDashModifierFlag{};
1761 if (src_segment.flag & GP_DASH_USE_CYCLIC) {
1763 }
1764 dst_segment.dash = src_segment.dash;
1765 dst_segment.gap = src_segment.gap;
1766 dst_segment.opacity = src_segment.opacity;
1767 dst_segment.radius = src_segment.radius;
1768 dst_segment.mat_nr = src_segment.mat_nr;
1769 }
1770
1771 legacy_object_modifier_influence(md_dash.influence,
1772 legacy_md_dash.layername,
1773 legacy_md_dash.layer_pass,
1774 legacy_md_dash.flag & GP_DASH_INVERT_LAYER,
1775 legacy_md_dash.flag & GP_DASH_INVERT_LAYERPASS,
1776 &legacy_md_dash.material,
1777 legacy_md_dash.pass_index,
1778 legacy_md_dash.flag & GP_DASH_INVERT_MATERIAL,
1779 legacy_md_dash.flag & GP_DASH_INVERT_PASS,
1780 "",
1781 false,
1782 nullptr,
1783 false);
1784}
1785
1787 Object &object,
1788 GpencilModifierData &legacy_md)
1789{
1791 conversion_data, object, eModifierType_GreasePencilEnvelope, legacy_md);
1792 auto &md_envelope = reinterpret_cast<GreasePencilEnvelopeModifierData &>(md);
1793 auto &legacy_md_envelope = reinterpret_cast<EnvelopeGpencilModifierData &>(legacy_md);
1794
1795 switch (eEnvelopeGpencil_Mode(legacy_md_envelope.mode)) {
1796 case GP_ENVELOPE_DEFORM:
1797 md_envelope.mode = MOD_GREASE_PENCIL_ENVELOPE_DEFORM;
1798 break;
1800 md_envelope.mode = MOD_GREASE_PENCIL_ENVELOPE_SEGMENTS;
1801 break;
1802 case GP_ENVELOPE_FILLS:
1803 md_envelope.mode = MOD_GREASE_PENCIL_ENVELOPE_FILLS;
1804 break;
1805 }
1806 md_envelope.mat_nr = legacy_md_envelope.mat_nr;
1807 md_envelope.thickness = legacy_md_envelope.thickness;
1808 md_envelope.strength = legacy_md_envelope.strength;
1809 md_envelope.skip = legacy_md_envelope.skip;
1810 md_envelope.spread = legacy_md_envelope.spread;
1811
1812 legacy_object_modifier_influence(md_envelope.influence,
1813 legacy_md_envelope.layername,
1814 legacy_md_envelope.layer_pass,
1815 legacy_md_envelope.flag & GP_ENVELOPE_INVERT_LAYER,
1816 legacy_md_envelope.flag & GP_ENVELOPE_INVERT_LAYERPASS,
1817 &legacy_md_envelope.material,
1818 legacy_md_envelope.pass_index,
1819 legacy_md_envelope.flag & GP_ENVELOPE_INVERT_MATERIAL,
1820 legacy_md_envelope.flag & GP_ENVELOPE_INVERT_PASS,
1821 legacy_md_envelope.vgname,
1822 legacy_md_envelope.flag & GP_ENVELOPE_INVERT_VGROUP,
1823 nullptr,
1824 false);
1825}
1826
1827static void legacy_object_modifier_hook(ConversionData &conversion_data,
1828 Object &object,
1829 GpencilModifierData &legacy_md)
1830{
1832 conversion_data, object, eModifierType_GreasePencilHook, legacy_md);
1833 auto &md_hook = reinterpret_cast<GreasePencilHookModifierData &>(md);
1834 auto &legacy_md_hook = reinterpret_cast<HookGpencilModifierData &>(legacy_md);
1835
1836 md_hook.flag = GreasePencilHookFlag{};
1837 if (legacy_md_hook.flag & GP_HOOK_UNIFORM_SPACE) {
1839 }
1840 switch (eHookGpencil_Falloff(legacy_md_hook.falloff_type)) {
1842 md_hook.falloff_type = MOD_GREASE_PENCIL_HOOK_Falloff_None;
1843 break;
1845 md_hook.falloff_type = MOD_GREASE_PENCIL_HOOK_Falloff_Curve;
1846 break;
1848 md_hook.falloff_type = MOD_GREASE_PENCIL_HOOK_Falloff_Sharp;
1849 break;
1851 md_hook.falloff_type = MOD_GREASE_PENCIL_HOOK_Falloff_Smooth;
1852 break;
1854 md_hook.falloff_type = MOD_GREASE_PENCIL_HOOK_Falloff_Root;
1855 break;
1857 md_hook.falloff_type = MOD_GREASE_PENCIL_HOOK_Falloff_Linear;
1858 break;
1860 md_hook.falloff_type = MOD_GREASE_PENCIL_HOOK_Falloff_Const;
1861 break;
1863 md_hook.falloff_type = MOD_GREASE_PENCIL_HOOK_Falloff_Sphere;
1864 break;
1866 md_hook.falloff_type = MOD_GREASE_PENCIL_HOOK_Falloff_InvSquare;
1867 break;
1868 }
1869 md_hook.object = legacy_md_hook.object;
1870 legacy_md_hook.object = nullptr;
1871 STRNCPY(md_hook.subtarget, legacy_md_hook.subtarget);
1872 copy_m4_m4(md_hook.parentinv, legacy_md_hook.parentinv);
1873 copy_v3_v3(md_hook.cent, legacy_md_hook.cent);
1874 md_hook.falloff = legacy_md_hook.falloff;
1875 md_hook.force = legacy_md_hook.force;
1876
1877 legacy_object_modifier_influence(md_hook.influence,
1878 legacy_md_hook.layername,
1879 legacy_md_hook.layer_pass,
1880 legacy_md_hook.flag & GP_HOOK_INVERT_LAYER,
1881 legacy_md_hook.flag & GP_HOOK_INVERT_LAYERPASS,
1882 &legacy_md_hook.material,
1883 legacy_md_hook.pass_index,
1884 legacy_md_hook.flag & GP_HOOK_INVERT_MATERIAL,
1885 legacy_md_hook.flag & GP_HOOK_INVERT_PASS,
1886 legacy_md_hook.vgname,
1887 legacy_md_hook.flag & GP_HOOK_INVERT_VGROUP,
1888 &legacy_md_hook.curfalloff,
1889 true);
1890}
1891
1893 Object &object,
1894 GpencilModifierData &legacy_md)
1895{
1897 conversion_data, object, eModifierType_GreasePencilLattice, legacy_md);
1898 auto &md_lattice = reinterpret_cast<GreasePencilLatticeModifierData &>(md);
1899 auto &legacy_md_lattice = reinterpret_cast<LatticeGpencilModifierData &>(legacy_md);
1900
1901 md_lattice.object = legacy_md_lattice.object;
1902 legacy_md_lattice.object = nullptr;
1903 md_lattice.strength = legacy_md_lattice.strength;
1904
1905 legacy_object_modifier_influence(md_lattice.influence,
1906 legacy_md_lattice.layername,
1907 legacy_md_lattice.layer_pass,
1908 legacy_md_lattice.flag & GP_LATTICE_INVERT_LAYER,
1909 legacy_md_lattice.flag & GP_LATTICE_INVERT_LAYERPASS,
1910 &legacy_md_lattice.material,
1911 legacy_md_lattice.pass_index,
1912 legacy_md_lattice.flag & GP_LATTICE_INVERT_MATERIAL,
1913 legacy_md_lattice.flag & GP_LATTICE_INVERT_PASS,
1914 legacy_md_lattice.vgname,
1915 legacy_md_lattice.flag & GP_LATTICE_INVERT_VGROUP,
1916 nullptr,
1917 false);
1918}
1919
1921 Object &object,
1922 GpencilModifierData &legacy_md)
1923{
1925 conversion_data, object, eModifierType_GreasePencilLength, legacy_md);
1926 auto &md_length = reinterpret_cast<GreasePencilLengthModifierData &>(md);
1927 auto &legacy_md_length = reinterpret_cast<LengthGpencilModifierData &>(legacy_md);
1928
1929 md_length.flag = legacy_md_length.flag;
1930 md_length.start_fac = legacy_md_length.start_fac;
1931 md_length.end_fac = legacy_md_length.end_fac;
1932 md_length.rand_start_fac = legacy_md_length.rand_start_fac;
1933 md_length.rand_end_fac = legacy_md_length.rand_end_fac;
1934 md_length.rand_offset = legacy_md_length.rand_offset;
1935 md_length.overshoot_fac = legacy_md_length.overshoot_fac;
1936 md_length.seed = legacy_md_length.seed;
1937 md_length.step = legacy_md_length.step;
1938 md_length.mode = legacy_md_length.mode;
1939 md_length.point_density = legacy_md_length.point_density;
1940 md_length.segment_influence = legacy_md_length.segment_influence;
1941 md_length.max_angle = legacy_md_length.max_angle;
1942
1943 legacy_object_modifier_influence(md_length.influence,
1944 legacy_md_length.layername,
1945 legacy_md_length.layer_pass,
1946 legacy_md_length.flag & GP_LENGTH_INVERT_LAYER,
1947 legacy_md_length.flag & GP_LENGTH_INVERT_LAYERPASS,
1948 &legacy_md_length.material,
1949 legacy_md_length.pass_index,
1950 legacy_md_length.flag & GP_LENGTH_INVERT_MATERIAL,
1951 legacy_md_length.flag & GP_LENGTH_INVERT_PASS,
1952 "",
1953 false,
1954 nullptr,
1955 false);
1956}
1957
1959 Object &object,
1960 GpencilModifierData &legacy_md)
1961{
1963 conversion_data, object, eModifierType_GreasePencilMirror, legacy_md);
1964 auto &md_mirror = reinterpret_cast<GreasePencilMirrorModifierData &>(md);
1965 auto &legacy_md_mirror = reinterpret_cast<MirrorGpencilModifierData &>(legacy_md);
1966
1967 md_mirror.object = legacy_md_mirror.object;
1968 legacy_md_mirror.object = nullptr;
1970 if (legacy_md_mirror.flag & GP_MIRROR_AXIS_X) {
1971 md_mirror.flag |= MOD_GREASE_PENCIL_MIRROR_AXIS_X;
1972 }
1973 if (legacy_md_mirror.flag & GP_MIRROR_AXIS_Y) {
1974 md_mirror.flag |= MOD_GREASE_PENCIL_MIRROR_AXIS_Y;
1975 }
1976 if (legacy_md_mirror.flag & GP_MIRROR_AXIS_Z) {
1977 md_mirror.flag |= MOD_GREASE_PENCIL_MIRROR_AXIS_Z;
1978 }
1979
1980 legacy_object_modifier_influence(md_mirror.influence,
1981 legacy_md_mirror.layername,
1982 legacy_md_mirror.layer_pass,
1983 legacy_md_mirror.flag & GP_MIRROR_INVERT_LAYER,
1984 legacy_md_mirror.flag & GP_MIRROR_INVERT_LAYERPASS,
1985 &legacy_md_mirror.material,
1986 legacy_md_mirror.pass_index,
1987 legacy_md_mirror.flag & GP_MIRROR_INVERT_MATERIAL,
1988 legacy_md_mirror.flag & GP_MIRROR_INVERT_PASS,
1989 "",
1990 false,
1991 nullptr,
1992 false);
1993}
1994
1996 Object &object,
1997 GpencilModifierData &legacy_md)
1998{
2000 conversion_data, object, eModifierType_GreasePencilMultiply, legacy_md);
2001 auto &md_multiply = reinterpret_cast<GreasePencilMultiModifierData &>(md);
2002 auto &legacy_md_multiply = reinterpret_cast<MultiplyGpencilModifierData &>(legacy_md);
2003
2004 md_multiply.flag = GreasePencilMultiplyModifierFlag{};
2005 if (legacy_md_multiply.flags & GP_MULTIPLY_ENABLE_FADING) {
2006 md_multiply.flag |= MOD_GREASE_PENCIL_MULTIPLY_ENABLE_FADING;
2007 }
2008 md_multiply.duplications = legacy_md_multiply.duplications;
2009 md_multiply.distance = legacy_md_multiply.distance;
2010 md_multiply.offset = legacy_md_multiply.offset;
2011 md_multiply.fading_center = legacy_md_multiply.fading_center;
2012 md_multiply.fading_thickness = legacy_md_multiply.fading_thickness;
2013 md_multiply.fading_opacity = legacy_md_multiply.fading_opacity;
2014
2015 /* NOTE: This looks wrong, but GPv2 version uses Mirror modifier flags in its `flag` property
2016 * and own flags in its `flags` property. */
2017 legacy_object_modifier_influence(md_multiply.influence,
2018 legacy_md_multiply.layername,
2019 legacy_md_multiply.layer_pass,
2020 legacy_md_multiply.flag & GP_MIRROR_INVERT_LAYER,
2021 legacy_md_multiply.flag & GP_MIRROR_INVERT_LAYERPASS,
2022 &legacy_md_multiply.material,
2023 legacy_md_multiply.pass_index,
2024 legacy_md_multiply.flag & GP_MIRROR_INVERT_MATERIAL,
2025 legacy_md_multiply.flag & GP_MIRROR_INVERT_PASS,
2026 "",
2027 false,
2028 nullptr,
2029 false);
2030}
2031
2033 Object &object,
2034 GpencilModifierData &legacy_md)
2035{
2037 conversion_data, object, eModifierType_GreasePencilNoise, legacy_md);
2038 auto &md_noise = reinterpret_cast<GreasePencilNoiseModifierData &>(md);
2039 auto &legacy_md_noise = reinterpret_cast<NoiseGpencilModifierData &>(legacy_md);
2040
2041 md_noise.flag = legacy_md_noise.flag;
2042 md_noise.factor = legacy_md_noise.factor;
2043 md_noise.factor_strength = legacy_md_noise.factor_strength;
2044 md_noise.factor_thickness = legacy_md_noise.factor_thickness;
2045 md_noise.factor_uvs = legacy_md_noise.factor_uvs;
2046 md_noise.noise_scale = legacy_md_noise.noise_scale;
2047 md_noise.noise_offset = legacy_md_noise.noise_offset;
2048 md_noise.noise_mode = legacy_md_noise.noise_mode;
2049 md_noise.step = legacy_md_noise.step;
2050 md_noise.seed = legacy_md_noise.seed;
2051
2052 legacy_object_modifier_influence(md_noise.influence,
2053 legacy_md_noise.layername,
2054 legacy_md_noise.layer_pass,
2055 legacy_md_noise.flag & GP_NOISE_INVERT_LAYER,
2056 legacy_md_noise.flag & GP_NOISE_INVERT_LAYERPASS,
2057 &legacy_md_noise.material,
2058 legacy_md_noise.pass_index,
2059 legacy_md_noise.flag & GP_NOISE_INVERT_MATERIAL,
2060 legacy_md_noise.flag & GP_NOISE_INVERT_PASS,
2061 legacy_md_noise.vgname,
2062 legacy_md_noise.flag & GP_NOISE_INVERT_VGROUP,
2063 &legacy_md_noise.curve_intensity,
2064 legacy_md_noise.flag & GP_NOISE_CUSTOM_CURVE);
2065}
2066
2068 Object &object,
2069 GpencilModifierData &legacy_md)
2070{
2072 conversion_data, object, eModifierType_GreasePencilOffset, legacy_md);
2073 auto &md_offset = reinterpret_cast<GreasePencilOffsetModifierData &>(md);
2074 auto &legacy_md_offset = reinterpret_cast<OffsetGpencilModifierData &>(legacy_md);
2075
2077 if (legacy_md_offset.flag & GP_OFFSET_UNIFORM_RANDOM_SCALE) {
2079 }
2080 switch (eOffsetGpencil_Mode(legacy_md_offset.mode)) {
2081 case GP_OFFSET_RANDOM:
2082 md_offset.offset_mode = MOD_GREASE_PENCIL_OFFSET_RANDOM;
2083 break;
2084 case GP_OFFSET_LAYER:
2085 md_offset.offset_mode = MOD_GREASE_PENCIL_OFFSET_LAYER;
2086 break;
2087 case GP_OFFSET_MATERIAL:
2088 md_offset.offset_mode = MOD_GREASE_PENCIL_OFFSET_MATERIAL;
2089 break;
2090 case GP_OFFSET_STROKE:
2091 md_offset.offset_mode = MOD_GREASE_PENCIL_OFFSET_STROKE;
2092 break;
2093 }
2094 copy_v3_v3(md_offset.loc, legacy_md_offset.loc);
2095 copy_v3_v3(md_offset.rot, legacy_md_offset.rot);
2096 copy_v3_v3(md_offset.scale, legacy_md_offset.scale);
2097 copy_v3_v3(md_offset.stroke_loc, legacy_md_offset.rnd_offset);
2098 copy_v3_v3(md_offset.stroke_rot, legacy_md_offset.rnd_rot);
2099 copy_v3_v3(md_offset.stroke_scale, legacy_md_offset.rnd_scale);
2100 md_offset.seed = legacy_md_offset.seed;
2101 md_offset.stroke_step = legacy_md_offset.stroke_step;
2102 md_offset.stroke_start_offset = legacy_md_offset.stroke_start_offset;
2103
2104 legacy_object_modifier_influence(md_offset.influence,
2105 legacy_md_offset.layername,
2106 legacy_md_offset.layer_pass,
2107 legacy_md_offset.flag & GP_OFFSET_INVERT_LAYER,
2108 legacy_md_offset.flag & GP_OFFSET_INVERT_LAYERPASS,
2109 &legacy_md_offset.material,
2110 legacy_md_offset.pass_index,
2111 legacy_md_offset.flag & GP_OFFSET_INVERT_MATERIAL,
2112 legacy_md_offset.flag & GP_OFFSET_INVERT_PASS,
2113 legacy_md_offset.vgname,
2114 legacy_md_offset.flag & GP_OFFSET_INVERT_VGROUP,
2115 nullptr,
2116 false);
2117}
2118
2120 Object &object,
2121 GpencilModifierData &legacy_md)
2122{
2124 conversion_data, object, eModifierType_GreasePencilOpacity, legacy_md);
2125 auto &md_opacity = reinterpret_cast<GreasePencilOpacityModifierData &>(md);
2126 auto &legacy_md_opacity = reinterpret_cast<OpacityGpencilModifierData &>(legacy_md);
2127
2129 if (legacy_md_opacity.flag & GP_OPACITY_NORMALIZE) {
2131 }
2132 if (legacy_md_opacity.flag & GP_OPACITY_WEIGHT_FACTOR) {
2134 }
2135 switch (eModifyColorGpencil_Flag(legacy_md_opacity.modify_color)) {
2137 md_opacity.color_mode = MOD_GREASE_PENCIL_COLOR_BOTH;
2138 break;
2140 md_opacity.color_mode = MOD_GREASE_PENCIL_COLOR_STROKE;
2141 break;
2143 md_opacity.color_mode = MOD_GREASE_PENCIL_COLOR_FILL;
2144 break;
2146 md_opacity.color_mode = MOD_GREASE_PENCIL_COLOR_HARDNESS;
2147 break;
2148 }
2149 md_opacity.color_factor = legacy_md_opacity.factor;
2150 md_opacity.hardness_factor = legacy_md_opacity.hardness;
2151
2152 /* Account for animation on renamed properties. */
2153 char modifier_name[MAX_NAME * 2];
2154 BLI_str_escape(modifier_name, md.name, sizeof(modifier_name));
2155 AnimDataConvertor anim_convertor_factor(
2156 conversion_data, object.id, object.id, {{".factor", ".color_factor"}});
2157 anim_convertor_factor.root_path_src = fmt::format("modifiers[\"{}\"]", modifier_name);
2158 anim_convertor_factor.root_path_dst = fmt::format("modifiers[\"{}\"]", modifier_name);
2159 anim_convertor_factor.fcurves_convert();
2160 anim_convertor_factor.fcurves_convert_finalize();
2161 AnimDataConvertor anim_convertor_hardness(
2162 conversion_data, object.id, object.id, {{".hardness", ".hardness_factor"}});
2163 anim_convertor_hardness.root_path_src = fmt::format("modifiers[\"{}\"]", modifier_name);
2164 anim_convertor_hardness.root_path_dst = fmt::format("modifiers[\"{}\"]", modifier_name);
2165 anim_convertor_hardness.fcurves_convert();
2166 anim_convertor_hardness.fcurves_convert_finalize();
2167 DEG_relations_tag_update(&conversion_data.bmain);
2168
2169 legacy_object_modifier_influence(md_opacity.influence,
2170 legacy_md_opacity.layername,
2171 legacy_md_opacity.layer_pass,
2172 legacy_md_opacity.flag & GP_OPACITY_INVERT_LAYER,
2173 legacy_md_opacity.flag & GP_OPACITY_INVERT_LAYERPASS,
2174 &legacy_md_opacity.material,
2175 legacy_md_opacity.pass_index,
2176 legacy_md_opacity.flag & GP_OPACITY_INVERT_MATERIAL,
2177 legacy_md_opacity.flag & GP_OPACITY_INVERT_PASS,
2178 legacy_md_opacity.vgname,
2179 legacy_md_opacity.flag & GP_OPACITY_INVERT_VGROUP,
2180 &legacy_md_opacity.curve_intensity,
2181 legacy_md_opacity.flag & GP_OPACITY_CUSTOM_CURVE);
2182}
2183
2185 Object &object,
2186 GpencilModifierData &legacy_md)
2187{
2189 conversion_data, object, eModifierType_GreasePencilOutline, legacy_md);
2190 auto &md_outline = reinterpret_cast<GreasePencilOutlineModifierData &>(md);
2191 auto &legacy_md_outline = reinterpret_cast<OutlineGpencilModifierData &>(legacy_md);
2192
2194 if (legacy_md_outline.flag & GP_OUTLINE_KEEP_SHAPE) {
2195 md_outline.flag |= MOD_GREASE_PENCIL_OUTLINE_KEEP_SHAPE;
2196 }
2197 md_outline.object = legacy_md_outline.object;
2198 legacy_md_outline.object = nullptr;
2199 md_outline.outline_material = legacy_md_outline.outline_material;
2200 legacy_md_outline.outline_material = nullptr;
2201 md_outline.sample_length = legacy_md_outline.sample_length;
2202 md_outline.subdiv = legacy_md_outline.subdiv;
2203 md_outline.thickness = legacy_md_outline.thickness;
2204
2205 legacy_object_modifier_influence(md_outline.influence,
2206 legacy_md_outline.layername,
2207 legacy_md_outline.layer_pass,
2208 legacy_md_outline.flag & GP_OUTLINE_INVERT_LAYER,
2209 legacy_md_outline.flag & GP_OUTLINE_INVERT_LAYERPASS,
2210 &legacy_md_outline.material,
2211 legacy_md_outline.pass_index,
2212 legacy_md_outline.flag & GP_OUTLINE_INVERT_MATERIAL,
2213 legacy_md_outline.flag & GP_OUTLINE_INVERT_PASS,
2214 "",
2215 false,
2216 nullptr,
2217 false);
2218}
2219
2221 Object &object,
2222 GpencilModifierData &legacy_md)
2223{
2225 conversion_data, object, eModifierType_GreasePencilShrinkwrap, legacy_md);
2226 auto &md_shrinkwrap = reinterpret_cast<GreasePencilShrinkwrapModifierData &>(md);
2227 auto &legacy_md_shrinkwrap = reinterpret_cast<ShrinkwrapGpencilModifierData &>(legacy_md);
2228
2229 /* Shrinkwrap enums and flags do not have named types. */
2230 /* MOD_SHRINKWRAP_NEAREST_SURFACE etc. */
2231 md_shrinkwrap.shrink_type = legacy_md_shrinkwrap.shrink_type;
2232 /* MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR etc. */
2233 md_shrinkwrap.shrink_opts = legacy_md_shrinkwrap.shrink_opts;
2234 /* MOD_SHRINKWRAP_ON_SURFACE etc. */
2235 md_shrinkwrap.shrink_mode = legacy_md_shrinkwrap.shrink_mode;
2236 /* MOD_SHRINKWRAP_PROJECT_OVER_NORMAL etc. */
2237 md_shrinkwrap.proj_axis = legacy_md_shrinkwrap.proj_axis;
2238
2239 md_shrinkwrap.target = legacy_md_shrinkwrap.target;
2240 legacy_md_shrinkwrap.target = nullptr;
2241 md_shrinkwrap.aux_target = legacy_md_shrinkwrap.aux_target;
2242 legacy_md_shrinkwrap.aux_target = nullptr;
2243 md_shrinkwrap.keep_dist = legacy_md_shrinkwrap.keep_dist;
2244 md_shrinkwrap.proj_limit = legacy_md_shrinkwrap.proj_limit;
2245 md_shrinkwrap.subsurf_levels = legacy_md_shrinkwrap.subsurf_levels;
2246 md_shrinkwrap.smooth_factor = legacy_md_shrinkwrap.smooth_factor;
2247 md_shrinkwrap.smooth_step = legacy_md_shrinkwrap.smooth_step;
2248
2249 legacy_object_modifier_influence(md_shrinkwrap.influence,
2250 legacy_md_shrinkwrap.layername,
2251 legacy_md_shrinkwrap.layer_pass,
2252 legacy_md_shrinkwrap.flag & GP_SHRINKWRAP_INVERT_LAYER,
2253 legacy_md_shrinkwrap.flag & GP_SHRINKWRAP_INVERT_LAYERPASS,
2254 &legacy_md_shrinkwrap.material,
2255 legacy_md_shrinkwrap.pass_index,
2256 legacy_md_shrinkwrap.flag & GP_SHRINKWRAP_INVERT_MATERIAL,
2257 legacy_md_shrinkwrap.flag & GP_SHRINKWRAP_INVERT_PASS,
2258 legacy_md_shrinkwrap.vgname,
2259 legacy_md_shrinkwrap.flag & GP_SHRINKWRAP_INVERT_VGROUP,
2260 nullptr,
2261 false);
2262}
2263
2265 Object &object,
2266 GpencilModifierData &legacy_md)
2267{
2269 conversion_data, object, eModifierType_GreasePencilSmooth, legacy_md);
2270 auto &md_smooth = reinterpret_cast<GreasePencilSmoothModifierData &>(md);
2271 auto &legacy_md_smooth = reinterpret_cast<SmoothGpencilModifierData &>(legacy_md);
2272
2273 md_smooth.flag = eGreasePencilSmooth_Flag{};
2274 if (legacy_md_smooth.flag & GP_SMOOTH_MOD_LOCATION) {
2275 md_smooth.flag |= MOD_GREASE_PENCIL_SMOOTH_MOD_LOCATION;
2276 }
2277 if (legacy_md_smooth.flag & GP_SMOOTH_MOD_STRENGTH) {
2278 md_smooth.flag |= MOD_GREASE_PENCIL_SMOOTH_MOD_STRENGTH;
2279 }
2280 if (legacy_md_smooth.flag & GP_SMOOTH_MOD_THICKNESS) {
2282 }
2283 if (legacy_md_smooth.flag & GP_SMOOTH_MOD_UV) {
2284 md_smooth.flag |= MOD_GREASE_PENCIL_SMOOTH_MOD_UV;
2285 }
2286 if (legacy_md_smooth.flag & GP_SMOOTH_KEEP_SHAPE) {
2287 md_smooth.flag |= MOD_GREASE_PENCIL_SMOOTH_KEEP_SHAPE;
2288 }
2289 md_smooth.factor = legacy_md_smooth.factor;
2290 md_smooth.step = legacy_md_smooth.step;
2291
2292 legacy_object_modifier_influence(md_smooth.influence,
2293 legacy_md_smooth.layername,
2294 legacy_md_smooth.layer_pass,
2295 legacy_md_smooth.flag & GP_SMOOTH_INVERT_LAYER,
2296 legacy_md_smooth.flag & GP_SMOOTH_INVERT_LAYERPASS,
2297 &legacy_md_smooth.material,
2298 legacy_md_smooth.pass_index,
2299 legacy_md_smooth.flag & GP_SMOOTH_INVERT_MATERIAL,
2300 legacy_md_smooth.flag & GP_SMOOTH_INVERT_PASS,
2301 legacy_md_smooth.vgname,
2302 legacy_md_smooth.flag & GP_SMOOTH_INVERT_VGROUP,
2303 &legacy_md_smooth.curve_intensity,
2304 legacy_md_smooth.flag & GP_SMOOTH_CUSTOM_CURVE);
2305}
2306
2308 Object &object,
2309 GpencilModifierData &legacy_md)
2310{
2312 conversion_data, object, eModifierType_GreasePencilSubdiv, legacy_md);
2313 auto &md_subdiv = reinterpret_cast<GreasePencilSubdivModifierData &>(md);
2314 auto &legacy_md_subdiv = reinterpret_cast<SubdivGpencilModifierData &>(legacy_md);
2315
2316 switch (eSubdivGpencil_Type(legacy_md_subdiv.type)) {
2317 case GP_SUBDIV_CATMULL:
2318 md_subdiv.type = MOD_GREASE_PENCIL_SUBDIV_CATMULL;
2319 break;
2320 case GP_SUBDIV_SIMPLE:
2321 md_subdiv.type = MOD_GREASE_PENCIL_SUBDIV_SIMPLE;
2322 break;
2323 }
2324 md_subdiv.level = legacy_md_subdiv.level;
2325
2326 legacy_object_modifier_influence(md_subdiv.influence,
2327 legacy_md_subdiv.layername,
2328 legacy_md_subdiv.layer_pass,
2329 legacy_md_subdiv.flag & GP_SUBDIV_INVERT_LAYER,
2330 legacy_md_subdiv.flag & GP_SUBDIV_INVERT_LAYERPASS,
2331 &legacy_md_subdiv.material,
2332 legacy_md_subdiv.pass_index,
2333 legacy_md_subdiv.flag & GP_SUBDIV_INVERT_MATERIAL,
2334 legacy_md_subdiv.flag & GP_SUBDIV_INVERT_PASS,
2335 "",
2336 false,
2337 nullptr,
2338 false);
2339}
2340
2342 Object &object,
2343 GpencilModifierData &legacy_md)
2344{
2346 conversion_data, object, eModifierType_GreasePencilTexture, legacy_md);
2347 auto &md_texture = reinterpret_cast<GreasePencilTextureModifierData &>(md);
2348 auto &legacy_md_texture = reinterpret_cast<TextureGpencilModifierData &>(legacy_md);
2349
2350 switch (eTextureGpencil_Mode(legacy_md_texture.mode)) {
2351 case STROKE:
2352 md_texture.mode = MOD_GREASE_PENCIL_TEXTURE_STROKE;
2353 break;
2354 case FILL:
2355 md_texture.mode = MOD_GREASE_PENCIL_TEXTURE_FILL;
2356 break;
2357 case STROKE_AND_FILL:
2359 break;
2360 }
2361 switch (eTextureGpencil_Fit(legacy_md_texture.fit_method)) {
2362 case GP_TEX_FIT_STROKE:
2363 md_texture.fit_method = MOD_GREASE_PENCIL_TEXTURE_FIT_STROKE;
2364 break;
2366 md_texture.fit_method = MOD_GREASE_PENCIL_TEXTURE_CONSTANT_LENGTH;
2367 break;
2368 }
2369 md_texture.uv_offset = legacy_md_texture.uv_offset;
2370 md_texture.uv_scale = legacy_md_texture.uv_scale;
2371 md_texture.fill_rotation = legacy_md_texture.fill_rotation;
2372 copy_v2_v2(md_texture.fill_offset, legacy_md_texture.fill_offset);
2373 md_texture.fill_scale = legacy_md_texture.fill_scale;
2374 md_texture.layer_pass = legacy_md_texture.layer_pass;
2375 md_texture.alignment_rotation = legacy_md_texture.alignment_rotation;
2376
2377 legacy_object_modifier_influence(md_texture.influence,
2378 legacy_md_texture.layername,
2379 legacy_md_texture.layer_pass,
2380 legacy_md_texture.flag & GP_TEX_INVERT_LAYER,
2381 legacy_md_texture.flag & GP_TEX_INVERT_LAYERPASS,
2382 &legacy_md_texture.material,
2383 legacy_md_texture.pass_index,
2384 legacy_md_texture.flag & GP_TEX_INVERT_MATERIAL,
2385 legacy_md_texture.flag & GP_TEX_INVERT_PASS,
2386 legacy_md_texture.vgname,
2387 legacy_md_texture.flag & GP_TEX_INVERT_VGROUP,
2388 nullptr,
2389 false);
2390}
2391
2393 Object &object,
2394 GpencilModifierData &legacy_md)
2395{
2397 conversion_data, object, eModifierType_GreasePencilThickness, legacy_md);
2398 auto &md_thickness = reinterpret_cast<GreasePencilThickModifierData &>(md);
2399 auto &legacy_md_thickness = reinterpret_cast<ThickGpencilModifierData &>(legacy_md);
2400
2401 md_thickness.flag = GreasePencilThicknessModifierFlag{};
2402 if (legacy_md_thickness.flag & GP_THICK_NORMALIZE) {
2403 md_thickness.flag |= MOD_GREASE_PENCIL_THICK_NORMALIZE;
2404 }
2405 if (legacy_md_thickness.flag & GP_THICK_WEIGHT_FACTOR) {
2406 md_thickness.flag |= MOD_GREASE_PENCIL_THICK_WEIGHT_FACTOR;
2407 }
2408 md_thickness.thickness_fac = legacy_md_thickness.thickness_fac;
2409 md_thickness.thickness = legacy_md_thickness.thickness * LEGACY_RADIUS_CONVERSION_FACTOR;
2410
2411 legacy_object_modifier_influence(md_thickness.influence,
2412 legacy_md_thickness.layername,
2413 legacy_md_thickness.layer_pass,
2414 legacy_md_thickness.flag & GP_THICK_INVERT_LAYER,
2415 legacy_md_thickness.flag & GP_THICK_INVERT_LAYERPASS,
2416 &legacy_md_thickness.material,
2417 legacy_md_thickness.pass_index,
2418 legacy_md_thickness.flag & GP_THICK_INVERT_MATERIAL,
2419 legacy_md_thickness.flag & GP_THICK_INVERT_PASS,
2420 legacy_md_thickness.vgname,
2421 legacy_md_thickness.flag & GP_THICK_INVERT_VGROUP,
2422 &legacy_md_thickness.curve_thickness,
2423 legacy_md_thickness.flag & GP_THICK_CUSTOM_CURVE);
2424}
2425
2426static void legacy_object_modifier_time(ConversionData &conversion_data,
2427 Object &object,
2428 GpencilModifierData &legacy_md)
2429{
2431 conversion_data, object, eModifierType_GreasePencilTime, legacy_md);
2432 auto &md_time = reinterpret_cast<GreasePencilTimeModifierData &>(md);
2433 auto &legacy_md_time = reinterpret_cast<TimeGpencilModifierData &>(legacy_md);
2434
2436 if (legacy_md_time.flag & GP_TIME_CUSTOM_RANGE) {
2438 }
2439 if (legacy_md_time.flag & GP_TIME_KEEP_LOOP) {
2440 md_time.flag |= MOD_GREASE_PENCIL_TIME_KEEP_LOOP;
2441 }
2442 switch (eTimeGpencil_Mode(legacy_md_time.mode)) {
2445 break;
2448 break;
2449 case GP_TIME_MODE_FIX:
2450 md_time.mode = MOD_GREASE_PENCIL_TIME_MODE_FIX;
2451 break;
2454 break;
2455 case GP_TIME_MODE_CHAIN:
2456 md_time.mode = MOD_GREASE_PENCIL_TIME_MODE_CHAIN;
2457 break;
2458 }
2459 md_time.offset = legacy_md_time.offset;
2460 md_time.frame_scale = legacy_md_time.frame_scale;
2461 md_time.sfra = legacy_md_time.sfra;
2462 md_time.efra = legacy_md_time.efra;
2463 md_time.segment_active_index = legacy_md_time.segment_active_index;
2464 md_time.segments_num = legacy_md_time.segments_len;
2465 MEM_SAFE_DELETE(md_time.segments_array);
2466 md_time.segments_array = MEM_new_array<GreasePencilTimeModifierSegment>(
2467 legacy_md_time.segments_len, __func__);
2468 for (const int i : IndexRange(md_time.segments_num)) {
2469 GreasePencilTimeModifierSegment &dst_segment = md_time.segments_array[i];
2470 const TimeGpencilModifierSegment &src_segment = legacy_md_time.segments[i];
2471 STRNCPY(dst_segment.name, src_segment.name);
2472 switch (eTimeGpencil_Seg_Mode(src_segment.seg_mode)) {
2475 break;
2478 break;
2481 break;
2482 }
2483 dst_segment.segment_start = src_segment.seg_start;
2484 dst_segment.segment_end = src_segment.seg_end;
2485 dst_segment.segment_repeat = src_segment.seg_repeat;
2486 }
2487
2488 /* NOTE: GPv2 time modifier has a material pointer but it is unused. */
2489 legacy_object_modifier_influence(md_time.influence,
2490 legacy_md_time.layername,
2491 legacy_md_time.layer_pass,
2492 legacy_md_time.flag & GP_TIME_INVERT_LAYER,
2493 legacy_md_time.flag & GP_TIME_INVERT_LAYERPASS,
2494 nullptr,
2495 0,
2496 false,
2497 false,
2498 "",
2499 false,
2500 nullptr,
2501 false);
2502}
2503
2504static void legacy_object_modifier_tint(ConversionData &conversion_data,
2505 Object &object,
2506 GpencilModifierData &legacy_md)
2507{
2509 conversion_data, object, eModifierType_GreasePencilTint, legacy_md);
2510 auto &md_tint = reinterpret_cast<GreasePencilTintModifierData &>(md);
2511 auto &legacy_md_tint = reinterpret_cast<TintGpencilModifierData &>(legacy_md);
2512
2514 if (legacy_md_tint.flag & GP_TINT_WEIGHT_FACTOR) {
2516 }
2517 switch (eGp_Vertex_Mode(legacy_md_tint.mode)) {
2518 case GPPAINT_MODE_BOTH:
2519 md_tint.color_mode = MOD_GREASE_PENCIL_COLOR_BOTH;
2520 break;
2522 md_tint.color_mode = MOD_GREASE_PENCIL_COLOR_STROKE;
2523 break;
2524 case GPPAINT_MODE_FILL:
2525 md_tint.color_mode = MOD_GREASE_PENCIL_COLOR_FILL;
2526 break;
2527 }
2528 switch (eTintGpencil_Type(legacy_md_tint.type)) {
2529 case GP_TINT_UNIFORM:
2530 md_tint.tint_mode = MOD_GREASE_PENCIL_TINT_UNIFORM;
2531 break;
2532 case GP_TINT_GRADIENT:
2533 md_tint.tint_mode = MOD_GREASE_PENCIL_TINT_GRADIENT;
2534 break;
2535 }
2536 md_tint.factor = legacy_md_tint.factor;
2537 md_tint.radius = legacy_md_tint.radius;
2538 copy_v3_v3(md_tint.color, legacy_md_tint.rgb);
2539 md_tint.object = legacy_md_tint.object;
2540 legacy_md_tint.object = nullptr;
2541 MEM_SAFE_DELETE(md_tint.color_ramp);
2542 md_tint.color_ramp = legacy_md_tint.colorband;
2543 legacy_md_tint.colorband = nullptr;
2544
2545 legacy_object_modifier_influence(md_tint.influence,
2546 legacy_md_tint.layername,
2547 legacy_md_tint.layer_pass,
2548 legacy_md_tint.flag & GP_TINT_INVERT_LAYER,
2549 legacy_md_tint.flag & GP_TINT_INVERT_LAYERPASS,
2550 &legacy_md_tint.material,
2551 legacy_md_tint.pass_index,
2552 legacy_md_tint.flag & GP_TINT_INVERT_MATERIAL,
2553 legacy_md_tint.flag & GP_TINT_INVERT_PASS,
2554 legacy_md_tint.vgname,
2555 legacy_md_tint.flag & GP_TINT_INVERT_VGROUP,
2556 &legacy_md_tint.curve_intensity,
2557 legacy_md_tint.flag & GP_TINT_CUSTOM_CURVE);
2558}
2559
2561 Object &object,
2562 GpencilModifierData &legacy_md)
2563{
2565 conversion_data, object, eModifierType_GreasePencilWeightAngle, legacy_md);
2566 auto &md_weight_angle = reinterpret_cast<GreasePencilWeightAngleModifierData &>(md);
2567 auto &legacy_md_weight_angle = reinterpret_cast<WeightAngleGpencilModifierData &>(legacy_md);
2568
2569 md_weight_angle.flag = GreasePencilWeightAngleModifierFlag{};
2570 if (legacy_md_weight_angle.flag & GP_WEIGHT_MULTIPLY_DATA) {
2571 md_weight_angle.flag |= MOD_GREASE_PENCIL_WEIGHT_ANGLE_MULTIPLY_DATA;
2572 }
2573 if (legacy_md_weight_angle.flag & GP_WEIGHT_INVERT_OUTPUT) {
2574 md_weight_angle.flag |= MOD_GREASE_PENCIL_WEIGHT_ANGLE_INVERT_OUTPUT;
2575 }
2576 switch (eGpencilModifierSpace(legacy_md_weight_angle.space)) {
2577 case GP_SPACE_LOCAL:
2578 md_weight_angle.space = MOD_GREASE_PENCIL_WEIGHT_ANGLE_SPACE_LOCAL;
2579 break;
2580 case GP_SPACE_WORLD:
2581 md_weight_angle.space = MOD_GREASE_PENCIL_WEIGHT_ANGLE_SPACE_WORLD;
2582 break;
2583 }
2584 md_weight_angle.axis = legacy_md_weight_angle.axis;
2585 STRNCPY(md_weight_angle.target_vgname, legacy_md_weight_angle.target_vgname);
2586 md_weight_angle.min_weight = legacy_md_weight_angle.min_weight;
2587 md_weight_angle.angle = legacy_md_weight_angle.angle;
2588
2589 legacy_object_modifier_influence(md_weight_angle.influence,
2590 legacy_md_weight_angle.layername,
2591 legacy_md_weight_angle.layer_pass,
2592 legacy_md_weight_angle.flag & GP_WEIGHT_INVERT_LAYER,
2593 legacy_md_weight_angle.flag & GP_WEIGHT_INVERT_LAYERPASS,
2594 &legacy_md_weight_angle.material,
2595 legacy_md_weight_angle.pass_index,
2596 legacy_md_weight_angle.flag & GP_WEIGHT_INVERT_MATERIAL,
2597 legacy_md_weight_angle.flag & GP_WEIGHT_INVERT_PASS,
2598 legacy_md_weight_angle.vgname,
2599 legacy_md_weight_angle.flag & GP_WEIGHT_INVERT_VGROUP,
2600 nullptr,
2601 false);
2602}
2603
2605 Object &object,
2606 GpencilModifierData &legacy_md)
2607{
2609 conversion_data, object, eModifierType_GreasePencilWeightProximity, legacy_md);
2610 auto &md_weight_prox = reinterpret_cast<GreasePencilWeightProximityModifierData &>(md);
2611 auto &legacy_md_weight_prox = reinterpret_cast<WeightProxGpencilModifierData &>(legacy_md);
2612
2613 md_weight_prox.flag = GreasePencilWeightProximityFlag{};
2614 if (legacy_md_weight_prox.flag & GP_WEIGHT_MULTIPLY_DATA) {
2616 }
2617 if (legacy_md_weight_prox.flag & GP_WEIGHT_INVERT_OUTPUT) {
2619 }
2620 STRNCPY(md_weight_prox.target_vgname, legacy_md_weight_prox.target_vgname);
2621 md_weight_prox.min_weight = legacy_md_weight_prox.min_weight;
2622 md_weight_prox.dist_start = legacy_md_weight_prox.dist_start;
2623 md_weight_prox.dist_end = legacy_md_weight_prox.dist_end;
2624 md_weight_prox.object = legacy_md_weight_prox.object;
2625 legacy_md_weight_prox.object = nullptr;
2626
2627 legacy_object_modifier_influence(md_weight_prox.influence,
2628 legacy_md_weight_prox.layername,
2629 legacy_md_weight_prox.layer_pass,
2630 legacy_md_weight_prox.flag & GP_WEIGHT_INVERT_LAYER,
2631 legacy_md_weight_prox.flag & GP_WEIGHT_INVERT_LAYERPASS,
2632 &legacy_md_weight_prox.material,
2633 legacy_md_weight_prox.pass_index,
2634 legacy_md_weight_prox.flag & GP_WEIGHT_INVERT_MATERIAL,
2635 legacy_md_weight_prox.flag & GP_WEIGHT_INVERT_PASS,
2636 legacy_md_weight_prox.vgname,
2637 legacy_md_weight_prox.flag & GP_WEIGHT_INVERT_VGROUP,
2638 nullptr,
2639 false);
2640}
2641
2643 Object &object,
2644 GpencilModifierData &legacy_md)
2645{
2647 conversion_data, object, eModifierType_GreasePencilLineart, legacy_md);
2648 auto &md_lineart = reinterpret_cast<GreasePencilLineartModifierData &>(md);
2649 auto &legacy_md_lineart = reinterpret_cast<LineartGpencilModifierData &>(legacy_md);
2650
2651 greasepencil::convert::lineart_wrap_v3(&legacy_md_lineart, &md_lineart);
2652}
2653
2655 Object &object,
2656 GpencilModifierData &legacy_md)
2657{
2659 conversion_data, object, eModifierType_GreasePencilBuild, legacy_md);
2660 auto &md_build = reinterpret_cast<GreasePencilBuildModifierData &>(md);
2661 auto &legacy_md_build = reinterpret_cast<BuildGpencilModifierData &>(legacy_md);
2662
2663 md_build.flag = GreasePencilBuildFlag{};
2664 if (legacy_md_build.flag & GP_BUILD_RESTRICT_TIME) {
2666 }
2667 if (legacy_md_build.flag & GP_BUILD_USE_FADING) {
2668 md_build.flag |= MOD_GREASE_PENCIL_BUILD_USE_FADING;
2669 }
2670
2671 switch (legacy_md_build.mode) {
2674 break;
2677 break;
2679 default:
2681 break;
2682 }
2683
2684 switch (legacy_md_build.time_alignment) {
2685 default:
2687 md_build.time_alignment = MOD_GREASE_PENCIL_BUILD_TIMEALIGN_START;
2688 break;
2690 md_build.time_alignment = MOD_GREASE_PENCIL_BUILD_TIMEALIGN_END;
2691 break;
2692 }
2693
2694 switch (legacy_md_build.time_mode) {
2695 default:
2697 md_build.time_mode = MOD_GREASE_PENCIL_BUILD_TIMEMODE_FRAMES;
2698 break;
2701 break;
2703 md_build.time_mode = MOD_GREASE_PENCIL_BUILD_TIMEMODE_DRAWSPEED;
2704 break;
2705 }
2706
2707 switch (legacy_md_build.transition) {
2708 default:
2710 md_build.transition = MOD_GREASE_PENCIL_BUILD_TRANSITION_GROW;
2711 break;
2713 md_build.transition = MOD_GREASE_PENCIL_BUILD_TRANSITION_SHRINK;
2714 break;
2716 md_build.transition = MOD_GREASE_PENCIL_BUILD_TRANSITION_VANISH;
2717 break;
2718 }
2719
2720 md_build.start_frame = legacy_md_build.start_frame;
2721 md_build.end_frame = legacy_md_build.end_frame;
2722 md_build.start_delay = legacy_md_build.start_delay;
2723 md_build.length = legacy_md_build.length;
2724 md_build.fade_fac = legacy_md_build.fade_fac;
2725 md_build.fade_opacity_strength = legacy_md_build.fade_opacity_strength;
2726 md_build.fade_thickness_strength = legacy_md_build.fade_thickness_strength;
2727 md_build.percentage_fac = legacy_md_build.percentage_fac;
2728 md_build.speed_fac = legacy_md_build.speed_fac;
2729 md_build.speed_maxgap = legacy_md_build.speed_maxgap;
2730 md_build.object = legacy_md_build.object;
2731 STRNCPY(md_build.target_vgname, legacy_md_build.target_vgname);
2732
2733 legacy_object_modifier_influence(md_build.influence,
2734 legacy_md_build.layername,
2735 legacy_md_build.layer_pass,
2736 legacy_md_build.flag & GP_BUILD_INVERT_LAYER,
2737 legacy_md_build.flag & GP_BUILD_INVERT_LAYERPASS,
2738 &legacy_md_build.material,
2739 legacy_md_build.pass_index,
2740 false,
2741 legacy_md_build.flag & GP_BUILD_INVERT_PASS,
2742 legacy_md_build.target_vgname,
2743 false,
2744 nullptr,
2745 false);
2746}
2747
2749 Object &object,
2750 GpencilModifierData &legacy_md)
2751{
2753 conversion_data, object, eModifierType_GreasePencilSimplify, legacy_md);
2754 auto &md_simplify = reinterpret_cast<GreasePencilSimplifyModifierData &>(md);
2755 auto &legacy_md_simplify = reinterpret_cast<SimplifyGpencilModifierData &>(legacy_md);
2756
2757 switch (legacy_md_simplify.mode) {
2758 case GP_SIMPLIFY_FIXED:
2759 md_simplify.mode = MOD_GREASE_PENCIL_SIMPLIFY_FIXED;
2760 break;
2762 md_simplify.mode = MOD_GREASE_PENCIL_SIMPLIFY_ADAPTIVE;
2763 break;
2764 case GP_SIMPLIFY_SAMPLE:
2765 md_simplify.mode = MOD_GREASE_PENCIL_SIMPLIFY_SAMPLE;
2766 break;
2767 case GP_SIMPLIFY_MERGE:
2768 md_simplify.mode = MOD_GREASE_PENCIL_SIMPLIFY_MERGE;
2769 break;
2770 }
2771
2772 md_simplify.step = legacy_md_simplify.step;
2773 md_simplify.factor = legacy_md_simplify.factor;
2774 md_simplify.length = legacy_md_simplify.length;
2775 md_simplify.sharp_threshold = legacy_md_simplify.sharp_threshold;
2776 md_simplify.distance = legacy_md_simplify.distance;
2777
2778 legacy_object_modifier_influence(md_simplify.influence,
2779 legacy_md_simplify.layername,
2780 legacy_md_simplify.layer_pass,
2781 legacy_md_simplify.flag & GP_SIMPLIFY_INVERT_LAYER,
2782 legacy_md_simplify.flag & GP_SIMPLIFY_INVERT_LAYERPASS,
2783 &legacy_md_simplify.material,
2784 legacy_md_simplify.pass_index,
2785 legacy_md_simplify.flag & GP_SIMPLIFY_INVERT_MATERIAL,
2786 legacy_md_simplify.flag & GP_SIMPLIFY_INVERT_PASS,
2787 "",
2788 false,
2789 nullptr,
2790 false);
2791}
2792
2793static void legacy_object_modifiers(ConversionData &conversion_data, Object &object)
2794{
2795 BLI_assert(object.modifiers.is_empty());
2796
2797 while (GpencilModifierData *gpd_md = static_cast<GpencilModifierData *>(
2798 BLI_pophead(&object.greasepencil_modifiers)))
2799 {
2800 switch (gpd_md->type) {
2803 /* Unknown type, just ignore. */
2804 break;
2806 legacy_object_modifier_armature(conversion_data, object, *gpd_md);
2807 break;
2809 legacy_object_modifier_array(conversion_data, object, *gpd_md);
2810 break;
2812 legacy_object_modifier_color(conversion_data, object, *gpd_md);
2813 break;
2815 legacy_object_modifier_dash(conversion_data, object, *gpd_md);
2816 break;
2818 legacy_object_modifier_envelope(conversion_data, object, *gpd_md);
2819 break;
2821 legacy_object_modifier_hook(conversion_data, object, *gpd_md);
2822 break;
2824 legacy_object_modifier_lattice(conversion_data, object, *gpd_md);
2825 break;
2827 legacy_object_modifier_length(conversion_data, object, *gpd_md);
2828 break;
2830 legacy_object_modifier_mirror(conversion_data, object, *gpd_md);
2831 break;
2833 legacy_object_modifier_multiply(conversion_data, object, *gpd_md);
2834 break;
2836 legacy_object_modifier_noise(conversion_data, object, *gpd_md);
2837 break;
2839 legacy_object_modifier_offset(conversion_data, object, *gpd_md);
2840 break;
2842 legacy_object_modifier_opacity(conversion_data, object, *gpd_md);
2843 break;
2845 legacy_object_modifier_outline(conversion_data, object, *gpd_md);
2846 break;
2848 legacy_object_modifier_shrinkwrap(conversion_data, object, *gpd_md);
2849 break;
2851 legacy_object_modifier_smooth(conversion_data, object, *gpd_md);
2852 break;
2854 legacy_object_modifier_subdiv(conversion_data, object, *gpd_md);
2855 break;
2857 legacy_object_modifier_texture(conversion_data, object, *gpd_md);
2858 break;
2860 legacy_object_modifier_thickness(conversion_data, object, *gpd_md);
2861 break;
2863 legacy_object_modifier_time(conversion_data, object, *gpd_md);
2864 break;
2866 legacy_object_modifier_tint(conversion_data, object, *gpd_md);
2867 break;
2869 legacy_object_modifier_weight_angle(conversion_data, object, *gpd_md);
2870 break;
2872 legacy_object_modifier_weight_proximity(conversion_data, object, *gpd_md);
2873 break;
2875 legacy_object_modifier_lineart(conversion_data, object, *gpd_md);
2876 break;
2878 legacy_object_modifier_build(conversion_data, object, *gpd_md);
2879 break;
2881 legacy_object_modifier_simplify(conversion_data, object, *gpd_md);
2882 break;
2883 }
2884
2886 }
2887}
2888
2907{
2908 /* Annotations mapping, keys are existing GPv2 IDs actually used as annotations, values are
2909 * either:
2910 * - nullptr: this annotation is never used by any object, there was no need to duplicate it.
2911 * - new GPv2 ID: this annotation was also used by objects, this is its new duplicated ID. */
2912 Map<bGPdata *, bGPdata *> annotations_gpv2;
2913 /* All legacy GPv2 data used by objects. */
2914 Set<bGPdata *> object_gpv2;
2915
2916 /* Check all GP objects. */
2917 for (Object &object : bmain.objects) {
2918 if (object.type != OB_GPENCIL_LEGACY) {
2919 continue;
2920 }
2921 bGPdata *legacy_gpd = id_cast<bGPdata *>(object.data);
2922 if (!legacy_gpd) {
2923 continue;
2924 }
2925 if ((legacy_gpd->flag & GP_DATA_ANNOTATIONS) != 0) {
2926 legacy_gpd->flag &= ~GP_DATA_ANNOTATIONS;
2927 }
2928 object_gpv2.add(legacy_gpd);
2929 }
2930
2931 /* Detect all annotations currently used as such, and de-duplicate them if they are also used by
2932 * objects. */
2933
2934 auto sanitize_gpv2_annotation = [&](bGPdata **legacy_gpd_p) {
2935 bGPdata *legacy_gpd = *legacy_gpd_p;
2936 if (!legacy_gpd) {
2937 return;
2938 }
2939
2940 bGPdata *new_annotation_gpd = annotations_gpv2.lookup_or_add(legacy_gpd, nullptr);
2941 if (!object_gpv2.contains(legacy_gpd)) {
2942 /* Legacy annotation GPv2 data not used by any object, just ensure that it is properly
2943 * tagged. */
2944 BLI_assert(!new_annotation_gpd);
2945 if ((legacy_gpd->flag & GP_DATA_ANNOTATIONS) == 0) {
2946 legacy_gpd->flag |= GP_DATA_ANNOTATIONS;
2947 }
2948 return;
2949 }
2950
2951 /* Legacy GP data also used by objects. Create the duplicate of legacy GPv2 data for
2952 * annotations, if not yet done. */
2953 if (!new_annotation_gpd) {
2954 new_annotation_gpd = reinterpret_cast<bGPdata *>(BKE_id_copy_in_lib(&bmain,
2955 legacy_gpd->id.lib,
2956 &legacy_gpd->id,
2957 std::nullopt,
2958 nullptr,
2960 new_annotation_gpd->flag |= GP_DATA_ANNOTATIONS;
2961 id_us_min(&new_annotation_gpd->id);
2962 annotations_gpv2.add_overwrite(legacy_gpd, new_annotation_gpd);
2963 }
2964
2965 /* Assign the annotation duplicate ID to the annotation pointer. */
2966 BLI_assert(new_annotation_gpd->flag & GP_DATA_ANNOTATIONS);
2967 id_us_min(&legacy_gpd->id);
2968 *legacy_gpd_p = new_annotation_gpd;
2969 id_us_plus_no_lib(&new_annotation_gpd->id);
2970 };
2971
2972 for (Scene &scene : bmain.scenes) {
2973 sanitize_gpv2_annotation(&scene.gpd);
2974 }
2975
2976 ID *id_iter;
2977 FOREACH_MAIN_ID_BEGIN (&bmain, id_iter) {
2978 if (bNodeTree *node_tree = bke::node_tree_from_id(id_iter)) {
2979 sanitize_gpv2_annotation(&node_tree->gpd);
2980 }
2981 }
2983 for (bNodeTree &node_tree : bmain.nodetrees) {
2984 sanitize_gpv2_annotation(&node_tree.gpd);
2985 }
2986
2987 for (MovieClip &movie_clip : bmain.movieclips) {
2988 sanitize_gpv2_annotation(&movie_clip.gpd);
2989
2990 for (MovieTrackingObject &mvc_tracking_object : movie_clip.tracking.objects) {
2991 for (MovieTrackingTrack &mvc_track : mvc_tracking_object.tracks) {
2992 sanitize_gpv2_annotation(&mvc_track.gpd);
2993 }
2994 for (MovieTrackingPlaneTrack &mvc_plane_track : mvc_tracking_object.plane_tracks) {
2995 for (int i = 0; i < mvc_plane_track.point_tracksnr; i++) {
2996 sanitize_gpv2_annotation(&mvc_plane_track.point_tracks[i]->gpd);
2997 }
2998 }
2999 }
3000 }
3001
3002 for (bScreen &screen : bmain.screens) {
3003 for (ScrArea &area : screen.areabase) {
3004 for (SpaceLink &space_link : area.spacedata) {
3005 switch (eSpace_Type(space_link.spacetype)) {
3006 case SPACE_SEQ: {
3007 SpaceSeq *space_sequencer = reinterpret_cast<SpaceSeq *>(&space_link);
3008 sanitize_gpv2_annotation(&space_sequencer->gpd);
3009 break;
3010 }
3011 case SPACE_IMAGE: {
3012 SpaceImage *space_image = reinterpret_cast<SpaceImage *>(&space_link);
3013 sanitize_gpv2_annotation(&space_image->gpd);
3014 break;
3015 }
3016 case SPACE_NODE: {
3017 SpaceNode *space_node = reinterpret_cast<SpaceNode *>(&space_link);
3018 sanitize_gpv2_annotation(&space_node->gpd);
3019 break;
3020 }
3021 case SPACE_EMPTY:
3022 case SPACE_VIEW3D:
3023 /* #View3D.gpd is deprecated and can be ignored here. */
3024 case SPACE_GRAPH:
3025 case SPACE_OUTLINER:
3026 case SPACE_PROPERTIES:
3027 case SPACE_FILE:
3028 case SPACE_INFO:
3029 case SPACE_TEXT:
3030 case SPACE_ACTION:
3031 case SPACE_NLA:
3032 case SPACE_SCRIPT:
3033 case SPACE_CONSOLE:
3034 case SPACE_USERPREF:
3035 case SPACE_CLIP:
3036 case SPACE_TOPBAR:
3037 case SPACE_STATUSBAR:
3038 case SPACE_SPREADSHEET:
3039 case SPACE_PROJECT:
3040 break;
3041 }
3042 }
3043 }
3044 }
3045}
3046
3047static void legacy_gpencil_object(ConversionData &conversion_data, Object &object)
3048{
3049 BLI_assert((GS(object.data->name) == ID_GD_LEGACY));
3050
3051 bGPdata *gpd = id_cast<bGPdata *>(object.data);
3052
3053 GreasePencil *new_grease_pencil = conversion_data.legacy_to_greasepencil_data.lookup_default(
3054 gpd, nullptr);
3055 const bool do_gpencil_data_conversion = (new_grease_pencil == nullptr);
3056
3057 if (!new_grease_pencil) {
3058 new_grease_pencil = BKE_id_new_in_lib<GreasePencil>(
3059 &conversion_data.bmain, gpd->id.lib, gpd->id.name + 2);
3060 id_us_min(&new_grease_pencil->id);
3061 }
3062
3063 object.data = id_cast<ID *>(new_grease_pencil);
3064 object.type = OB_GREASE_PENCIL;
3065
3066 /* NOTE: Could also use #BKE_id_free_us, to also free the legacy GP if not used anymore? */
3067 id_us_min(&gpd->id);
3068 id_us_plus(&new_grease_pencil->id);
3069
3070 if (do_gpencil_data_conversion) {
3071 legacy_gpencil_to_grease_pencil(conversion_data, *new_grease_pencil, *gpd);
3072 conversion_data.legacy_to_greasepencil_data.add(gpd, new_grease_pencil);
3073 }
3074
3075 legacy_object_modifiers(conversion_data, object);
3076 /* Convert the animation of the "uniform thickness" setting of the thickness modifier. */
3077 legacy_object_thickness_modifier_thickness_anim(conversion_data, object);
3078
3079 /* Layer adjustments should be added after all other modifiers. */
3080 layer_adjustments_to_modifiers(conversion_data, *gpd, object);
3081 /* Thickness factor is applied after all other changes to the radii. */
3082 thickness_factor_to_modifier(conversion_data, *gpd, object);
3083
3085}
3086
3087void legacy_main(Main &bmain,
3088 BlendfileLinkAppendContext *lapp_context,
3089 BlendFileReadReport &reports)
3090{
3091 ConversionData conversion_data(bmain, lapp_context);
3092
3093 /* Ensure that annotations are fully separated from object usages of legacy GPv2 data. */
3095
3096 for (Object &object : bmain.objects) {
3097 if (object.type != OB_GPENCIL_LEGACY) {
3098 continue;
3099 }
3100 legacy_gpencil_object(conversion_data, object);
3101 }
3102
3103 /* Potential other usages of legacy bGPdata IDs also need to be remapped to their matching new
3104 * GreasePencil counterparts. */
3105 bke::id::IDRemapper gpd_remapper;
3106 /* Allow remapping from legacy bGPdata IDs to new GreasePencil ones. */
3107 gpd_remapper.allow_idtype_mismatch = true;
3108
3109 Set<GreasePencil *> new_grease_pencils;
3110 for (bGPdata &legacy_gpd : bmain.gpencils) {
3111 /* Annotations still use legacy `bGPdata`, these should not be converted. Call to
3112 * #legacy_gpencil_sanitize_annotations above ensured to fully separate annotations from object
3113 * legacy grease pencil. */
3114 if ((legacy_gpd.flag & GP_DATA_ANNOTATIONS) != 0) {
3115 continue;
3116 }
3117 GreasePencil *new_grease_pencil = conversion_data.legacy_to_greasepencil_data.lookup_default(
3118 &legacy_gpd, nullptr);
3119 if (!new_grease_pencil) {
3120 new_grease_pencil = BKE_id_new_in_lib<GreasePencil>(
3121 &bmain, legacy_gpd.id.lib, legacy_gpd.id.name + 2);
3122 id_us_min(&new_grease_pencil->id);
3123 legacy_gpencil_to_grease_pencil(conversion_data, *new_grease_pencil, legacy_gpd);
3124 conversion_data.legacy_to_greasepencil_data.add(&legacy_gpd, new_grease_pencil);
3125 }
3126 new_grease_pencils.add(new_grease_pencil);
3127 gpd_remapper.add(&legacy_gpd.id, &new_grease_pencil->id);
3128 }
3129
3131
3132 /* !MAIN_VERSION_FILE_ATLEAST(new_bmain, 501, 24) */
3133 /* Convert all the material stroke/fill settings to geometry attributes. */
3135 bmain, new_grease_pencils, reports);
3136
3137 if (conversion_data.lapp_context) {
3139 conversion_data.lapp_context,
3140 [&conversion_data](BlendfileLinkAppendContext *lapp_context,
3141 BlendfileLinkAppendContextItem *item) -> bool {
3142 ID *item_new_id = BKE_blendfile_link_append_context_item_newid_get(lapp_context, item);
3143 if (!item_new_id || item_new_id->id_type() != ID_GD_LEGACY) {
3144 return true;
3145 }
3146 GreasePencil **item_grease_pencil =
3147 conversion_data.legacy_to_greasepencil_data.lookup_ptr(
3148 reinterpret_cast<bGPdata *>(item_new_id));
3149 if (item_grease_pencil && *item_grease_pencil) {
3151 lapp_context, item, &(*item_grease_pencil)->id);
3152 }
3153 return true;
3154 },
3158 }
3159}
3160
3162 BlendFileReadReport &reports,
3163 Object *object,
3164 const StringRef layer_name,
3165 const int frame_number,
3166 greasepencil::Drawing &drawing)
3167{
3168 using namespace blender;
3170 if (curves.is_empty()) {
3171 return;
3172 }
3173
3174 Array<bool> material_hides_stroke(curves.curves_num(), false);
3175 Array<bool> material_uses_fill(curves.curves_num(), false);
3176 const VArray<int> materials = *curves.attributes().lookup_or_default<int>(
3177 "material_index", AttrDomain::Curve, 0);
3178 threading::parallel_for(curves.curves_range(), 1024, [&](const IndexRange range) {
3179 for (const int curve_i : range) {
3180 const Material *material = BKE_object_material_get(object, materials[curve_i] + 1);
3181 if (!material) {
3182 continue;
3183 }
3184 BLI_assert(material->gp_style != nullptr);
3185 material_hides_stroke[curve_i] = (material->gp_style->flag & GP_MATERIAL_STROKE_SHOW) == 0;
3186 material_uses_fill[curve_i] = (material->gp_style->flag & GP_MATERIAL_FILL_SHOW) != 0;
3187 }
3188 });
3189
3190 std::string layer_name_string(layer_name);
3191
3192 MutableAttributeAccessor attributes = curves.attributes_for_write();
3193 /* Optimization: If all of the strokes are shown, don't create the attribute. */
3194 if (array_utils::booleans_mix_calc(VArray<bool>::from_span(material_hides_stroke)) !=
3196 {
3197 constexpr StringRefNull hide_stroke_name = "hide_stroke";
3198 /* Ensure that the name is not already taken. If so, rename the existing attribute and report a
3199 * warning. */
3200 if (attributes.contains(hide_stroke_name)) {
3201 Set<StringRefNull> names = attributes.all_names();
3202 std::string unique_name = BLI_uniquename_cb(
3203 [&](StringRef name) { return names.contains(StringRefNull(name)); },
3204 '.',
3205 hide_stroke_name);
3206 attributes.rename(hide_stroke_name, unique_name);
3208 &reports,
3210 RPT_("Renamed attribute '%s' to '%s' in object '%s' on layer '%s' on frame %d!"),
3211 hide_stroke_name.c_str(),
3212 unique_name.c_str(),
3213 object->id.name + 2,
3214 layer_name_string.c_str(),
3215 frame_number);
3216 }
3217 SpanAttributeWriter hide_stroke = attributes.lookup_or_add_for_write_only_span<bool>(
3218 hide_stroke_name, AttrDomain::Curve);
3219 hide_stroke.span.copy_from(material_hides_stroke);
3220 hide_stroke.finish();
3221 }
3222
3223 /* Optimization: If no fills are used in this drawing, don't create the attribute. */
3226 {
3227 constexpr StringRefNull fill_id_name = "fill_id";
3228 /* Ensure that the name is not already taken. If so, rename the existing attribute. */
3229 if (attributes.contains(fill_id_name)) {
3230 Set<StringRefNull> names = attributes.all_names();
3231 std::string unique_name = BLI_uniquename_cb(
3232 [&](StringRef name) { return names.contains(StringRefNull(name)); }, '.', fill_id_name);
3233 attributes.rename(fill_id_name, unique_name);
3235 &reports,
3237 RPT_("Renamed attribute '%s' to '%s' in object '%s' on layer '%s' on frame %d!"),
3238 fill_id_name.c_str(),
3239 unique_name.c_str(),
3240 object->id.name + 2,
3241 layer_name_string.c_str(),
3242 frame_number);
3243 }
3244 SpanAttributeWriter fill_ids = attributes.lookup_or_add_for_write_only_span<int>(
3245 "fill_id", AttrDomain::Curve);
3246 int current_fill_id = 1;
3247 for (const int curve_i : curves.curves_range()) {
3248 if (material_uses_fill[curve_i]) {
3249 fill_ids.span[curve_i] = current_fill_id;
3250 current_fill_id++;
3251 }
3252 else {
3253 fill_ids.span[curve_i] = 0;
3254 }
3255 }
3256 fill_ids.finish();
3257 }
3258}
3259
3261 const std::optional<Set<GreasePencil *>> &filter,
3262 BlendFileReadReport &reports)
3263{
3264 using namespace blender;
3265 using namespace bke::greasepencil;
3266 if (filter && filter->is_empty()) {
3267 return;
3268 }
3269 /* NOTE: We ignore the edge cases where Grease Pencil data is reused in different objects.
3270 * This does break visual compatibility in the case where different objects use different
3271 * materials that use a different stroke/fill toggle state.
3272 * It seems too unusual for it to make sense to handle this in versioning. */
3273 Set<GreasePencil *> grease_pencils;
3274 for (Object &object : bmain.objects) {
3275 if (object.type != OB_GREASE_PENCIL) {
3276 continue;
3277 }
3278 GreasePencil *grease_pencil = id_cast<GreasePencil *>(object.data);
3279 if (filter && !filter->contains(grease_pencil)) {
3280 continue;
3281 }
3282 if (grease_pencils.add(grease_pencil)) {
3283 for (Layer *layer : grease_pencil->layers_for_write()) {
3284 for (auto [frame_number, frame] : layer->frames().items()) {
3285 Drawing &drawing = *grease_pencil->get_drawing_at(*layer, frame_number);
3287 reports, &object, layer->name(), frame_number, drawing);
3288 }
3289 }
3290 }
3291 else {
3292 BLO_reportf_wrap(&reports,
3294 RPT_("Skipped versioning materials of object '%s' because '%s' was already "
3295 "converted. Manual intervention might be required!"),
3296 object.id.name + 2,
3297 grease_pencil->id.name + 2);
3298 }
3299 }
3300}
3301
3304{
3305 lmd->edge_types = lmd_legacy->edge_types;
3307 lmd->use_multiple_levels = lmd_legacy->use_multiple_levels;
3308 lmd->level_start = lmd_legacy->level_start;
3309 lmd->level_end = lmd_legacy->level_end;
3310 lmd->source_camera = lmd_legacy->source_camera;
3311 lmd->light_contour_object = lmd_legacy->light_contour_object;
3312 lmd->source_object = lmd_legacy->source_object;
3313 lmd->source_collection = lmd_legacy->source_collection;
3314 lmd->target_material = lmd_legacy->target_material;
3315 STRNCPY(lmd->target_layer, lmd_legacy->target_layer);
3317 STRNCPY(lmd->vgname, lmd_legacy->vgname);
3318 lmd->overscan = lmd_legacy->overscan;
3319 lmd->shadow_camera_fov = lmd_legacy->shadow_camera_fov;
3320 lmd->shadow_camera_size = lmd_legacy->shadow_camera_size;
3321 lmd->shadow_camera_near = lmd_legacy->shadow_camera_near;
3322 lmd->shadow_camera_far = lmd_legacy->shadow_camera_far;
3323 lmd->opacity = lmd_legacy->opacity;
3326 lmd->material_mask_bits = lmd_legacy->material_mask_bits;
3327 lmd->intersection_mask = lmd_legacy->intersection_mask;
3328 lmd->shadow_selection = lmd_legacy->shadow_selection;
3329 lmd->silhouette_selection = lmd_legacy->silhouette_selection;
3330 lmd->crease_threshold = lmd_legacy->crease_threshold;
3334 lmd->calculation_flags = lmd_legacy->calculation_flags;
3335 lmd->flags = eGreasePencilLineartFlags(lmd_legacy->flags);
3336 lmd->stroke_depth_offset = lmd_legacy->stroke_depth_offset;
3337 lmd->level_start_override = lmd_legacy->level_start_override;
3338 lmd->level_end_override = lmd_legacy->level_end_override;
3339 lmd->edge_types_override = lmd_legacy->edge_types_override;
3342 lmd->cache = lmd_legacy->cache;
3343 lmd->la_data_ptr = lmd_legacy->la_data_ptr;
3344}
3345
3348{
3349 lmd_legacy->edge_types = lmd->edge_types;
3350 lmd_legacy->source_type = lmd->source_type;
3351 lmd_legacy->use_multiple_levels = lmd->use_multiple_levels;
3352 lmd_legacy->level_start = lmd->level_start;
3353 lmd_legacy->level_end = lmd->level_end;
3354 lmd_legacy->source_camera = lmd->source_camera;
3355 lmd_legacy->light_contour_object = lmd->light_contour_object;
3356 lmd_legacy->source_object = lmd->source_object;
3357 lmd_legacy->source_collection = lmd->source_collection;
3358 lmd_legacy->target_material = lmd->target_material;
3360 STRNCPY(lmd_legacy->vgname, lmd->vgname);
3361 lmd_legacy->overscan = lmd->overscan;
3362 lmd_legacy->shadow_camera_fov = lmd->shadow_camera_fov;
3363 lmd_legacy->shadow_camera_size = lmd->shadow_camera_size;
3364 lmd_legacy->shadow_camera_near = lmd->shadow_camera_near;
3365 lmd_legacy->shadow_camera_far = lmd->shadow_camera_far;
3366 lmd_legacy->opacity = lmd->opacity;
3368 lmd_legacy->mask_switches = lmd->mask_switches;
3369 lmd_legacy->material_mask_bits = lmd->material_mask_bits;
3370 lmd_legacy->intersection_mask = lmd->intersection_mask;
3371 lmd_legacy->shadow_selection = lmd->shadow_selection;
3372 lmd_legacy->silhouette_selection = lmd->silhouette_selection;
3373 lmd_legacy->crease_threshold = lmd->crease_threshold;
3378 lmd_legacy->flags = eLineArtGPencilModifierFlags(lmd->flags);
3379 lmd_legacy->stroke_depth_offset = lmd->stroke_depth_offset;
3380 lmd_legacy->level_start_override = lmd->level_start_override;
3381 lmd_legacy->level_end_override = lmd->level_end_override;
3382 lmd_legacy->edge_types_override = lmd->edge_types_override;
3385 lmd_legacy->cache = lmd->cache;
3386 lmd_legacy->la_data_ptr = lmd->la_data_ptr;
3387}
3388
3389} // namespace blender::bke::greasepencil::convert
Functions and classes to work with Actions.
Functionality to iterate an Action in various ways.
Blender kernel action and pose functionality.
Low-level operations for curves.
support for deformation groups and hooks.
Low-level operations for grease pencil.
#define FOREACH_MAIN_ID_END
Definition BKE_main.hh:735
#define FOREACH_MAIN_ID_BEGIN(_bmain, _id)
Definition BKE_main.hh:729
General operations, lookup, etc. for materials.
General operations, lookup, etc. for blender objects.
#define STRNLEN(str)
#define SNPRINTF_UTF8(dst, format,...)
#define STRNCPY_UTF8(dst, src)
external readfile function prototypes.
#define RPT_(msgid)
#define DATA_(msgid)
#define MAX_NAME
Definition DNA_defs.h:63
#define GREASE_PENCIL_ONION_SKINNING_FILTER_ALL
#define BLI_assert_unreachable()
#define UNUSED_VARS_NDEBUG(...)
#define SET_FLAG_FROM_TEST(value, test, flag)
#define ELEM(...)
#define BLI_assert_msg(a, msg)
#define STREQ(a, b)
void reinitialize(const int64_t new_size)
Definition BLI_array.hh:430
bool is_empty() const
Definition BLI_array.hh:275
constexpr int64_t size() const
bool add_overwrite(const Key &key, const Value &value)
Definition BLI_map.hh:325
Value & lookup_or_add(const Key &key, const Value &value)
Definition BLI_map.hh:588
constexpr MutableSpan()=default
constexpr MutableSpan slice(const int64_t start, const int64_t size) const
Definition BLI_span.hh:579
bool contains(const Key &key) const
Definition BLI_set.hh:310
bool add(const Key &key)
Definition BLI_set.hh:248
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr const char * c_str() const
static VArray from_span(Span< T > values)
void append(const T &value)
bool is_empty() const
Slot & slot_add_for_id(const ID &animated_id)
Set< StringRefNull > all_names() const
bool contains(StringRef name) const
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
GSpanAttributeWriter lookup_or_add_for_write_only_span(StringRef name, AttrDomain domain, AttrType data_type)
bool rename(StringRef old_name, StringRef new_name, bool overwrite=false)
MutableSpan< float > opacities_for_write()
MutableSpan< float > radii_for_write()
bke::CurvesGeometry & strokes_for_write()
MutableSpan< ColorGeometry4f > fill_colors_for_write()
MutableSpan< ColorGeometry4f > vertex_colors_for_write()
void set_view_layer_name(StringRef new_name)
const GreasePencilFrame * frame_at(const int frame_number) const
void set_parent_bone_name(StringRef new_name)
AnimDataConvertor(ConversionData &conversion_data, ID &id_dst, ID &id_src, const Array< AnimDataFCurveConvertor > fcurve_convertors={})
AnimDataConvertor(ConversionData &conversion_data, ID &id_src, const Array< AnimDataFCurveConvertor > fcurve_convertors={})
void add(ID *old_id, ID *new_id)
void copy_utf8_truncated(char *dst, int64_t dst_size) const
Definition string_ref.cc:28
#define FLT_MAX
#define layer
#define sin
#define cos
VecBase< float, D > normalize(VecOp< float, D >) RET
float dot(VecOp< float, D >, VecOp< float, D >) RET
MatBase< R, C > transpose(MatBase< C, R >) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
decltype(blender::ActionSlot::handle) slot_handle_t
void action_fcurve_move(Action &action_dst, slot_handle_t action_slot_dst, Action &action_src, FCurve &fcurve)
Action & action_add(Main &bmain, StringRefNull name)
void foreach_fcurve_in_action(Action &action, FunctionRef< void(FCurve &fcurve)> callback)
bool assign_tmpaction(bAction *action, OwnedAnimData owned_adt)
bool assign_action(bAction *action, ID &animated_id)
BooleanMix booleans_mix_calc(const VArray< bool > &varray, IndexRange range_to_check)
static float4x2 get_legacy_texture_matrix(bGPDstroke *gps)
static Drawing legacy_gpencil_frame_to_grease_pencil_drawing(const bGPDframe &gpf, const ListBaseT< bDeformGroup > &vertex_group_names)
static void legacy_object_modifier_subdiv(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_mirror(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static bNodeTree * offset_radius_node_tree_add(ConversionData &conversion_data, Library *library)
static void legacy_object_modifier_time(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_color(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static ModifierData & legacy_object_modifier_common(ConversionData &conversion_data, Object &object, const ModifierType type, GpencilModifierData &legacy_md)
static void legacy_object_modifier_offset(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
void material_stroke_fill_toggles_to_attributes(Main &bmain, const std::optional< Set< GreasePencil * > > &filter, BlendFileReadReport &reports)
static void legacy_object_modifier_opacity(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_lineart(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_armature(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_shrinkwrap(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void thickness_factor_to_modifier(ConversionData &conversion_data, bGPdata &src_object_data, Object &dst_object)
static void legacy_object_modifier_envelope(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_outline(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_thickness(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_gpencil_to_grease_pencil(ConversionData &conversion_data, GreasePencil &grease_pencil, bGPdata &gpd)
static void legacy_object_modifier_weight_angle(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_tint(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
void lineart_unwrap_v3(LineartGpencilModifierData *lmd_legacy, const GreasePencilLineartModifierData *lmd)
static void legacy_object_modifier_noise(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
void legacy_main(Main &bmain, BlendfileLinkAppendContext *lapp_context, BlendFileReadReport &reports)
static void legacy_object_thickness_modifier_thickness_anim(ConversionData &conversion_data, Object &object)
static void layer_adjustments_to_modifiers(ConversionData &conversion_data, bGPdata &src_object_data, Object &dst_object)
static void legacy_object_modifier_texture(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifiers(ConversionData &conversion_data, Object &object)
static void find_used_vertex_groups(const bGPDframe &gpf, const ListBaseT< bDeformGroup > &vertex_group_names, const int num_vertex_groups, ListBaseT< bDeformGroup > &r_vertex_group_names, Array< int > &r_indices)
static float3x2 get_legacy_stroke_to_texture_matrix(const float2 uv_translation, const float uv_rotation, const float2 uv_scale)
static void legacy_object_modifier_dash(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_build(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_array(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_multiply(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_smooth(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void convert_grease_pencil_drawing_material_stroke_fill_toggle_to_attributes(BlendFileReadReport &reports, Object *object, const StringRef layer_name, const int frame_number, greasepencil::Drawing &drawing)
void lineart_wrap_v3(const LineartGpencilModifierData *lmd_legacy, GreasePencilLineartModifierData *lmd)
static void legacy_object_modifier_lattice(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_weight_proximity(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static float4x2 get_legacy_layer_to_stroke_matrix(bGPDstroke *gps)
static void legacy_object_modifier_influence(GreasePencilModifierInfluenceData &influence, StringRef layername, const int layer_pass, const bool invert_layer, const bool invert_layer_pass, Material **material, const int material_pass, const bool invert_material, const bool invert_material_pass, StringRef vertex_group_name, const bool invert_vertex_group, CurveMapping **custom_curve, const bool use_custom_curve)
static void legacy_object_modifier_hook(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_gpencil_object(ConversionData &conversion_data, Object &object)
static void legacy_object_modifier_length(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
static void legacy_object_modifier_simplify(ConversionData &conversion_data, Object &object, GpencilModifierData &legacy_md)
constexpr float LEGACY_RADIUS_CONVERSION_FACTOR
std::unique_ptr< IDProperty, IDPropertyDeleter > create(StringRef prop_name, int32_t value, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_INT, set its name and value.
std::unique_ptr< IDProperty, IDPropertyDeleter > create_group(StringRef prop_name, eIDPropertyFlag flags={})
Allocate a new IDProperty of type IDP_GROUP.
bNode * node_add_node(const bContext *C, bNodeTree &ntree, UString idname, std::optional< int > unique_identifier=std::nullopt)
Definition node.cc:4260
bool node_set_selected(bNode &node, bool select)
Definition node.cc:5455
bNodeLink & node_add_link(bNodeTree &ntree, bNode &fromnode, bNodeSocket &fromsock, bNode &tonode, bNodeSocket &tosock)
Definition node.cc:4638
bNodeSocket * node_find_socket(bNode &node, eNodeSocketInOut in_out, UString identifier)
Definition node.cc:3036
bNodeTree * node_tree_add_in_lib(Main *bmain, Library *owner_library, StringRefNull name, StringRefNull idname)
Definition node.cc:4997
bNodeTree * node_tree_from_id(ID *id)
Definition node.cc:5337
T safe_rcp(const T &a)
T safe_divide(const T &a, const T &b)
T average(const VecBase< T, Size > &a)
MatT from_scale(const VecBase< typename MatT::base_type, ScaleDim > &scale)
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
BMesh Iterators.
@ MOD_GREASE_PENCIL_BUILD_TIMEMODE_PERCENTAGE
@ MOD_GREASE_PENCIL_BUILD_TIMEMODE_DRAWSPEED
@ MOD_GREASE_PENCIL_BUILD_TIMEMODE_FRAMES
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ GP_LAYER_TREE_NODE_HIDE_ONION_SKINNING
@ GP_LAYER_TREE_NODE_DISABLE_MASKS_IN_VIEWLAYER
GreasePencilWeightAngleModifierFlag
@ MOD_GREASE_PENCIL_WEIGHT_ANGLE_MULTIPLY_DATA
@ MOD_GREASE_PENCIL_WEIGHT_ANGLE_INVERT_OUTPUT
__int64 int64_t
Definition BKE_text.h:90
char * STRNCPY(char(&dst)[N], const char *src)
@ RPT_WARNING
Definition BKE_report.hh:40
@ MOD_GREASE_PENCIL_HOOK_Falloff_Curve
@ MOD_GREASE_PENCIL_HOOK_Falloff_Sharp
@ MOD_GREASE_PENCIL_HOOK_Falloff_Linear
@ MOD_GREASE_PENCIL_HOOK_Falloff_InvSquare
@ MOD_GREASE_PENCIL_HOOK_Falloff_Root
@ MOD_GREASE_PENCIL_HOOK_Falloff_None
@ MOD_GREASE_PENCIL_HOOK_Falloff_Smooth
@ MOD_GREASE_PENCIL_HOOK_Falloff_Const
@ MOD_GREASE_PENCIL_HOOK_Falloff_Sphere
MINLINE void copy_v3_v3(float r[3], const float a[3])
unsigned int uint
Definition BKE_text.h:55
void id_us_plus(ID *id)
Definition lib_id.cc:433
@ MOD_GREASE_PENCIL_OPACITY_USE_UNIFORM_OPACITY
@ MOD_GREASE_PENCIL_OPACITY_USE_WEIGHT_AS_FACTOR
MINLINE void copy_v2_v2(float r[2], const float a[2])
bool IDP_AddToGroup(IDProperty *group, IDProperty *prop) ATTR_NONNULL()
Definition idprop.cc:788
IDProperty * IDP_CopyProperty(const IDProperty *prop) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition idprop.cc:986
@ MOD_GREASE_PENCIL_MULTIPLY_ENABLE_FADING
MatBase< float, 2, 2 > float2x2
@ MOD_GREASE_PENCIL_TIME_SEG_MODE_PINGPONG
@ MOD_GREASE_PENCIL_TIME_SEG_MODE_REVERSE
@ MOD_GREASE_PENCIL_TIME_SEG_MODE_NORMAL
@ eModifierType_GreasePencilOffset
@ eModifierType_GreasePencilMultiply
@ eModifierType_GreasePencilArray
@ eModifierType_GreasePencilThickness
@ eModifierType_GreasePencilSubdiv
@ eModifierType_GreasePencilShrinkwrap
@ eModifierType_GreasePencilDash
@ eModifierType_GreasePencilBuild
@ eModifierType_GreasePencilWeightAngle
@ eModifierType_GreasePencilColor
@ eModifierType_GreasePencilLineart
@ eModifierType_GreasePencilHook
@ eModifierType_GreasePencilMirror
@ eModifierType_GreasePencilLattice
@ eModifierType_GreasePencilSmooth
@ eModifierType_GreasePencilTexture
@ eModifierType_GreasePencilArmature
@ eModifierType_GreasePencilTime
@ eModifierType_GreasePencilOpacity
@ eModifierType_GreasePencilOutline
@ eModifierType_GreasePencilTint
@ eModifierType_GreasePencilNoise
@ eModifierType_GreasePencilSimplify
@ eModifierType_GreasePencilLength
@ eModifierType_GreasePencilEnvelope
@ eModifierType_GreasePencilWeightProximity
@ MOD_GREASE_PENCIL_BUILD_MODE_SEQUENTIAL
@ MOD_GREASE_PENCIL_BUILD_MODE_CONCURRENT
@ MOD_GREASE_PENCIL_BUILD_MODE_ADDITIVE
@ MOD_GREASE_PENCIL_BUILD_TIMEALIGN_START
@ MOD_GREASE_PENCIL_BUILD_TIMEALIGN_END
@ MOD_GREASE_PENCIL_WEIGHT_ANGLE_SPACE_WORLD
@ MOD_GREASE_PENCIL_WEIGHT_ANGLE_SPACE_LOCAL
AnimData * BKE_animdata_copy_in_lib(Main *bmain, std::optional< Library * > owner_library, AnimData *adt, int flag)
Definition anim_data.cc:263
@ GEO_NODE_ASSET_MODIFIER
@ 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
@ GREASE_PENCIL_INFLUENCE_USE_CUSTOM_CURVE
@ ID_REMAP_ALLOW_IDTYPE_MISMATCH
@ MOD_GREASE_PENCIL_TEXTURE_FILL
@ MOD_GREASE_PENCIL_TEXTURE_STROKE_AND_FILL
@ MOD_GREASE_PENCIL_TEXTURE_STROKE
@ MOD_GREASE_PENCIL_SUBDIV_CATMULL
@ MOD_GREASE_PENCIL_SUBDIV_SIMPLE
void BKE_id_materials_copy(Main *bmain, ID *id_src, ID *id_dst)
void BKE_curvemapping_free(CurveMapping *cumap)
void id_fake_user_set(ID *id)
Definition lib_id.cc:471
MatBase< float, 2, 4 > float2x4
@ GP_ARRAY_UNIFORM_RANDOM_SCALE
@ GP_ARRAY_INVERT_LAYERPASS
@ MOD_GREASE_PENCIL_WEIGHT_PROXIMITY_MULTIPLY_DATA
@ MOD_GREASE_PENCIL_WEIGHT_PROXIMITY_INVERT_OUTPUT
void BKE_modifiers_persistent_uid_init(const Object &object, ModifierData &md)
@ MOD_GREASE_PENCIL_TIME_KEEP_LOOP
@ MOD_GREASE_PENCIL_TIME_CUSTOM_RANGE
@ LIB_ID_COPY_DEFAULT
@ MOD_GREASE_PENCIL_OUTLINE_KEEP_SHAPE
@ MOD_GREASE_PENCIL_ARRAY_USE_OB_OFFSET
@ MOD_GREASE_PENCIL_ARRAY_USE_OFFSET
@ MOD_GREASE_PENCIL_ARRAY_UNIFORM_RANDOM_SCALE
@ MOD_GREASE_PENCIL_ARRAY_USE_RELATIVE
@ MOD_GREASE_PENCIL_OFFSET_UNIFORM_RANDOM_SCALE
AnimData * BKE_animdata_ensure_id(ID *id)
Definition anim_data.cc:107
void * BLI_pophead(ListBase *listbase) ATTR_NONNULL(1)
Definition listbase.cc:259
VecBase< float, 4 > float4
void BKE_modifier_unique_name(ListBaseT< ModifierData > *modifiers, ModifierData *md)
@ GP_LENGTH_INVERT_LAYERPASS
@ GP_LENGTH_INVERT_MATERIAL
AnimData * BKE_animdata_from_id(const ID *id)
Definition anim_data.cc:93
size_t void BLI_uniquename_cb(FunctionRef< bool(StringRefNull)> unique_check, const char *defname, char delim, char *name, size_t name_maxncpy) ATTR_NONNULL(2
@ MOD_GREASE_PENCIL_SIMPLIFY_MERGE
@ MOD_GREASE_PENCIL_SIMPLIFY_ADAPTIVE
@ MOD_GREASE_PENCIL_SIMPLIFY_SAMPLE
@ MOD_GREASE_PENCIL_SIMPLIFY_FIXED
@ MOD_GREASE_PENCIL_ENVELOPE_FILLS
@ MOD_GREASE_PENCIL_ENVELOPE_SEGMENTS
@ MOD_GREASE_PENCIL_ENVELOPE_DEFORM
unsigned int uint32_t
Definition BKE_text.h:81
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
@ MOD_GREASE_PENCIL_SMOOTH_MOD_UV
@ MOD_GREASE_PENCIL_SMOOTH_MOD_STRENGTH
@ MOD_GREASE_PENCIL_SMOOTH_MOD_LOCATION
@ MOD_GREASE_PENCIL_SMOOTH_KEEP_SHAPE
@ MOD_GREASE_PENCIL_SMOOTH_MOD_THICKNESS
VecBase< float, 2 > float2
@ MOD_GREASE_PENCIL_BUILD_TRANSITION_GROW
@ MOD_GREASE_PENCIL_BUILD_TRANSITION_SHRINK
@ MOD_GREASE_PENCIL_BUILD_TRANSITION_VANISH
void BKE_fcurve_handles_recalc(FCurve &fcu)
void BKE_blendfile_link_append_context_item_newid_set(BlendfileLinkAppendContext *lapp_context, BlendfileLinkAppendContextItem *item, ID *new_id)
void BKE_object_free_derived_caches(Object *ob)
Definition object.cc:1810
@ MOD_GREASE_PENCIL_TINT_GRADIENT
@ MOD_GREASE_PENCIL_TINT_UNIFORM
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
@ MOD_GREASE_PENCIL_TIME_MODE_REVERSE
@ MOD_GREASE_PENCIL_TIME_MODE_PINGPONG
@ MOD_GREASE_PENCIL_TIME_MODE_FIX
@ MOD_GREASE_PENCIL_TIME_MODE_NORMAL
@ MOD_GREASE_PENCIL_TIME_MODE_CHAIN
void DEG_id_tag_update(ID *id, unsigned int flags)
@ MOD_GREASE_PENCIL_BUILD_USE_FADING
@ MOD_GREASE_PENCIL_BUILD_RESTRICT_TIME
BMesh const char void * data
@ MOD_GREASE_PENCIL_OFFSET_RANDOM
@ MOD_GREASE_PENCIL_OFFSET_STROKE
@ MOD_GREASE_PENCIL_OFFSET_MATERIAL
@ MOD_GREASE_PENCIL_OFFSET_LAYER
ModifierData * BKE_modifier_new(int type)
MatBase< float, 4, 2 > float4x2
char char size_t BLI_str_escape(char *__restrict dst, StringRef src, size_t dst_maxncpy) ATTR_NONNULL(1)
void BKE_ntree_update_after_single_tree_change(Main &bmain, bNodeTree &modified_tree, const NodeTreeUpdateExtraParams &params={})
MatBase< float, 3, 2 > float3x2
void BKE_libblock_remap_multiple(Main *bmain, bke::id::IDRemapper &mappings, const int remap_flags)
Definition lib_remap.cc:710
@ MOD_GREASE_PENCIL_HOOK_UNIFORM_SPACE
MatBase< float, 4, 3 > float4x3
void BLO_reportf_wrap(BlendFileReadReport *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition readfile.cc:237
@ MOD_GREASE_PENCIL_TEXTURE_CONSTANT_LENGTH
@ MOD_GREASE_PENCIL_TEXTURE_FIT_STROKE
@ eModifierTypeFlag_RequiresOriginalData
void BLI_insertlinkbefore(ListBase *listbase, void *vnextlink, void *vnewlink) ATTR_NONNULL(1)
Definition listbase.cc:378
void BKE_grease_pencil_modifier_free_ex(struct GpencilModifierData *md, int flag)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
@ MOD_GREASE_PENCIL_MIRROR_AXIS_X
@ MOD_GREASE_PENCIL_MIRROR_AXIS_Z
@ MOD_GREASE_PENCIL_MIRROR_AXIS_Y
MINLINE float max_ff(float a, float b)
@ ID_RECALC_ANIMATION
Definition DNA_ID.h:1077
ID_Type GS(const char *name)
Definition DNA_ID.h:410
void BKE_defgroup_copy_list(ListBaseT< bDeformGroup > *outbase, const ListBaseT< bDeformGroup > *inbase)
Definition deform.cc:75
@ eModifierFlag_OverrideLibrary_Local
@ GP_NOISE_INVERT_LAYERPASS
@ BKE_BLENDFILE_LINK_APPEND_FOREACH_ITEM_FLAG_DO_INDIRECT
@ BKE_BLENDFILE_LINK_APPEND_FOREACH_ITEM_FLAG_DO_DIRECT
void DEG_relations_tag_update(Main *bmain)
void * BKE_id_new_in_lib(Main *bmain, std::optional< Library * > owner_library, short type, const char *name)
Definition lib_id.cc:1594
@ ID_FLAG_FAKEUSER
Definition DNA_ID.h:770
ColorSceneLinear4f< eAlpha::Premultiplied > ColorGeometry4f
void copy_m4_m4(float m1[4][4], const float m2[4][4])
VecBase< float, 3 > float3
void BKE_blendfile_link_append_context_item_foreach(BlendfileLinkAppendContext *lapp_context, FunctionRef< bool(BlendfileLinkAppendContext *lapp_context, BlendfileLinkAppendContextItem *item)> callback_function, eBlendfileLinkAppendForeachItemFlag flag)
@ PROP_TRANSLATION
Definition RNA_types.hh:318
@ PROP_DISTANCE
Definition RNA_types.hh:313
@ MOD_GREASE_PENCIL_THICK_NORMALIZE
@ MOD_GREASE_PENCIL_THICK_WEIGHT_FACTOR
IDPropertyUIData * IDP_ui_data_ensure(IDProperty *prop)
Definition idprop.cc:2034
@ MOD_GREASE_PENCIL_DASH_USE_CYCLIC
void id_us_plus_no_lib(ID *id)
Definition lib_id.cc:417
void id_us_min(ID *id)
Definition lib_id.cc:441
const ModifierTypeInfo * BKE_modifier_get_info(ModifierType type)
struct ID * BKE_id_copy_in_lib(Main *bmain, std::optional< Library * > owner_library, const ID *id, std::optional< const ID * > new_owner_id, ID **new_id_p, int flag)
Definition lib_id.cc:749
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
signed char int8_t
Definition BKE_text.h:76
@ MOD_GREASE_PENCIL_COLOR_HARDNESS
@ MOD_GREASE_PENCIL_COLOR_STROKE
@ MOD_GREASE_PENCIL_TINT_USE_WEIGHT_AS_FACTOR
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
ListBaseT< FCurve > drivers
eFCurve_Flags flag
unsigned int totvert
GreasePencilLayerTreeNode base
ListBaseT< GreasePencilLayerMask > masks
GreasePencilLayerBlendMode blend_mode
eGreasePencilLineartMaskSwitches mask_switches
GreasePencilLineartModifierSource source_type
GreasePencilModifierInfluenceFlag flag
GreasePencilTimeModifierSegmentMode segment_mode
GreasePencilModifierInfluenceData influence
char name[258]
Definition DNA_ID.h:433
struct Library * lib
Definition DNA_ID.h:421
short flag
Definition DNA_ID.h:439
IDProperty * properties
Definition DNA_ID.h:481
struct MDeformWeight * dw
ListBaseT< bGPdata > gpencils
Definition BKE_main.hh:417
ListBaseT< bNodeTree > nodetrees
Definition BKE_main.hh:409
ListBaseT< MovieClip > movieclips
Definition BKE_main.hh:419
ListBaseT< Object > objects
Definition BKE_main.hh:388
ListBaseT< Scene > scenes
Definition BKE_main.hh:386
ListBaseT< bScreen > screens
Definition BKE_main.hh:400
struct ModifierData * next
struct MovieTracking tracking
ListBaseT< MovieTrackingTrack > tracks
ListBaseT< MovieTrackingPlaneTrack > plane_tracks
ListBaseT< MovieTrackingObject > objects
struct Object * parent
struct bGPdata * gpd
ListBaseT< SpaceLink > spacedata
struct bGPdata * gpd
struct bGPdata * gpd
struct bGPdata * gpd
ListBaseT< bGPDstroke > strokes
ListBaseT< bGPDlayer > layers
ListBaseT< bDeformGroup > vertex_group_names
struct bGPdata * gpd
struct GeometryNodeAssetTraits * geometry_node_asset_traits
bNodeTreeInterface tree_interface
ListBaseT< bNode > nodes
ListBaseT< struct ScrArea > areabase
AnimDataFCurveConvertor(const char *relative_rna_path_src, const char *relative_rna_path_dst, FunctionRef< FCurveConvertCB > convert_cb={nullptr})
ConversionData(Main &bmain, BlendfileLinkAppendContext *lapp_context)