ClangFormat: apply to source, most of intern
[blender.git] / source / blender / blenkernel / intern / object_facemap.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2008 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <string.h>
25
26 #include "DNA_object_types.h"
27 #include "DNA_mesh_types.h"
28
29 #include "BLI_utildefines.h"
30 #include "BLI_string.h"
31 #include "BLI_string_utils.h"
32 #include "BLI_listbase.h"
33
34 #include "BKE_customdata.h"
35 #include "BKE_editmesh.h"
36 #include "BKE_object.h"
37 #include "BKE_object_facemap.h" /* own include */
38 #include "BKE_object_deform.h"
39
40 #include "BLT_translation.h"
41
42 #include "MEM_guardedalloc.h"
43
44 #include "RNA_define.h"
45 #include "RNA_access.h"
46
47 static bool fmap_unique_check(void *arg, const char *name)
48 {
49   struct {
50     Object *ob;
51     void *fm;
52   } *data = arg;
53
54   bFaceMap *fmap;
55
56   for (fmap = data->ob->fmaps.first; fmap; fmap = fmap->next) {
57     if (data->fm != fmap) {
58       if (!strcmp(fmap->name, name)) {
59         return true;
60       }
61     }
62   }
63
64   return false;
65 }
66
67 static bFaceMap *fmap_duplicate(bFaceMap *infmap)
68 {
69   bFaceMap *outfmap;
70
71   if (!infmap)
72     return NULL;
73
74   outfmap = MEM_callocN(sizeof(bFaceMap), "copy facemap");
75
76   /* For now, just copy everything over. */
77   memcpy(outfmap, infmap, sizeof(bFaceMap));
78
79   outfmap->next = outfmap->prev = NULL;
80
81   return outfmap;
82 }
83
84 void BKE_object_facemap_copy_list(ListBase *outbase, const ListBase *inbase)
85 {
86   bFaceMap *fmap, *fmapn;
87
88   BLI_listbase_clear(outbase);
89
90   for (fmap = inbase->first; fmap; fmap = fmap->next) {
91     fmapn = fmap_duplicate(fmap);
92     BLI_addtail(outbase, fmapn);
93   }
94 }
95
96 void BKE_object_facemap_unique_name(Object *ob, bFaceMap *fmap)
97 {
98   struct {
99     Object *ob;
100     void *fmap;
101   } data;
102   data.ob = ob;
103   data.fmap = fmap;
104
105   BLI_uniquename_cb(fmap_unique_check, &data, DATA_("Group"), '.', fmap->name, sizeof(fmap->name));
106 }
107
108 bFaceMap *BKE_object_facemap_add_name(Object *ob, const char *name)
109 {
110   bFaceMap *fmap;
111
112   if (!ob || ob->type != OB_MESH)
113     return NULL;
114
115   fmap = MEM_callocN(sizeof(bFaceMap), __func__);
116
117   BLI_strncpy(fmap->name, name, sizeof(fmap->name));
118
119   BLI_addtail(&ob->fmaps, fmap);
120
121   ob->actfmap = BLI_listbase_count(&ob->fmaps);
122
123   BKE_object_facemap_unique_name(ob, fmap);
124
125   return fmap;
126 }
127
128 bFaceMap *BKE_object_facemap_add(Object *ob)
129 {
130   return BKE_object_facemap_add_name(ob, DATA_("FaceMap"));
131 }
132
133 static void object_fmap_remove_edit_mode(Object *ob, bFaceMap *fmap, bool do_selected, bool purge)
134 {
135   const int fmap_nr = BLI_findindex(&ob->fmaps, fmap);
136
137   if (ob->type == OB_MESH) {
138     Mesh *me = ob->data;
139
140     if (me->edit_mesh) {
141       BMEditMesh *em = me->edit_mesh;
142       const int cd_fmap_offset = CustomData_get_offset(&em->bm->pdata, CD_FACEMAP);
143
144       if (cd_fmap_offset != -1) {
145         BMFace *efa;
146         BMIter iter;
147         int *map;
148
149         if (purge) {
150           BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
151             map = BM_ELEM_CD_GET_VOID_P(efa, cd_fmap_offset);
152
153             if (map) {
154               if (*map == fmap_nr)
155                 *map = -1;
156               else if (*map > fmap_nr)
157                 *map -= 1;
158             }
159           }
160         }
161         else {
162           BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
163             map = BM_ELEM_CD_GET_VOID_P(efa, cd_fmap_offset);
164
165             if (map && *map == fmap_nr &&
166                 (!do_selected || BM_elem_flag_test(efa, BM_ELEM_SELECT))) {
167               *map = -1;
168             }
169           }
170         }
171       }
172
173       if (ob->actfmap == BLI_listbase_count(&ob->fmaps))
174         ob->actfmap--;
175
176       BLI_remlink(&ob->fmaps, fmap);
177       MEM_freeN(fmap);
178     }
179   }
180 }
181
182 static void object_fmap_remove_object_mode(Object *ob, bFaceMap *fmap, bool purge)
183 {
184   const int fmap_nr = BLI_findindex(&ob->fmaps, fmap);
185
186   if (ob->type == OB_MESH) {
187     Mesh *me = ob->data;
188
189     if (CustomData_has_layer(&me->pdata, CD_FACEMAP)) {
190       int *map = CustomData_get_layer(&me->pdata, CD_FACEMAP);
191       int i;
192
193       if (map) {
194         for (i = 0; i < me->totpoly; i++) {
195           if (map[i] == fmap_nr)
196             map[i] = -1;
197           else if (purge && map[i] > fmap_nr)
198             map[i]--;
199         }
200       }
201     }
202
203     if (ob->actfmap == BLI_listbase_count(&ob->fmaps))
204       ob->actfmap--;
205
206     BLI_remlink(&ob->fmaps, fmap);
207     MEM_freeN(fmap);
208   }
209 }
210
211 static void fmap_remove_exec(Object *ob, bFaceMap *fmap, const bool is_edit_mode, const bool purge)
212 {
213   if (is_edit_mode)
214     object_fmap_remove_edit_mode(ob, fmap, false, purge);
215   else
216     object_fmap_remove_object_mode(ob, fmap, purge);
217 }
218
219 void BKE_object_facemap_remove(Object *ob, bFaceMap *fmap)
220 {
221   fmap_remove_exec(ob, fmap, BKE_object_is_in_editmode(ob), true);
222 }
223
224 void BKE_object_facemap_clear(Object *ob)
225 {
226   bFaceMap *fmap = (bFaceMap *)ob->fmaps.first;
227
228   if (fmap) {
229     const bool edit_mode = BKE_object_is_in_editmode_vgroup(ob);
230
231     while (fmap) {
232       bFaceMap *next_fmap = fmap->next;
233       fmap_remove_exec(ob, fmap, edit_mode, false);
234       fmap = next_fmap;
235     }
236   }
237   /* remove all face-maps */
238   if (ob->type == OB_MESH) {
239     Mesh *me = ob->data;
240     CustomData_free_layer(&me->pdata, CD_FACEMAP, me->totpoly, 0);
241   }
242   ob->actfmap = 0;
243 }
244
245 int BKE_object_facemap_name_index(Object *ob, const char *name)
246 {
247   return (name) ? BLI_findstringindex(&ob->fmaps, name, offsetof(bFaceMap, name)) : -1;
248 }
249
250 bFaceMap *BKE_object_facemap_find_name(Object *ob, const char *name)
251 {
252   return BLI_findstring(&ob->fmaps, name, offsetof(bFaceMap, name));
253 }