Changeset View
Changeset View
Standalone View
Standalone View
source/blender/blenkernel/intern/data_transfer.cc
- This file was moved from source/blender/blenkernel/intern/data_transfer.c.
| Show First 20 Lines • Show All 265 Lines • ▼ Show 20 Lines | if (dtdata_type == DT_TYPE_LNOR) { | ||||
| const MLoop *loops_dst = BKE_mesh_loops(me_dst); | const MLoop *loops_dst = BKE_mesh_loops(me_dst); | ||||
| const int num_loops_dst = me_dst->totloop; | const int num_loops_dst = me_dst->totloop; | ||||
| CustomData *ldata_dst = &me_dst->ldata; | CustomData *ldata_dst = &me_dst->ldata; | ||||
| const bool use_split_nors_dst = (me_dst->flag & ME_AUTOSMOOTH) != 0; | const bool use_split_nors_dst = (me_dst->flag & ME_AUTOSMOOTH) != 0; | ||||
| const float split_angle_dst = me_dst->smoothresh; | const float split_angle_dst = me_dst->smoothresh; | ||||
| /* This should be ensured by cddata_masks we pass to code generating/giving us me_src now. */ | /* This should be ensured by cddata_masks we pass to code generating/giving us me_src now. */ | ||||
| BLI_assert(CustomData_get_layer(&me_src->ldata, CD_NORMAL) != NULL); | BLI_assert(CustomData_get_layer(&me_src->ldata, CD_NORMAL) != nullptr); | ||||
| (void)me_src; | (void)me_src; | ||||
| float(*loop_nors_dst)[3]; | float(*loop_nors_dst)[3]; | ||||
| short(*custom_nors_dst)[2] = CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL); | short(*custom_nors_dst)[2] = static_cast<short(*)[2]>( | ||||
| CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL)); | |||||
| /* Cache loop nors into a temp CDLayer. */ | /* Cache loop nors into a temp CDLayer. */ | ||||
| loop_nors_dst = CustomData_get_layer(ldata_dst, CD_NORMAL); | loop_nors_dst = static_cast<float(*)[3]>(CustomData_get_layer(ldata_dst, CD_NORMAL)); | ||||
| const bool do_loop_nors_dst = (loop_nors_dst == NULL); | const bool do_loop_nors_dst = (loop_nors_dst == nullptr); | ||||
| if (do_loop_nors_dst) { | if (do_loop_nors_dst) { | ||||
| loop_nors_dst = CustomData_add_layer( | loop_nors_dst = static_cast<float(*)[3]>( | ||||
| ldata_dst, CD_NORMAL, CD_SET_DEFAULT, NULL, num_loops_dst); | CustomData_add_layer(ldata_dst, CD_NORMAL, CD_SET_DEFAULT, nullptr, num_loops_dst)); | ||||
| CustomData_set_layer_flag(ldata_dst, CD_NORMAL, CD_FLAG_TEMPORARY); | CustomData_set_layer_flag(ldata_dst, CD_NORMAL, CD_FLAG_TEMPORARY); | ||||
| } | } | ||||
| if (dirty_nors_dst || do_loop_nors_dst) { | if (dirty_nors_dst || do_loop_nors_dst) { | ||||
| BKE_mesh_normals_loop_split(verts_dst, | BKE_mesh_normals_loop_split(verts_dst, | ||||
| BKE_mesh_vertex_normals_ensure(me_dst), | BKE_mesh_vertex_normals_ensure(me_dst), | ||||
| num_verts_dst, | num_verts_dst, | ||||
| edges_dst, | edges_dst, | ||||
| num_edges_dst, | num_edges_dst, | ||||
| loops_dst, | loops_dst, | ||||
| loop_nors_dst, | loop_nors_dst, | ||||
| num_loops_dst, | num_loops_dst, | ||||
| polys_dst, | polys_dst, | ||||
| BKE_mesh_poly_normals_ensure(me_dst), | BKE_mesh_poly_normals_ensure(me_dst), | ||||
| num_polys_dst, | num_polys_dst, | ||||
| use_split_nors_dst, | use_split_nors_dst, | ||||
| split_angle_dst, | split_angle_dst, | ||||
| NULL, | nullptr, | ||||
| NULL, | nullptr, | ||||
| custom_nors_dst); | custom_nors_dst); | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| static void data_transfer_dtdata_type_postprocess(Object *UNUSED(ob_src), | static void data_transfer_dtdata_type_postprocess(Object *UNUSED(ob_src), | ||||
| Object *UNUSED(ob_dst), | Object *UNUSED(ob_dst), | ||||
| Mesh *UNUSED(me_src), | Mesh *UNUSED(me_src), | ||||
| Show All 13 Lines | if (dtdata_type == DT_TYPE_LNOR) { | ||||
| const int num_edges_dst = me_dst->totedge; | const int num_edges_dst = me_dst->totedge; | ||||
| MPoly *polys_dst = BKE_mesh_polys_for_write(me_dst); | MPoly *polys_dst = BKE_mesh_polys_for_write(me_dst); | ||||
| const int num_polys_dst = me_dst->totpoly; | const int num_polys_dst = me_dst->totpoly; | ||||
| MLoop *loops_dst = BKE_mesh_loops_for_write(me_dst); | MLoop *loops_dst = BKE_mesh_loops_for_write(me_dst); | ||||
| const int num_loops_dst = me_dst->totloop; | const int num_loops_dst = me_dst->totloop; | ||||
| CustomData *ldata_dst = &me_dst->ldata; | CustomData *ldata_dst = &me_dst->ldata; | ||||
| const float(*poly_nors_dst)[3] = BKE_mesh_poly_normals_ensure(me_dst); | const float(*poly_nors_dst)[3] = BKE_mesh_poly_normals_ensure(me_dst); | ||||
| float(*loop_nors_dst)[3] = CustomData_get_layer(ldata_dst, CD_NORMAL); | float(*loop_nors_dst)[3] = static_cast<float(*)[3]>( | ||||
| short(*custom_nors_dst)[2] = CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL); | CustomData_get_layer(ldata_dst, CD_NORMAL)); | ||||
| short(*custom_nors_dst)[2] = static_cast<short(*)[2]>( | |||||
| CustomData_get_layer(ldata_dst, CD_CUSTOMLOOPNORMAL)); | |||||
| if (!custom_nors_dst) { | if (!custom_nors_dst) { | ||||
| custom_nors_dst = CustomData_add_layer( | custom_nors_dst = static_cast<short(*)[2]>(CustomData_add_layer( | ||||
| ldata_dst, CD_CUSTOMLOOPNORMAL, CD_SET_DEFAULT, NULL, num_loops_dst); | ldata_dst, CD_CUSTOMLOOPNORMAL, CD_SET_DEFAULT, nullptr, num_loops_dst)); | ||||
| } | } | ||||
| /* Note loop_nors_dst contains our custom normals as transferred from source... */ | /* Note loop_nors_dst contains our custom normals as transferred from source... */ | ||||
| BKE_mesh_normals_loop_custom_set(verts_dst, | BKE_mesh_normals_loop_custom_set(verts_dst, | ||||
| BKE_mesh_vertex_normals_ensure(me_dst), | BKE_mesh_vertex_normals_ensure(me_dst), | ||||
| num_verts_dst, | num_verts_dst, | ||||
| edges_dst, | edges_dst, | ||||
| num_edges_dst, | num_edges_dst, | ||||
| Show All 12 Lines | |||||
| static MeshRemapIslandsCalc data_transfer_get_loop_islands_generator(const int cddata_type) | static MeshRemapIslandsCalc data_transfer_get_loop_islands_generator(const int cddata_type) | ||||
| { | { | ||||
| switch (cddata_type) { | switch (cddata_type) { | ||||
| case CD_FAKE_UV: | case CD_FAKE_UV: | ||||
| return BKE_mesh_calc_islands_loop_poly_edgeseam; | return BKE_mesh_calc_islands_loop_poly_edgeseam; | ||||
| default: | default: | ||||
| break; | break; | ||||
| } | } | ||||
| return NULL; | return nullptr; | ||||
| } | } | ||||
| float data_transfer_interp_float_do(const int mix_mode, | float data_transfer_interp_float_do(const int mix_mode, | ||||
| const float val_dst, | const float val_dst, | ||||
| const float val_src, | const float val_src, | ||||
| const float mix_factor) | const float mix_factor) | ||||
| { | { | ||||
| float val_ret; | float val_ret; | ||||
| ▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines | void data_transfer_layersmapping_add_item(ListBase *r_map, | ||||
| const int data_dst_n, | const int data_dst_n, | ||||
| const size_t elem_size, | const size_t elem_size, | ||||
| const size_t data_size, | const size_t data_size, | ||||
| const size_t data_offset, | const size_t data_offset, | ||||
| const uint64_t data_flag, | const uint64_t data_flag, | ||||
| cd_datatransfer_interp interp, | cd_datatransfer_interp interp, | ||||
| void *interp_data) | void *interp_data) | ||||
| { | { | ||||
| CustomDataTransferLayerMap *item = MEM_mallocN(sizeof(*item), __func__); | CustomDataTransferLayerMap *item = MEM_new<CustomDataTransferLayerMap>(__func__); | ||||
| BLI_assert(data_dst != NULL); | BLI_assert(data_dst != nullptr); | ||||
| item->data_type = cddata_type; | item->data_type = cddata_type; | ||||
| item->mix_mode = mix_mode; | item->mix_mode = mix_mode; | ||||
| item->mix_factor = mix_factor; | item->mix_factor = mix_factor; | ||||
| item->mix_weights = mix_weights; | item->mix_weights = mix_weights; | ||||
| item->data_src = data_src; | item->data_src = data_src; | ||||
| item->data_dst = data_dst; | item->data_dst = data_dst; | ||||
| ▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines | data_transfer_layersmapping_add_item(r_map, | ||||
| interp, | interp, | ||||
| interp_data); | interp_data); | ||||
| } | } | ||||
| /** | /** | ||||
| * \note | * \note | ||||
| * All those layer mapping handlers return false *only* if they were given invalid parameters. | * All those layer mapping handlers return false *only* if they were given invalid parameters. | ||||
| * This means that even if they do nothing, they will return true if all given parameters were OK. | * This means that even if they do nothing, they will return true if all given parameters were OK. | ||||
| * Also, r_map may be NULL, in which case they will 'only' create/delete destination layers | * Also, r_map may be nullptr, in which case they will 'only' create/delete destination layers | ||||
| * according to given parameters. | * according to given parameters. | ||||
| */ | */ | ||||
| static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map, | static bool data_transfer_layersmapping_cdlayers_multisrc_to_dst(ListBase *r_map, | ||||
| const int cddata_type, | const int cddata_type, | ||||
| const int mix_mode, | const int mix_mode, | ||||
| const float mix_factor, | const float mix_factor, | ||||
| const float *mix_weights, | const float *mix_weights, | ||||
| const int num_elem_dst, | const int num_elem_dst, | ||||
| const bool use_create, | const bool use_create, | ||||
| const bool use_delete, | const bool use_delete, | ||||
| CustomData *cd_src, | CustomData *cd_src, | ||||
| CustomData *cd_dst, | CustomData *cd_dst, | ||||
| const bool use_dupref_dst, | const bool use_dupref_dst, | ||||
| const int tolayers, | const int tolayers, | ||||
| const bool *use_layers_src, | const bool *use_layers_src, | ||||
| const int num_layers_src, | const int num_layers_src, | ||||
| cd_datatransfer_interp interp, | cd_datatransfer_interp interp, | ||||
| void *interp_data) | void *interp_data) | ||||
| { | { | ||||
| const void *data_src; | const void *data_src; | ||||
| void *data_dst = NULL; | void *data_dst = nullptr; | ||||
| int idx_src = num_layers_src; | int idx_src = num_layers_src; | ||||
| int idx_dst, tot_dst = CustomData_number_of_layers(cd_dst, cddata_type); | int idx_dst, tot_dst = CustomData_number_of_layers(cd_dst, cddata_type); | ||||
| bool *data_dst_to_delete = NULL; | bool *data_dst_to_delete = nullptr; | ||||
| if (!use_layers_src) { | if (!use_layers_src) { | ||||
| /* No source at all, we can only delete all dest if requested... */ | /* No source at all, we can only delete all dest if requested... */ | ||||
| if (use_delete) { | if (use_delete) { | ||||
| idx_dst = tot_dst; | idx_dst = tot_dst; | ||||
| while (idx_dst--) { | while (idx_dst--) { | ||||
| CustomData_free_layer(cd_dst, cddata_type, num_elem_dst, idx_dst); | CustomData_free_layer(cd_dst, cddata_type, num_elem_dst, idx_dst); | ||||
| } | } | ||||
| Show All 10 Lines | case DT_LAYERS_INDEX_DST: | ||||
| /* pass */ | /* pass */ | ||||
| } | } | ||||
| idx_src++; | idx_src++; | ||||
| if (idx_dst < idx_src) { | if (idx_dst < idx_src) { | ||||
| if (use_create) { | if (use_create) { | ||||
| /* Create as much data layers as necessary! */ | /* Create as much data layers as necessary! */ | ||||
| for (; idx_dst < idx_src; idx_dst++) { | for (; idx_dst < idx_src; idx_dst++) { | ||||
| CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst); | CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst); | ||||
| } | } | ||||
| } | } | ||||
| else { | else { | ||||
| /* Otherwise, just try to map what we can with existing dst data layers. */ | /* Otherwise, just try to map what we can with existing dst data layers. */ | ||||
| idx_src = idx_dst; | idx_src = idx_dst; | ||||
| } | } | ||||
| } | } | ||||
| else if (use_delete && idx_dst > idx_src) { | else if (use_delete && idx_dst > idx_src) { | ||||
| Show All 26 Lines | case DT_LAYERS_INDEX_DST: | ||||
| interp, | interp, | ||||
| interp_data); | interp_data); | ||||
| } | } | ||||
| } | } | ||||
| break; | break; | ||||
| case DT_LAYERS_NAME_DST: | case DT_LAYERS_NAME_DST: | ||||
| if (use_delete) { | if (use_delete) { | ||||
| if (tot_dst) { | if (tot_dst) { | ||||
| data_dst_to_delete = MEM_mallocN(sizeof(*data_dst_to_delete) * (size_t)tot_dst, | data_dst_to_delete = static_cast<bool *>( | ||||
| __func__); | MEM_mallocN(sizeof(*data_dst_to_delete) * (size_t)tot_dst, __func__)); | ||||
| memset(data_dst_to_delete, true, sizeof(*data_dst_to_delete) * (size_t)tot_dst); | memset(data_dst_to_delete, true, sizeof(*data_dst_to_delete) * (size_t)tot_dst); | ||||
| } | } | ||||
| } | } | ||||
| while (idx_src--) { | while (idx_src--) { | ||||
| const char *name; | const char *name; | ||||
| if (!use_layers_src[idx_src]) { | if (!use_layers_src[idx_src]) { | ||||
| continue; | continue; | ||||
| } | } | ||||
| name = CustomData_get_layer_name(cd_src, cddata_type, idx_src); | name = CustomData_get_layer_name(cd_src, cddata_type, idx_src); | ||||
| data_src = CustomData_get_layer_n(cd_src, cddata_type, idx_src); | data_src = CustomData_get_layer_n(cd_src, cddata_type, idx_src); | ||||
| if ((idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name)) == -1) { | if ((idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name)) == -1) { | ||||
| if (use_create) { | if (use_create) { | ||||
| CustomData_add_layer_named( | CustomData_add_layer_named( | ||||
| cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst, name); | cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst, name); | ||||
| idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name); | idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name); | ||||
| } | } | ||||
| else { | else { | ||||
| /* If we are not allowed to create missing dst data layers, | /* If we are not allowed to create missing dst data layers, | ||||
| * just skip matching src one. */ | * just skip matching src one. */ | ||||
| continue; | continue; | ||||
| } | } | ||||
| } | } | ||||
| ▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines | static bool data_transfer_layersmapping_cdlayers(ListBase *r_map, | ||||
| const bool use_dupref_dst, | const bool use_dupref_dst, | ||||
| const int fromlayers, | const int fromlayers, | ||||
| const int tolayers, | const int tolayers, | ||||
| cd_datatransfer_interp interp, | cd_datatransfer_interp interp, | ||||
| void *interp_data) | void *interp_data) | ||||
| { | { | ||||
| int idx_src, idx_dst; | int idx_src, idx_dst; | ||||
| const void *data_src; | const void *data_src; | ||||
| void *data_dst = NULL; | void *data_dst = nullptr; | ||||
| if (CustomData_layertype_is_singleton(cddata_type)) { | if (CustomData_layertype_is_singleton(cddata_type)) { | ||||
| if (!(data_src = CustomData_get_layer(cd_src, cddata_type))) { | if (!(data_src = CustomData_get_layer(cd_src, cddata_type))) { | ||||
| if (use_delete) { | if (use_delete) { | ||||
| CustomData_free_layer(cd_dst, cddata_type, num_elem_dst, 0); | CustomData_free_layer(cd_dst, cddata_type, num_elem_dst, 0); | ||||
| } | } | ||||
| return true; | return true; | ||||
| } | } | ||||
| data_dst = CustomData_get_layer(cd_dst, cddata_type); | data_dst = CustomData_get_layer(cd_dst, cddata_type); | ||||
| if (!data_dst) { | if (!data_dst) { | ||||
| if (!use_create) { | if (!use_create) { | ||||
| return true; | return true; | ||||
| } | } | ||||
| data_dst = CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst); | data_dst = CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst); | ||||
| } | } | ||||
| else if (use_dupref_dst && r_map) { | else if (use_dupref_dst && r_map) { | ||||
| /* If dest is a evaluated mesh (from modifier), | /* If dest is a evaluated mesh (from modifier), | ||||
| * we do not want to overwrite cdlayers of orig mesh! */ | * we do not want to overwrite cdlayers of orig mesh! */ | ||||
| data_dst = CustomData_duplicate_referenced_layer(cd_dst, cddata_type, num_elem_dst); | data_dst = CustomData_duplicate_referenced_layer(cd_dst, cddata_type, num_elem_dst); | ||||
| } | } | ||||
| if (r_map) { | if (r_map) { | ||||
| Show All 36 Lines | if (tolayers >= 0) { /* Real-layer index */ | ||||
| data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst); | data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst); | ||||
| } | } | ||||
| } | } | ||||
| else if (tolayers == DT_LAYERS_ACTIVE_DST) { | else if (tolayers == DT_LAYERS_ACTIVE_DST) { | ||||
| if ((idx_dst = CustomData_get_active_layer(cd_dst, cddata_type)) == -1) { | if ((idx_dst = CustomData_get_active_layer(cd_dst, cddata_type)) == -1) { | ||||
| if (!use_create) { | if (!use_create) { | ||||
| return true; | return true; | ||||
| } | } | ||||
| data_dst = CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst); | data_dst = CustomData_add_layer( | ||||
| cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst); | |||||
| } | } | ||||
| else { | else { | ||||
| /* If dest is a evaluated mesh (from modifier), | /* If dest is a evaluated mesh (from modifier), | ||||
| * we do not want to overwrite cdlayers of orig mesh! */ | * we do not want to overwrite cdlayers of orig mesh! */ | ||||
| if (use_dupref_dst && r_map) { | if (use_dupref_dst && r_map) { | ||||
| data_dst = CustomData_duplicate_referenced_layer_n( | data_dst = CustomData_duplicate_referenced_layer_n( | ||||
| cd_dst, cddata_type, idx_dst, num_elem_dst); | cd_dst, cddata_type, idx_dst, num_elem_dst); | ||||
| } | } | ||||
| else { | else { | ||||
| data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst); | data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst); | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| else if (tolayers == DT_LAYERS_INDEX_DST) { | else if (tolayers == DT_LAYERS_INDEX_DST) { | ||||
| int num = CustomData_number_of_layers(cd_dst, cddata_type); | int num = CustomData_number_of_layers(cd_dst, cddata_type); | ||||
| idx_dst = idx_src; | idx_dst = idx_src; | ||||
| if (num <= idx_dst) { | if (num <= idx_dst) { | ||||
| if (!use_create) { | if (!use_create) { | ||||
| return true; | return true; | ||||
| } | } | ||||
| /* Create as much data layers as necessary! */ | /* Create as much data layers as necessary! */ | ||||
| for (; num <= idx_dst; num++) { | for (; num <= idx_dst; num++) { | ||||
| CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst); | CustomData_add_layer(cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst); | ||||
| } | } | ||||
| } | } | ||||
| /* If dest is a evaluated mesh (from modifier), | /* If dest is a evaluated mesh (from modifier), | ||||
| * we do not want to overwrite cdlayers of orig mesh! */ | * we do not want to overwrite cdlayers of orig mesh! */ | ||||
| if (use_dupref_dst && r_map) { | if (use_dupref_dst && r_map) { | ||||
| data_dst = CustomData_duplicate_referenced_layer_n( | data_dst = CustomData_duplicate_referenced_layer_n( | ||||
| cd_dst, cddata_type, idx_dst, num_elem_dst); | cd_dst, cddata_type, idx_dst, num_elem_dst); | ||||
| } | } | ||||
| else { | else { | ||||
| data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst); | data_dst = CustomData_get_layer_n(cd_dst, cddata_type, idx_dst); | ||||
| } | } | ||||
| } | } | ||||
| else if (tolayers == DT_LAYERS_NAME_DST) { | else if (tolayers == DT_LAYERS_NAME_DST) { | ||||
| const char *name = CustomData_get_layer_name(cd_src, cddata_type, idx_src); | const char *name = CustomData_get_layer_name(cd_src, cddata_type, idx_src); | ||||
| if ((idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name)) == -1) { | if ((idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name)) == -1) { | ||||
| if (!use_create) { | if (!use_create) { | ||||
| return true; | return true; | ||||
| } | } | ||||
| CustomData_add_layer_named(cd_dst, cddata_type, CD_SET_DEFAULT, NULL, num_elem_dst, name); | CustomData_add_layer_named( | ||||
| cd_dst, cddata_type, CD_SET_DEFAULT, nullptr, num_elem_dst, name); | |||||
| idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name); | idx_dst = CustomData_get_named_layer(cd_dst, cddata_type, name); | ||||
| } | } | ||||
| /* If dest is a evaluated mesh (from modifier), | /* If dest is a evaluated mesh (from modifier), | ||||
| * we do not want to overwrite cdlayers of orig mesh! */ | * we do not want to overwrite cdlayers of orig mesh! */ | ||||
| if (use_dupref_dst && r_map) { | if (use_dupref_dst && r_map) { | ||||
| data_dst = CustomData_duplicate_referenced_layer_n( | data_dst = CustomData_duplicate_referenced_layer_n( | ||||
| cd_dst, cddata_type, idx_dst, num_elem_dst); | cd_dst, cddata_type, idx_dst, num_elem_dst); | ||||
| } | } | ||||
| Show All 18 Lines | if (r_map) { | ||||
| data_src, | data_src, | ||||
| data_dst, | data_dst, | ||||
| interp, | interp, | ||||
| interp_data); | interp_data); | ||||
| } | } | ||||
| } | } | ||||
| else if (fromlayers == DT_LAYERS_ALL_SRC) { | else if (fromlayers == DT_LAYERS_ALL_SRC) { | ||||
| int num_src = CustomData_number_of_layers(cd_src, cddata_type); | int num_src = CustomData_number_of_layers(cd_src, cddata_type); | ||||
| bool *use_layers_src = num_src ? | bool *use_layers_src = num_src ? static_cast<bool *>(MEM_mallocN( | ||||
| MEM_mallocN(sizeof(*use_layers_src) * (size_t)num_src, __func__) : | sizeof(*use_layers_src) * (size_t)num_src, __func__)) : | ||||
| NULL; | nullptr; | ||||
| bool ret; | bool ret; | ||||
| if (use_layers_src) { | if (use_layers_src) { | ||||
| memset(use_layers_src, true, sizeof(*use_layers_src) * num_src); | memset(use_layers_src, true, sizeof(*use_layers_src) * num_src); | ||||
| } | } | ||||
| ret = data_transfer_layersmapping_cdlayers_multisrc_to_dst(r_map, | ret = data_transfer_layersmapping_cdlayers_multisrc_to_dst(r_map, | ||||
| cddata_type, | cddata_type, | ||||
| Show All 38 Lines | static bool data_transfer_layersmapping_generate(ListBase *r_map, | ||||
| const bool use_create, | const bool use_create, | ||||
| const bool use_delete, | const bool use_delete, | ||||
| const int fromlayers, | const int fromlayers, | ||||
| const int tolayers, | const int tolayers, | ||||
| SpaceTransform *space_transform) | SpaceTransform *space_transform) | ||||
| { | { | ||||
| CustomData *cd_src, *cd_dst; | CustomData *cd_src, *cd_dst; | ||||
| cd_datatransfer_interp interp = NULL; | cd_datatransfer_interp interp = nullptr; | ||||
| void *interp_data = NULL; | void *interp_data = nullptr; | ||||
| if (elem_type == ME_VERT) { | if (elem_type == ME_VERT) { | ||||
| if (!(cddata_type & CD_FAKE)) { | if (!(cddata_type & CD_FAKE)) { | ||||
| cd_src = &me_src->vdata; | cd_src = &me_src->vdata; | ||||
| cd_dst = &me_dst->vdata; | cd_dst = &me_dst->vdata; | ||||
| if (!data_transfer_layersmapping_cdlayers(r_map, | if (!data_transfer_layersmapping_cdlayers(r_map, | ||||
| cddata_type, | cddata_type, | ||||
| ▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines | if (!(cddata_type & CD_FAKE)) { /* Unused for edges, currently... */ | ||||
| interp, | interp, | ||||
| interp_data)) { | interp_data)) { | ||||
| /* We handle specific source selection cases here. */ | /* We handle specific source selection cases here. */ | ||||
| return false; | return false; | ||||
| } | } | ||||
| return true; | return true; | ||||
| } | } | ||||
| if (r_map && ELEM(cddata_type, CD_FAKE_SHARP, CD_FAKE_SEAM)) { | if (r_map && ELEM(cddata_type, CD_FAKE_SHARP, CD_FAKE_SEAM)) { | ||||
| const size_t elem_size = sizeof(*((MEdge *)NULL)); | const size_t elem_size = sizeof(*((MEdge *)nullptr)); | ||||
| const size_t data_size = sizeof(((MEdge *)NULL)->flag); | const size_t data_size = sizeof(((MEdge *)nullptr)->flag); | ||||
| const size_t data_offset = offsetof(MEdge, flag); | const size_t data_offset = offsetof(MEdge, flag); | ||||
| const uint64_t data_flag = (cddata_type == CD_FAKE_SHARP) ? ME_SHARP : ME_SEAM; | const uint64_t data_flag = (cddata_type == CD_FAKE_SHARP) ? ME_SHARP : ME_SEAM; | ||||
| data_transfer_layersmapping_add_item(r_map, | data_transfer_layersmapping_add_item(r_map, | ||||
| cddata_type, | cddata_type, | ||||
| mix_mode, | mix_mode, | ||||
| mix_factor, | mix_factor, | ||||
| mix_weights, | mix_weights, | ||||
| BKE_mesh_edges(me_src), | BKE_mesh_edges(me_src), | ||||
| BKE_mesh_edges_for_write(me_dst), | BKE_mesh_edges_for_write(me_dst), | ||||
| me_src->totedge, | me_src->totedge, | ||||
| me_dst->totedge, | me_dst->totedge, | ||||
| elem_size, | elem_size, | ||||
| data_size, | data_size, | ||||
| data_offset, | data_offset, | ||||
| data_flag, | data_flag, | ||||
| NULL, | nullptr, | ||||
| interp_data); | interp_data); | ||||
| return true; | return true; | ||||
| } | } | ||||
| return false; | return false; | ||||
| } | } | ||||
| else if (elem_type == ME_LOOP) { | else if (elem_type == ME_LOOP) { | ||||
| if (cddata_type == CD_FAKE_UV) { | if (cddata_type == CD_FAKE_UV) { | ||||
| ▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines | if (!(cddata_type & CD_FAKE)) { | ||||
| interp, | interp, | ||||
| interp_data)) { | interp_data)) { | ||||
| /* We handle specific source selection cases here. */ | /* We handle specific source selection cases here. */ | ||||
| return false; | return false; | ||||
| } | } | ||||
| return true; | return true; | ||||
| } | } | ||||
| if (r_map && cddata_type == CD_FAKE_SHARP) { | if (r_map && cddata_type == CD_FAKE_SHARP) { | ||||
| const size_t elem_size = sizeof(*((MPoly *)NULL)); | const size_t elem_size = sizeof(*((MPoly *)nullptr)); | ||||
| const size_t data_size = sizeof(((MPoly *)NULL)->flag); | const size_t data_size = sizeof(((MPoly *)nullptr)->flag); | ||||
| const size_t data_offset = offsetof(MPoly, flag); | const size_t data_offset = offsetof(MPoly, flag); | ||||
| const uint64_t data_flag = ME_SMOOTH; | const uint64_t data_flag = ME_SMOOTH; | ||||
| data_transfer_layersmapping_add_item(r_map, | data_transfer_layersmapping_add_item(r_map, | ||||
| cddata_type, | cddata_type, | ||||
| mix_mode, | mix_mode, | ||||
| mix_factor, | mix_factor, | ||||
| mix_weights, | mix_weights, | ||||
| BKE_mesh_polys(me_src), | BKE_mesh_polys(me_src), | ||||
| BKE_mesh_polys_for_write(me_dst), | BKE_mesh_polys_for_write(me_dst), | ||||
| me_src->totpoly, | me_src->totpoly, | ||||
| me_dst->totpoly, | me_dst->totpoly, | ||||
| elem_size, | elem_size, | ||||
| data_size, | data_size, | ||||
| data_offset, | data_offset, | ||||
| data_flag, | data_flag, | ||||
| NULL, | nullptr, | ||||
| interp_data); | interp_data); | ||||
| return true; | return true; | ||||
| } | } | ||||
| return false; | return false; | ||||
| } | } | ||||
| return false; | return false; | ||||
| Show All 12 Lines | void BKE_object_data_transfer_layout(struct Depsgraph *depsgraph, | ||||
| Mesh *me_dst; | Mesh *me_dst; | ||||
| const bool use_create = true; /* We always create needed layers here. */ | const bool use_create = true; /* We always create needed layers here. */ | ||||
| CustomData_MeshMasks me_src_mask = CD_MASK_BAREMESH; | CustomData_MeshMasks me_src_mask = CD_MASK_BAREMESH; | ||||
| BLI_assert((ob_src != ob_dst) && (ob_src->type == OB_MESH) && (ob_dst->type == OB_MESH)); | BLI_assert((ob_src != ob_dst) && (ob_src->type == OB_MESH) && (ob_dst->type == OB_MESH)); | ||||
| me_dst = ob_dst->data; | me_dst = static_cast<Mesh *>(ob_dst->data); | ||||
| /* Get source evaluated mesh. */ | /* Get source evaluated mesh. */ | ||||
| BKE_object_data_transfer_dttypes_to_cdmask(data_types, &me_src_mask); | BKE_object_data_transfer_dttypes_to_cdmask(data_types, &me_src_mask); | ||||
| me_src = mesh_get_eval_final(depsgraph, scene, ob_src, &me_src_mask); | me_src = mesh_get_eval_final(depsgraph, scene, ob_src, &me_src_mask); | ||||
| if (!me_src) { | if (!me_src) { | ||||
| return; | return; | ||||
| } | } | ||||
| Show All 17 Lines | for (int i = 0; i < DT_TYPE_MAX; i++) { | ||||
| } | } | ||||
| else { | else { | ||||
| fromlayers = tolayers = 0; | fromlayers = tolayers = 0; | ||||
| } | } | ||||
| if (DT_DATATYPE_IS_VERT(dtdata_type)) { | if (DT_DATATYPE_IS_VERT(dtdata_type)) { | ||||
| const int num_elem_dst = me_dst->totvert; | const int num_elem_dst = me_dst->totvert; | ||||
| data_transfer_layersmapping_generate(NULL, | data_transfer_layersmapping_generate(nullptr, | ||||
| ob_src, | ob_src, | ||||
| ob_dst, | ob_dst, | ||||
| me_src, | me_src, | ||||
| me_dst, | me_dst, | ||||
| ME_VERT, | ME_VERT, | ||||
| cddata_type, | cddata_type, | ||||
| 0, | 0, | ||||
| 0.0f, | 0.0f, | ||||
| NULL, | nullptr, | ||||
| num_elem_dst, | num_elem_dst, | ||||
| use_create, | use_create, | ||||
| use_delete, | use_delete, | ||||
| fromlayers, | fromlayers, | ||||
| tolayers, | tolayers, | ||||
| NULL); | nullptr); | ||||
| } | } | ||||
| if (DT_DATATYPE_IS_EDGE(dtdata_type)) { | if (DT_DATATYPE_IS_EDGE(dtdata_type)) { | ||||
| const int num_elem_dst = me_dst->totedge; | const int num_elem_dst = me_dst->totedge; | ||||
| data_transfer_layersmapping_generate(NULL, | data_transfer_layersmapping_generate(nullptr, | ||||
| ob_src, | ob_src, | ||||
| ob_dst, | ob_dst, | ||||
| me_src, | me_src, | ||||
| me_dst, | me_dst, | ||||
| ME_EDGE, | ME_EDGE, | ||||
| cddata_type, | cddata_type, | ||||
| 0, | 0, | ||||
| 0.0f, | 0.0f, | ||||
| NULL, | nullptr, | ||||
| num_elem_dst, | num_elem_dst, | ||||
| use_create, | use_create, | ||||
| use_delete, | use_delete, | ||||
| fromlayers, | fromlayers, | ||||
| tolayers, | tolayers, | ||||
| NULL); | nullptr); | ||||
| } | } | ||||
| if (DT_DATATYPE_IS_LOOP(dtdata_type)) { | if (DT_DATATYPE_IS_LOOP(dtdata_type)) { | ||||
| const int num_elem_dst = me_dst->totloop; | const int num_elem_dst = me_dst->totloop; | ||||
| data_transfer_layersmapping_generate(NULL, | data_transfer_layersmapping_generate(nullptr, | ||||
| ob_src, | ob_src, | ||||
| ob_dst, | ob_dst, | ||||
| me_src, | me_src, | ||||
| me_dst, | me_dst, | ||||
| ME_LOOP, | ME_LOOP, | ||||
| cddata_type, | cddata_type, | ||||
| 0, | 0, | ||||
| 0.0f, | 0.0f, | ||||
| NULL, | nullptr, | ||||
| num_elem_dst, | num_elem_dst, | ||||
| use_create, | use_create, | ||||
| use_delete, | use_delete, | ||||
| fromlayers, | fromlayers, | ||||
| tolayers, | tolayers, | ||||
| NULL); | nullptr); | ||||
| } | } | ||||
| if (DT_DATATYPE_IS_POLY(dtdata_type)) { | if (DT_DATATYPE_IS_POLY(dtdata_type)) { | ||||
| const int num_elem_dst = me_dst->totpoly; | const int num_elem_dst = me_dst->totpoly; | ||||
| data_transfer_layersmapping_generate(NULL, | data_transfer_layersmapping_generate(nullptr, | ||||
| ob_src, | ob_src, | ||||
| ob_dst, | ob_dst, | ||||
| me_src, | me_src, | ||||
| me_dst, | me_dst, | ||||
| ME_POLY, | ME_POLY, | ||||
| cddata_type, | cddata_type, | ||||
| 0, | 0, | ||||
| 0.0f, | 0.0f, | ||||
| NULL, | nullptr, | ||||
| num_elem_dst, | num_elem_dst, | ||||
| use_create, | use_create, | ||||
| use_delete, | use_delete, | ||||
| fromlayers, | fromlayers, | ||||
| tolayers, | tolayers, | ||||
| NULL); | nullptr); | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph, | bool BKE_object_data_transfer_ex(struct Depsgraph *depsgraph, | ||||
| Scene *scene, | Scene *scene, | ||||
| Object *ob_src, | Object *ob_src, | ||||
| Object *ob_dst, | Object *ob_dst, | ||||
| Show All 24 Lines | |||||
| #define DATAMAX 4 | #define DATAMAX 4 | ||||
| SpaceTransform auto_space_transform; | SpaceTransform auto_space_transform; | ||||
| Mesh *me_src; | Mesh *me_src; | ||||
| /* Assumed always true if not using an evaluated mesh as destination. */ | /* Assumed always true if not using an evaluated mesh as destination. */ | ||||
| bool dirty_nors_dst = true; | bool dirty_nors_dst = true; | ||||
| const MDeformVert *mdef = NULL; | const MDeformVert *mdef = nullptr; | ||||
| int vg_idx = -1; | int vg_idx = -1; | ||||
| float *weights[DATAMAX] = {NULL}; | float *weights[DATAMAX] = {nullptr}; | ||||
| MeshPairRemap geom_map[DATAMAX] = {{0}}; | MeshPairRemap geom_map[DATAMAX] = {{0}}; | ||||
| bool geom_map_init[DATAMAX] = {0}; | bool geom_map_init[DATAMAX] = {0}; | ||||
| ListBase lay_map = {NULL}; | ListBase lay_map = {nullptr}; | ||||
| bool changed = false; | bool changed = false; | ||||
| bool is_modifier = false; | bool is_modifier = false; | ||||
| const bool use_delete = false; /* We never delete data layers from destination here. */ | const bool use_delete = false; /* We never delete data layers from destination here. */ | ||||
| CustomData_MeshMasks me_src_mask = CD_MASK_BAREMESH; | CustomData_MeshMasks me_src_mask = CD_MASK_BAREMESH; | ||||
| BLI_assert((ob_src != ob_dst) && (ob_src->type == OB_MESH) && (ob_dst->type == OB_MESH)); | BLI_assert((ob_src != ob_dst) && (ob_src->type == OB_MESH) && (ob_dst->type == OB_MESH)); | ||||
| if (me_dst) { | if (me_dst) { | ||||
| dirty_nors_dst = BKE_mesh_vertex_normals_are_dirty(me_dst); | dirty_nors_dst = BKE_mesh_vertex_normals_are_dirty(me_dst); | ||||
| /* Never create needed custom layers on passed destination mesh | /* Never create needed custom layers on passed destination mesh | ||||
| * (assumed to *not* be ob_dst->data, aka modifier case). */ | * (assumed to *not* be ob_dst->data, aka modifier case). */ | ||||
| use_create = false; | use_create = false; | ||||
| is_modifier = true; | is_modifier = true; | ||||
| } | } | ||||
| else { | else { | ||||
| me_dst = ob_dst->data; | me_dst = static_cast<Mesh *>(ob_dst->data); | ||||
| } | } | ||||
| if (vgroup_name) { | if (vgroup_name) { | ||||
| mdef = CustomData_get_layer(&me_dst->vdata, CD_MDEFORMVERT); | mdef = static_cast<const MDeformVert *>(CustomData_get_layer(&me_dst->vdata, CD_MDEFORMVERT)); | ||||
| if (mdef) { | if (mdef) { | ||||
| vg_idx = BKE_id_defgroup_name_index(&me_dst->id, vgroup_name); | vg_idx = BKE_id_defgroup_name_index(&me_dst->id, vgroup_name); | ||||
| } | } | ||||
| } | } | ||||
| /* Get source evaluated mesh. */ | /* Get source evaluated mesh. */ | ||||
| BKE_object_data_transfer_dttypes_to_cdmask(data_types, &me_src_mask); | BKE_object_data_transfer_dttypes_to_cdmask(data_types, &me_src_mask); | ||||
| BKE_mesh_remap_calc_source_cddata_masks_from_map_modes( | BKE_mesh_remap_calc_source_cddata_masks_from_map_modes( | ||||
| map_vert_mode, map_edge_mode, map_loop_mode, map_poly_mode, &me_src_mask); | map_vert_mode, map_edge_mode, map_loop_mode, map_poly_mode, &me_src_mask); | ||||
| if (is_modifier) { | if (is_modifier) { | ||||
| me_src = BKE_modifier_get_evaluated_mesh_from_evaluated_object(ob_src); | me_src = BKE_modifier_get_evaluated_mesh_from_evaluated_object(ob_src); | ||||
| if (me_src == NULL || | if (me_src == nullptr || | ||||
| !CustomData_MeshMasks_are_matching(&ob_src->runtime.last_data_mask, &me_src_mask)) { | !CustomData_MeshMasks_are_matching(&ob_src->runtime.last_data_mask, &me_src_mask)) { | ||||
| CLOG_WARN(&LOG, "Data Transfer: source mesh data is not ready - dependency cycle?"); | CLOG_WARN(&LOG, "Data Transfer: source mesh data is not ready - dependency cycle?"); | ||||
| return changed; | return changed; | ||||
| } | } | ||||
| } | } | ||||
| else { | else { | ||||
| me_src = mesh_get_eval_final(depsgraph, scene, ob_src, &me_src_mask); | me_src = mesh_get_eval_final(depsgraph, scene, ob_src, &me_src_mask); | ||||
| } | } | ||||
| if (!me_src) { | if (!me_src) { | ||||
| return changed; | return changed; | ||||
| } | } | ||||
| BKE_mesh_wrapper_ensure_mdata(me_src); | BKE_mesh_wrapper_ensure_mdata(me_src); | ||||
| if (auto_transform) { | if (auto_transform) { | ||||
| if (space_transform == NULL) { | if (space_transform == nullptr) { | ||||
| space_transform = &auto_space_transform; | space_transform = &auto_space_transform; | ||||
| } | } | ||||
| BKE_mesh_remap_find_best_match_from_mesh( | BKE_mesh_remap_find_best_match_from_mesh( | ||||
| BKE_mesh_verts(me_dst), me_dst->totvert, me_src, space_transform); | BKE_mesh_verts(me_dst), me_dst->totvert, me_src, space_transform); | ||||
| } | } | ||||
| /* Check all possible data types. | /* Check all possible data types. | ||||
| ▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines | if (DT_DATATYPE_IS_VERT(dtdata_type)) { | ||||
| dirty_nors_dst, | dirty_nors_dst, | ||||
| me_src, | me_src, | ||||
| me_dst, | me_dst, | ||||
| &geom_map[VDATA]); | &geom_map[VDATA]); | ||||
| geom_map_init[VDATA] = true; | geom_map_init[VDATA] = true; | ||||
| } | } | ||||
| if (mdef && vg_idx != -1 && !weights[VDATA]) { | if (mdef && vg_idx != -1 && !weights[VDATA]) { | ||||
| weights[VDATA] = MEM_mallocN(sizeof(*(weights[VDATA])) * (size_t)num_verts_dst, __func__); | weights[VDATA] = static_cast<float *>( | ||||
| MEM_mallocN(sizeof(*(weights[VDATA])) * (size_t)num_verts_dst, __func__)); | |||||
| BKE_defvert_extract_vgroup_to_vertweights( | BKE_defvert_extract_vgroup_to_vertweights( | ||||
| mdef, vg_idx, num_verts_dst, invert_vgroup, weights[VDATA]); | mdef, vg_idx, num_verts_dst, invert_vgroup, weights[VDATA]); | ||||
| } | } | ||||
| if (data_transfer_layersmapping_generate(&lay_map, | if (data_transfer_layersmapping_generate(&lay_map, | ||||
| ob_src, | ob_src, | ||||
| ob_dst, | ob_dst, | ||||
| me_src, | me_src, | ||||
| me_dst, | me_dst, | ||||
| ME_VERT, | ME_VERT, | ||||
| cddata_type, | cddata_type, | ||||
| mix_mode, | mix_mode, | ||||
| mix_factor, | mix_factor, | ||||
| weights[VDATA], | weights[VDATA], | ||||
| num_verts_dst, | num_verts_dst, | ||||
| use_create, | use_create, | ||||
| use_delete, | use_delete, | ||||
| fromlayers, | fromlayers, | ||||
| tolayers, | tolayers, | ||||
| space_transform)) { | space_transform)) { | ||||
| CustomDataTransferLayerMap *lay_mapit; | CustomDataTransferLayerMap *lay_mapit; | ||||
| changed |= (lay_map.first != NULL); | changed |= (lay_map.first != nullptr); | ||||
| for (lay_mapit = lay_map.first; lay_mapit; lay_mapit = lay_mapit->next) { | for (lay_mapit = static_cast<CustomDataTransferLayerMap *>(lay_map.first); lay_mapit; | ||||
| lay_mapit = lay_mapit->next) { | |||||
| CustomData_data_transfer(&geom_map[VDATA], lay_mapit); | CustomData_data_transfer(&geom_map[VDATA], lay_mapit); | ||||
| } | } | ||||
| BLI_freelistN(&lay_map); | BLI_freelistN(&lay_map); | ||||
| } | } | ||||
| } | } | ||||
| if (DT_DATATYPE_IS_EDGE(dtdata_type)) { | if (DT_DATATYPE_IS_EDGE(dtdata_type)) { | ||||
| const MVert *verts_dst = BKE_mesh_verts_for_write(me_dst); | const MVert *verts_dst = BKE_mesh_verts_for_write(me_dst); | ||||
| Show All 37 Lines | if (DT_DATATYPE_IS_EDGE(dtdata_type)) { | ||||
| dirty_nors_dst, | dirty_nors_dst, | ||||
| me_src, | me_src, | ||||
| me_dst, | me_dst, | ||||
| &geom_map[EDATA]); | &geom_map[EDATA]); | ||||
| geom_map_init[EDATA] = true; | geom_map_init[EDATA] = true; | ||||
| } | } | ||||
| if (mdef && vg_idx != -1 && !weights[EDATA]) { | if (mdef && vg_idx != -1 && !weights[EDATA]) { | ||||
| weights[EDATA] = MEM_mallocN(sizeof(*weights[EDATA]) * (size_t)num_edges_dst, __func__); | weights[EDATA] = static_cast<float *>( | ||||
| MEM_mallocN(sizeof(*weights[EDATA]) * (size_t)num_edges_dst, __func__)); | |||||
| BKE_defvert_extract_vgroup_to_edgeweights( | BKE_defvert_extract_vgroup_to_edgeweights( | ||||
| mdef, vg_idx, num_verts_dst, edges_dst, num_edges_dst, invert_vgroup, weights[EDATA]); | mdef, vg_idx, num_verts_dst, edges_dst, num_edges_dst, invert_vgroup, weights[EDATA]); | ||||
| } | } | ||||
| if (data_transfer_layersmapping_generate(&lay_map, | if (data_transfer_layersmapping_generate(&lay_map, | ||||
| ob_src, | ob_src, | ||||
| ob_dst, | ob_dst, | ||||
| me_src, | me_src, | ||||
| me_dst, | me_dst, | ||||
| ME_EDGE, | ME_EDGE, | ||||
| cddata_type, | cddata_type, | ||||
| mix_mode, | mix_mode, | ||||
| mix_factor, | mix_factor, | ||||
| weights[EDATA], | weights[EDATA], | ||||
| num_edges_dst, | num_edges_dst, | ||||
| use_create, | use_create, | ||||
| use_delete, | use_delete, | ||||
| fromlayers, | fromlayers, | ||||
| tolayers, | tolayers, | ||||
| space_transform)) { | space_transform)) { | ||||
| CustomDataTransferLayerMap *lay_mapit; | CustomDataTransferLayerMap *lay_mapit; | ||||
| changed |= (lay_map.first != NULL); | changed |= (lay_map.first != nullptr); | ||||
| for (lay_mapit = lay_map.first; lay_mapit; lay_mapit = lay_mapit->next) { | for (lay_mapit = static_cast<CustomDataTransferLayerMap *>(lay_map.first); lay_mapit; | ||||
| lay_mapit = lay_mapit->next) { | |||||
| CustomData_data_transfer(&geom_map[EDATA], lay_mapit); | CustomData_data_transfer(&geom_map[EDATA], lay_mapit); | ||||
| } | } | ||||
| BLI_freelistN(&lay_map); | BLI_freelistN(&lay_map); | ||||
| } | } | ||||
| } | } | ||||
| if (DT_DATATYPE_IS_LOOP(dtdata_type)) { | if (DT_DATATYPE_IS_LOOP(dtdata_type)) { | ||||
| const MVert *verts_dst = BKE_mesh_verts(me_dst); | const MVert *verts_dst = BKE_mesh_verts(me_dst); | ||||
| ▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines | if (DT_DATATYPE_IS_LOOP(dtdata_type)) { | ||||
| me_src, | me_src, | ||||
| island_callback, | island_callback, | ||||
| islands_handling_precision, | islands_handling_precision, | ||||
| &geom_map[LDATA]); | &geom_map[LDATA]); | ||||
| geom_map_init[LDATA] = true; | geom_map_init[LDATA] = true; | ||||
| } | } | ||||
| if (mdef && vg_idx != -1 && !weights[LDATA]) { | if (mdef && vg_idx != -1 && !weights[LDATA]) { | ||||
| weights[LDATA] = MEM_mallocN(sizeof(*weights[LDATA]) * (size_t)num_loops_dst, __func__); | weights[LDATA] = static_cast<float *>( | ||||
| MEM_mallocN(sizeof(*weights[LDATA]) * (size_t)num_loops_dst, __func__)); | |||||
| BKE_defvert_extract_vgroup_to_loopweights( | BKE_defvert_extract_vgroup_to_loopweights( | ||||
| mdef, vg_idx, num_verts_dst, loops_dst, num_loops_dst, invert_vgroup, weights[LDATA]); | mdef, vg_idx, num_verts_dst, loops_dst, num_loops_dst, invert_vgroup, weights[LDATA]); | ||||
| } | } | ||||
| if (data_transfer_layersmapping_generate(&lay_map, | if (data_transfer_layersmapping_generate(&lay_map, | ||||
| ob_src, | ob_src, | ||||
| ob_dst, | ob_dst, | ||||
| me_src, | me_src, | ||||
| me_dst, | me_dst, | ||||
| ME_LOOP, | ME_LOOP, | ||||
| cddata_type, | cddata_type, | ||||
| mix_mode, | mix_mode, | ||||
| mix_factor, | mix_factor, | ||||
| weights[LDATA], | weights[LDATA], | ||||
| num_loops_dst, | num_loops_dst, | ||||
| use_create, | use_create, | ||||
| use_delete, | use_delete, | ||||
| fromlayers, | fromlayers, | ||||
| tolayers, | tolayers, | ||||
| space_transform)) { | space_transform)) { | ||||
| CustomDataTransferLayerMap *lay_mapit; | CustomDataTransferLayerMap *lay_mapit; | ||||
| changed |= (lay_map.first != NULL); | changed |= (lay_map.first != nullptr); | ||||
| for (lay_mapit = lay_map.first; lay_mapit; lay_mapit = lay_mapit->next) { | for (lay_mapit = static_cast<CustomDataTransferLayerMap *>(lay_map.first); lay_mapit; | ||||
| lay_mapit = lay_mapit->next) { | |||||
| CustomData_data_transfer(&geom_map[LDATA], lay_mapit); | CustomData_data_transfer(&geom_map[LDATA], lay_mapit); | ||||
| } | } | ||||
| BLI_freelistN(&lay_map); | BLI_freelistN(&lay_map); | ||||
| } | } | ||||
| } | } | ||||
| if (DT_DATATYPE_IS_POLY(dtdata_type)) { | if (DT_DATATYPE_IS_POLY(dtdata_type)) { | ||||
| const MVert *verts_dst = BKE_mesh_verts(me_dst); | const MVert *verts_dst = BKE_mesh_verts(me_dst); | ||||
| Show All 38 Lines | if (DT_DATATYPE_IS_POLY(dtdata_type)) { | ||||
| polys_dst, | polys_dst, | ||||
| num_polys_dst, | num_polys_dst, | ||||
| me_src, | me_src, | ||||
| &geom_map[PDATA]); | &geom_map[PDATA]); | ||||
| geom_map_init[PDATA] = true; | geom_map_init[PDATA] = true; | ||||
| } | } | ||||
| if (mdef && vg_idx != -1 && !weights[PDATA]) { | if (mdef && vg_idx != -1 && !weights[PDATA]) { | ||||
| weights[PDATA] = MEM_mallocN(sizeof(*weights[PDATA]) * (size_t)num_polys_dst, __func__); | weights[PDATA] = static_cast<float *>( | ||||
| MEM_mallocN(sizeof(*weights[PDATA]) * (size_t)num_polys_dst, __func__)); | |||||
| BKE_defvert_extract_vgroup_to_polyweights(mdef, | BKE_defvert_extract_vgroup_to_polyweights(mdef, | ||||
| vg_idx, | vg_idx, | ||||
| num_verts_dst, | num_verts_dst, | ||||
| loops_dst, | loops_dst, | ||||
| num_loops_dst, | num_loops_dst, | ||||
| polys_dst, | polys_dst, | ||||
| num_polys_dst, | num_polys_dst, | ||||
| invert_vgroup, | invert_vgroup, | ||||
| Show All 13 Lines | if (DT_DATATYPE_IS_POLY(dtdata_type)) { | ||||
| num_polys_dst, | num_polys_dst, | ||||
| use_create, | use_create, | ||||
| use_delete, | use_delete, | ||||
| fromlayers, | fromlayers, | ||||
| tolayers, | tolayers, | ||||
| space_transform)) { | space_transform)) { | ||||
| CustomDataTransferLayerMap *lay_mapit; | CustomDataTransferLayerMap *lay_mapit; | ||||
| changed |= (lay_map.first != NULL); | changed |= (lay_map.first != nullptr); | ||||
| for (lay_mapit = lay_map.first; lay_mapit; lay_mapit = lay_mapit->next) { | for (lay_mapit = static_cast<CustomDataTransferLayerMap *>(lay_map.first); lay_mapit; | ||||
| lay_mapit = lay_mapit->next) { | |||||
| CustomData_data_transfer(&geom_map[PDATA], lay_mapit); | CustomData_data_transfer(&geom_map[PDATA], lay_mapit); | ||||
| } | } | ||||
| BLI_freelistN(&lay_map); | BLI_freelistN(&lay_map); | ||||
| } | } | ||||
| } | } | ||||
| data_transfer_dtdata_type_postprocess(ob_src, ob_dst, me_src, me_dst, dtdata_type, changed); | data_transfer_dtdata_type_postprocess(ob_src, ob_dst, me_src, me_dst, dtdata_type, changed); | ||||
| Show All 35 Lines | bool BKE_object_data_transfer_mesh(struct Depsgraph *depsgraph, | ||||
| const char *vgroup_name, | const char *vgroup_name, | ||||
| const bool invert_vgroup, | const bool invert_vgroup, | ||||
| ReportList *reports) | ReportList *reports) | ||||
| { | { | ||||
| return BKE_object_data_transfer_ex(depsgraph, | return BKE_object_data_transfer_ex(depsgraph, | ||||
| scene, | scene, | ||||
| ob_src, | ob_src, | ||||
| ob_dst, | ob_dst, | ||||
| NULL, | nullptr, | ||||
| data_types, | data_types, | ||||
| use_create, | use_create, | ||||
| map_vert_mode, | map_vert_mode, | ||||
| map_edge_mode, | map_edge_mode, | ||||
| map_loop_mode, | map_loop_mode, | ||||
| map_poly_mode, | map_poly_mode, | ||||
| space_transform, | space_transform, | ||||
| auto_transform, | auto_transform, | ||||
| Show All 11 Lines | |||||