Change !BLI_ghashIterator_isDone to BLI_ghashIterator_notDone. It is
[blender.git] / source / blender / modifiers / intern / MOD_mask.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software  Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2005 by the Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Daniel Dunbar
22  *                 Ton Roosendaal,
23  *                 Ben Batt,
24  *                 Brecht Van Lommel,
25  *                 Campbell Barton
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  *
29  */
30
31 /** \file blender/modifiers/intern/MOD_mask.c
32  *  \ingroup modifiers
33  */
34
35
36 #include "MEM_guardedalloc.h"
37
38 #include "BLI_utildefines.h"
39 #include "BLI_listbase.h"
40 #include "BLI_string.h"
41 #include "BLI_ghash.h"
42
43 #include "DNA_armature_types.h"
44 #include "DNA_meshdata_types.h"
45 #include "DNA_modifier_types.h"
46 #include "DNA_object_types.h"
47
48 #include "BKE_action.h" /* BKE_pose_channel_find_name */
49 #include "BKE_cdderivedmesh.h"
50 #include "BKE_mesh.h"
51 #include "BKE_modifier.h"
52 #include "BKE_deform.h"
53
54 #include "depsgraph_private.h"
55
56 #include "MOD_util.h"
57
58 static void copyData(ModifierData *md, ModifierData *target)
59 {
60         MaskModifierData *mmd = (MaskModifierData *) md;
61         MaskModifierData *tmmd = (MaskModifierData *) target;
62         
63         BLI_strncpy(tmmd->vgroup, mmd->vgroup, sizeof(tmmd->vgroup));
64         tmmd->flag = mmd->flag;
65 }
66
67 static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *UNUSED(md))
68 {
69         return CD_MASK_MDEFORMVERT;
70 }
71
72 static void foreachObjectLink(
73         ModifierData *md, Object *ob,
74         void (*walk)(void *userData, Object *ob, Object **obpoin),
75         void *userData)
76 {
77         MaskModifierData *mmd = (MaskModifierData *)md;
78         walk(userData, ob, &mmd->ob_arm);
79 }
80
81 static void updateDepgraph(ModifierData *md, DagForest *forest,
82                            struct Scene *UNUSED(scene),
83                            Object *UNUSED(ob),
84                            DagNode *obNode)
85 {
86         MaskModifierData *mmd = (MaskModifierData *)md;
87
88         if (mmd->ob_arm) {
89                 bArmature *arm = (bArmature *)mmd->ob_arm->data;
90                 DagNode *armNode = dag_get_node(forest, mmd->ob_arm);
91                 
92                 /* tag relationship in depsgraph, but also on the armature */
93                 dag_add_relation(forest, armNode, obNode, DAG_RL_DATA_DATA | DAG_RL_OB_DATA, "Mask Modifier");
94                 arm->flag |= ARM_HAS_VIZ_DEPS;
95         }
96 }
97
98 static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
99                                   DerivedMesh *derivedData,
100                                   ModifierApplyFlag UNUSED(flag))
101 {
102         MaskModifierData *mmd = (MaskModifierData *)md;
103         DerivedMesh *dm = derivedData, *result = NULL;
104         GHash *vertHash = NULL, *edgeHash, *polyHash;
105         GHashIterator *hashIter;
106         MDeformVert *dvert = NULL, *dv;
107         int numPolys = 0, numLoops = 0, numEdges = 0, numVerts = 0;
108         int maxVerts, maxEdges, maxPolys;
109         int i;
110
111         MPoly *mpoly;
112         MLoop *mloop;
113
114         MPoly *mpoly_new;
115         MLoop *mloop_new;
116         MEdge *medge_new;
117         MVert *mvert_new;
118
119
120         int *loop_mapping;
121
122         /* Overview of Method:
123          *      1. Get the vertices that are in the vertexgroup of interest 
124          *      2. Filter out unwanted geometry (i.e. not in vertexgroup), by populating mappings with new vs old indices
125          *      3. Make a new mesh containing only the mapping data
126          */
127         
128         /* get original number of verts, edges, and faces */
129         maxVerts = dm->getNumVerts(dm);
130         maxEdges = dm->getNumEdges(dm);
131         maxPolys = dm->getNumPolys(dm);
132         
133         /* check if we can just return the original mesh 
134          *      - must have verts and therefore verts assigned to vgroups to do anything useful
135          */
136         if (!(ELEM(mmd->mode, MOD_MASK_MODE_ARM, MOD_MASK_MODE_VGROUP)) ||
137             (maxVerts == 0) || (ob->defbase.first == NULL) )
138         {
139                 return derivedData;
140         }
141         
142         /* if mode is to use selected armature bones, aggregate the bone groups */
143         if (mmd->mode == MOD_MASK_MODE_ARM) { /* --- using selected bones --- */
144                 Object *oba = mmd->ob_arm;
145                 bPoseChannel *pchan;
146                 bDeformGroup *def;
147                 char *bone_select_array;
148                 int bone_select_tot = 0;
149                 const int defbase_tot = BLI_countlist(&ob->defbase);
150                 
151                 /* check that there is armature object with bones to use, otherwise return original mesh */
152                 if (ELEM3(NULL, oba, oba->pose, ob->defbase.first))
153                         return derivedData;
154                 
155                 /* determine whether each vertexgroup is associated with a selected bone or not 
156                  * - each cell is a boolean saying whether bone corresponding to the ith group is selected
157                  * - groups that don't match a bone are treated as not existing (along with the corresponding ungrouped verts)
158                  */
159                 bone_select_array = MEM_mallocN(defbase_tot * sizeof(char), "mask array");
160                 
161                 for (i = 0, def = ob->defbase.first; def; def = def->next, i++) {
162                         pchan = BKE_pose_channel_find_name(oba->pose, def->name);
163                         if (pchan && pchan->bone && (pchan->bone->flag & BONE_SELECTED)) {
164                                 bone_select_array[i] = TRUE;
165                                 bone_select_tot++;
166                         }
167                         else {
168                                 bone_select_array[i] = FALSE;
169                         }
170                 }
171                 
172                 /* if no dverts (i.e. no data for vertex groups exists), we've got an
173                  * inconsistent situation, so free hashes and return oirginal mesh
174                  */
175                 dvert = dm->getVertDataArray(dm, CD_MDEFORMVERT);
176                 if (dvert == NULL) {
177                         MEM_freeN(bone_select_array);
178                         return derivedData;
179                 }
180                 
181                 /* verthash gives mapping from original vertex indices to the new indices (including selected matches only)
182                  * key = oldindex, value = newindex
183                  */
184                 vertHash = BLI_ghash_int_new("mask vert gh");
185                 
186                 /* add vertices which exist in vertexgroups into vertHash for filtering 
187                  * - dv = for each vertex, what vertexgroups does it belong to
188                  * - dw = weight that vertex was assigned to a vertexgroup it belongs to
189                  */
190                 for (i = 0, dv = dvert; i < maxVerts; i++, dv++) {
191                         MDeformWeight *dw = dv->dw;
192                         short found = 0;
193                         int j;
194                         
195                         /* check the groups that vertex is assigned to, and see if it was any use */
196                         for (j = 0; j < dv->totweight; j++, dw++) {
197                                 if (dw->def_nr < defbase_tot) {
198                                         if (bone_select_array[dw->def_nr]) {
199                                                 if (dw->weight != 0.0f) {
200                                                         found = TRUE;
201                                                         break;
202                                                 }
203                                         }
204                                 }
205                         }
206                         
207                         /* check if include vert in vertHash */
208                         if (mmd->flag & MOD_MASK_INV) {
209                                 /* if this vert is in the vgroup, don't include it in vertHash */
210                                 if (found) continue;
211                         }
212                         else {
213                                 /* if this vert isn't in the vgroup, don't include it in vertHash */
214                                 if (!found) continue;
215                         }
216                         
217                         /* add to ghash for verts (numVerts acts as counter for mapping) */
218                         BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(i), SET_INT_IN_POINTER(numVerts));
219                         numVerts++;
220                 }
221                 
222                 /* free temp hashes */
223                 MEM_freeN(bone_select_array);
224         }
225         else {  /* --- Using Nominated VertexGroup only --- */
226                 int defgrp_index = defgroup_name_index(ob, mmd->vgroup);
227                 
228                 /* get dverts */
229                 if (defgrp_index != -1)
230                         dvert = dm->getVertDataArray(dm, CD_MDEFORMVERT);
231                         
232                 /* if no vgroup (i.e. dverts) found, return the initial mesh */
233                 if ((defgrp_index == -1) || (dvert == NULL))
234                         return dm;
235                         
236                 /* hashes for quickly providing a mapping from old to new - use key=oldindex, value=newindex */
237                 vertHash = BLI_ghash_int_new("mask vert2 bh");
238                 
239                 /* add vertices which exist in vertexgroup into ghash for filtering */
240                 for (i = 0, dv = dvert; i < maxVerts; i++, dv++) {
241                         const int weight_set = defvert_find_weight(dv, defgrp_index) != 0.0f;
242                         
243                         /* check if include vert in vertHash */
244                         if (mmd->flag & MOD_MASK_INV) {
245                                 /* if this vert is in the vgroup, don't include it in vertHash */
246                                 if (weight_set) continue;
247                         }
248                         else {
249                                 /* if this vert isn't in the vgroup, don't include it in vertHash */
250                                 if (!weight_set) continue;
251                         }
252                         
253                         /* add to ghash for verts (numVerts acts as counter for mapping) */
254                         BLI_ghash_insert(vertHash, SET_INT_IN_POINTER(i), SET_INT_IN_POINTER(numVerts));
255                         numVerts++;
256                 }
257         }
258
259         /* hashes for quickly providing a mapping from old to new - use key=oldindex, value=newindex */
260         edgeHash = BLI_ghash_int_new("mask ed2 gh");
261         polyHash = BLI_ghash_int_new("mask fa2 gh");
262         
263         mpoly = dm->getPolyArray(dm);
264         mloop = dm->getLoopArray(dm);
265
266         loop_mapping = MEM_callocN(sizeof(int) * maxPolys, "mask loopmap"); /* overalloc, assume all polys are seen */
267
268         /* loop over edges and faces, and do the same thing to 
269          * ensure that they only reference existing verts 
270          */
271         for (i = 0; i < maxEdges; i++) {
272                 MEdge me;
273                 dm->getEdge(dm, i, &me);
274                 
275                 /* only add if both verts will be in new mesh */
276                 if (BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me.v1)) &&
277                     BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(me.v2)))
278                 {
279                         BLI_ghash_insert(edgeHash, SET_INT_IN_POINTER(i), SET_INT_IN_POINTER(numEdges));
280                         numEdges++;
281                 }
282         }
283         for (i = 0; i < maxPolys; i++) {
284                 MPoly *mp = &mpoly[i];
285                 MLoop *ml = mloop + mp->loopstart;
286                 int ok = TRUE;
287                 int j;
288                 
289                 for (j = 0; j < mp->totloop; j++, ml++) {
290                         if (!BLI_ghash_haskey(vertHash, SET_INT_IN_POINTER(ml->v))) {
291                                 ok = FALSE;
292                                 break;
293                         }
294                 }
295                 
296                 /* all verts must be available */
297                 if (ok) {
298                         BLI_ghash_insert(polyHash, SET_INT_IN_POINTER(i), SET_INT_IN_POINTER(numPolys));
299                         loop_mapping[numPolys] = numLoops;
300                         numPolys++;
301                         numLoops += mp->totloop;
302                 }
303         }
304         
305         
306         /* now we know the number of verts, edges and faces, 
307          * we can create the new (reduced) mesh
308          */
309         result = CDDM_from_template(dm, numVerts, numEdges, 0, numLoops, numPolys);
310         
311         mpoly_new = CDDM_get_polys(result);
312         mloop_new = CDDM_get_loops(result);
313         medge_new = CDDM_get_edges(result);
314         mvert_new = CDDM_get_verts(result);
315         
316         /* using ghash-iterators, map data into new mesh */
317         /* vertices */
318         for (hashIter = BLI_ghashIterator_new(vertHash);
319              BLI_ghashIterator_notDone(hashIter);
320              BLI_ghashIterator_step(hashIter) )
321         {
322                 MVert source;
323                 MVert *dest;
324                 int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
325                 int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
326                 
327                 dm->getVert(dm, oldIndex, &source);
328                 dest = &mvert_new[newIndex];
329                 
330                 DM_copy_vert_data(dm, result, oldIndex, newIndex, 1);
331                 *dest = source;
332         }
333         BLI_ghashIterator_free(hashIter);
334                 
335         /* edges */
336         for (hashIter = BLI_ghashIterator_new(edgeHash);
337              BLI_ghashIterator_notDone(hashIter);
338              BLI_ghashIterator_step(hashIter))
339         {
340                 MEdge source;
341                 MEdge *dest;
342                 int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
343                 int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
344                 
345                 dm->getEdge(dm, oldIndex, &source);
346                 dest = &medge_new[newIndex];
347                 
348                 source.v1 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v1)));
349                 source.v2 = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source.v2)));
350                 
351                 DM_copy_edge_data(dm, result, oldIndex, newIndex, 1);
352                 *dest = source;
353         }
354         BLI_ghashIterator_free(hashIter);
355         
356         /* faces */
357         for (hashIter = BLI_ghashIterator_new(polyHash);
358              BLI_ghashIterator_notDone(hashIter);
359              BLI_ghashIterator_step(hashIter) )
360         {
361                 int oldIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getKey(hashIter));
362                 int newIndex = GET_INT_FROM_POINTER(BLI_ghashIterator_getValue(hashIter));
363                 MPoly *source = &mpoly[oldIndex];
364                 MPoly *dest = &mpoly_new[newIndex];
365                 int oldLoopIndex = source->loopstart;
366                 int newLoopIndex = loop_mapping[newIndex];
367                 MLoop *source_loop = &mloop[oldLoopIndex];
368                 MLoop *dest_loop = &mloop_new[newLoopIndex];
369                 
370                 DM_copy_poly_data(dm, result, oldIndex, newIndex, 1);
371                 DM_copy_loop_data(dm, result, oldLoopIndex, newLoopIndex, source->totloop);
372
373                 *dest = *source;
374                 dest->loopstart = newLoopIndex;
375                 for (i = 0; i < source->totloop; i++) {
376                         dest_loop[i].v = GET_INT_FROM_POINTER(BLI_ghash_lookup(vertHash, SET_INT_IN_POINTER(source_loop[i].v)));
377                         dest_loop[i].e = GET_INT_FROM_POINTER(BLI_ghash_lookup(edgeHash, SET_INT_IN_POINTER(source_loop[i].e)));
378                 }
379         }
380
381         BLI_ghashIterator_free(hashIter);
382
383         MEM_freeN(loop_mapping);
384
385         /* why is this needed? - campbell */
386         /* recalculate normals */
387         CDDM_calc_normals(result);
388         
389         /* free hashes */
390         BLI_ghash_free(vertHash, NULL, NULL);
391         BLI_ghash_free(edgeHash, NULL, NULL);
392         BLI_ghash_free(polyHash, NULL, NULL);
393
394         /* return the new mesh */
395         return result;
396 }
397
398
399 ModifierTypeInfo modifierType_Mask = {
400         /* name */              "Mask",
401         /* structName */        "MaskModifierData",
402         /* structSize */        sizeof(MaskModifierData),
403         /* type */              eModifierTypeType_Nonconstructive,
404         /* flags */             eModifierTypeFlag_AcceptsMesh |
405                                 eModifierTypeFlag_SupportsMapping |
406                                 eModifierTypeFlag_SupportsEditmode,
407
408         /* copyData */          copyData,
409         /* deformVerts */       NULL,
410         /* deformMatrices */    NULL,
411         /* deformVertsEM */     NULL,
412         /* deformMatricesEM */  NULL,
413         /* applyModifier */     applyModifier,
414         /* applyModifierEM */   NULL,
415         /* initData */          NULL,
416         /* requiredDataMask */  requiredDataMask,
417         /* freeData */          NULL,
418         /* isDisabled */        NULL,
419         /* updateDepgraph */    updateDepgraph,
420         /* dependsOnTime */     NULL,
421         /* dependsOnNormals */  NULL,
422         /* foreachObjectLink */ foreachObjectLink,
423         /* foreachIDLink */     NULL,
424         /* foreachTexLink */    NULL,
425 };