GPU: Fix broken assert
[blender.git] / source / blender / modifiers / intern / MOD_mask.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) 2005 by the Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup modifiers
22  */
23
24 #include "MEM_guardedalloc.h"
25
26 #include "BLI_utildefines.h"
27
28 #include "BLI_listbase.h"
29 #include "BLI_ghash.h"
30
31 #include "DNA_armature_types.h"
32 #include "DNA_mesh_types.h"
33 #include "DNA_meshdata_types.h"
34 #include "DNA_modifier_types.h"
35 #include "DNA_object_types.h"
36
37 #include "BKE_action.h" /* BKE_pose_channel_find_name */
38 #include "BKE_customdata.h"
39 #include "BKE_library_query.h"
40 #include "BKE_mesh.h"
41 #include "BKE_modifier.h"
42 #include "BKE_deform.h"
43
44 #include "DEG_depsgraph_build.h"
45 #include "DEG_depsgraph_query.h"
46
47 #include "MOD_modifiertypes.h"
48
49 #include "BLI_strict_flags.h"
50
51 static void requiredDataMask(Object *UNUSED(ob),
52                              ModifierData *UNUSED(md),
53                              CustomData_MeshMasks *r_cddata_masks)
54 {
55   r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
56 }
57
58 static void foreachObjectLink(ModifierData *md, Object *ob, ObjectWalkFunc walk, void *userData)
59 {
60   MaskModifierData *mmd = (MaskModifierData *)md;
61   walk(userData, ob, &mmd->ob_arm, IDWALK_CB_NOP);
62 }
63
64 static void updateDepsgraph(ModifierData *md, const ModifierUpdateDepsgraphContext *ctx)
65 {
66   MaskModifierData *mmd = (MaskModifierData *)md;
67   if (mmd->ob_arm) {
68     bArmature *arm = (bArmature *)mmd->ob_arm->data;
69     /* Tag relationship in depsgraph, but also on the armature. */
70     /* TODO(sergey): Is it a proper relation here? */
71     DEG_add_object_relation(ctx->node, mmd->ob_arm, DEG_OB_COMP_TRANSFORM, "Mask Modifier");
72     arm->flag |= ARM_HAS_VIZ_DEPS;
73     DEG_add_modifier_to_transform_relation(ctx->node, "Mask Modifier");
74   }
75 }
76
77 static Mesh *applyModifier(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mesh)
78 {
79   MaskModifierData *mmd = (MaskModifierData *)md;
80   Object *ob = ctx->object;
81   const bool found_test = (mmd->flag & MOD_MASK_INV) == 0;
82   Mesh *result = NULL;
83   GHash *vertHash = NULL, *edgeHash, *polyHash;
84   GHashIterator gh_iter;
85   MDeformVert *dvert, *dv;
86   int numPolys = 0, numLoops = 0, numEdges = 0, numVerts = 0;
87   int maxVerts, maxEdges, maxPolys;
88   int i;
89
90   const MVert *mvert_src;
91   const MEdge *medge_src;
92   const MPoly *mpoly_src;
93   const MLoop *mloop_src;
94
95   MPoly *mpoly_dst;
96   MLoop *mloop_dst;
97   MEdge *medge_dst;
98   MVert *mvert_dst;
99
100   int *loop_mapping;
101
102   dvert = CustomData_get_layer(&mesh->vdata, CD_MDEFORMVERT);
103   if (dvert == NULL) {
104     return found_test ? BKE_mesh_new_nomain_from_template(mesh, 0, 0, 0, 0, 0) : mesh;
105   }
106
107   /* Overview of Method:
108    * 1. Get the vertices that are in the vertexgroup of interest.
109    * 2. Filter out unwanted geometry (i.e. not in vertexgroup),
110    *    by populating mappings with new vs old indices.
111    * 3. Make a new mesh containing only the mapping data.
112    */
113
114   /* get original number of verts, edges, and faces */
115   maxVerts = mesh->totvert;
116   maxEdges = mesh->totedge;
117   maxPolys = mesh->totpoly;
118
119   /* check if we can just return the original mesh
120    * - must have verts and therefore verts assigned to vgroups to do anything useful
121    */
122   if (!(ELEM(mmd->mode, MOD_MASK_MODE_ARM, MOD_MASK_MODE_VGROUP)) || (maxVerts == 0) ||
123       BLI_listbase_is_empty(&ob->defbase)) {
124     return mesh;
125   }
126
127   /* if mode is to use selected armature bones, aggregate the bone groups */
128   if (mmd->mode == MOD_MASK_MODE_ARM) { /* --- using selected bones --- */
129     Object *oba = mmd->ob_arm;
130     bPoseChannel *pchan;
131     bDeformGroup *def;
132     bool *bone_select_array;
133     int bone_select_tot = 0;
134     const int defbase_tot = BLI_listbase_count(&ob->defbase);
135
136     /* check that there is armature object with bones to use, otherwise return original mesh */
137     if (ELEM(NULL, oba, oba->pose, ob->defbase.first)) {
138       return mesh;
139     }
140
141     /* Determine whether each vertex-group is associated with a selected bone or not:
142      * - Each cell is a boolean saying whether bone corresponding to the i'th group selected.
143      * - Groups that don't match a bone are treated as not existing
144      *   (along with the corresponding un-grouped verts).
145      */
146     bone_select_array = MEM_malloc_arrayN((size_t)defbase_tot, sizeof(char), "mask array");
147
148     for (i = 0, def = ob->defbase.first; def; def = def->next, i++) {
149       pchan = BKE_pose_channel_find_name(oba->pose, def->name);
150       if (pchan && pchan->bone && (pchan->bone->flag & BONE_SELECTED)) {
151         bone_select_array[i] = true;
152         bone_select_tot++;
153       }
154       else {
155         bone_select_array[i] = false;
156       }
157     }
158
159     /* verthash gives mapping from original vertex indices to the new indices
160      * (including selected matches only):
161      * key = oldindex, value = newindex
162      */
163     vertHash = BLI_ghash_int_new_ex("mask vert gh", (unsigned int)maxVerts);
164
165     /* add vertices which exist in vertexgroups into vertHash for filtering
166      * - dv = for each vertex, what vertexgroups does it belong to
167      * - dw = weight that vertex was assigned to a vertexgroup it belongs to
168      */
169     for (i = 0, dv = dvert; i < maxVerts; i++, dv++) {
170       MDeformWeight *dw = dv->dw;
171       bool found = false;
172       int j;
173
174       /* check the groups that vertex is assigned to, and see if it was any use */
175       for (j = 0; j < dv->totweight; j++, dw++) {
176         if (dw->def_nr < defbase_tot) {
177           if (bone_select_array[dw->def_nr]) {
178             if (dw->weight > mmd->threshold) {
179               found = true;
180               break;
181             }
182           }
183         }
184       }
185
186       if (found_test != found) {
187         continue;
188       }
189
190       /* add to ghash for verts (numVerts acts as counter for mapping) */
191       BLI_ghash_insert(vertHash, POINTER_FROM_INT(i), POINTER_FROM_INT(numVerts));
192       numVerts++;
193     }
194
195     /* free temp hashes */
196     MEM_freeN(bone_select_array);
197   }
198   else { /* --- Using Nominated VertexGroup only --- */
199     int defgrp_index = defgroup_name_index(ob, mmd->vgroup);
200
201     /* if no vgroup (i.e. dverts) found, return the initial mesh */
202     if (defgrp_index == -1) {
203       return mesh;
204     }
205
206     /* hashes for quickly providing a mapping from old to new - use key=oldindex, value=newindex */
207     vertHash = BLI_ghash_int_new_ex("mask vert2 bh", (unsigned int)maxVerts);
208
209     /* add vertices which exist in vertexgroup into ghash for filtering */
210     for (i = 0, dv = dvert; i < maxVerts; i++, dv++) {
211       const bool found = defvert_find_weight(dv, defgrp_index) > mmd->threshold;
212       if (found_test != found) {
213         continue;
214       }
215
216       /* add to ghash for verts (numVerts acts as counter for mapping) */
217       BLI_ghash_insert(vertHash, POINTER_FROM_INT(i), POINTER_FROM_INT(numVerts));
218       numVerts++;
219     }
220   }
221
222   /* hashes for quickly providing a mapping from old to new - use key=oldindex, value=newindex */
223   edgeHash = BLI_ghash_int_new_ex("mask ed2 gh", (unsigned int)maxEdges);
224   polyHash = BLI_ghash_int_new_ex("mask fa2 gh", (unsigned int)maxPolys);
225
226   mvert_src = mesh->mvert;
227   medge_src = mesh->medge;
228   mpoly_src = mesh->mpoly;
229   mloop_src = mesh->mloop;
230
231   /* overalloc, assume all polys are seen */
232   loop_mapping = MEM_malloc_arrayN((size_t)maxPolys, sizeof(int), "mask loopmap");
233
234   /* loop over edges and faces, and do the same thing to
235    * ensure that they only reference existing verts
236    */
237   for (i = 0; i < maxEdges; i++) {
238     const MEdge *me = &medge_src[i];
239
240     /* only add if both verts will be in new mesh */
241     if (BLI_ghash_haskey(vertHash, POINTER_FROM_INT(me->v1)) &&
242         BLI_ghash_haskey(vertHash, POINTER_FROM_INT(me->v2))) {
243       BLI_ghash_insert(edgeHash, POINTER_FROM_INT(i), POINTER_FROM_INT(numEdges));
244       numEdges++;
245     }
246   }
247   for (i = 0; i < maxPolys; i++) {
248     const MPoly *mp_src = &mpoly_src[i];
249     const MLoop *ml_src = &mloop_src[mp_src->loopstart];
250     bool ok = true;
251     int j;
252
253     for (j = 0; j < mp_src->totloop; j++, ml_src++) {
254       if (!BLI_ghash_haskey(vertHash, POINTER_FROM_INT(ml_src->v))) {
255         ok = false;
256         break;
257       }
258     }
259
260     /* all verts must be available */
261     if (ok) {
262       BLI_ghash_insert(polyHash, POINTER_FROM_INT(i), POINTER_FROM_INT(numPolys));
263       loop_mapping[numPolys] = numLoops;
264       numPolys++;
265       numLoops += mp_src->totloop;
266     }
267   }
268
269   /* now we know the number of verts, edges and faces,
270    * we can create the new (reduced) mesh
271    */
272   result = BKE_mesh_new_nomain_from_template(mesh, numVerts, numEdges, 0, numLoops, numPolys);
273
274   mpoly_dst = result->mpoly;
275   mloop_dst = result->mloop;
276   medge_dst = result->medge;
277   mvert_dst = result->mvert;
278
279   /* using ghash-iterators, map data into new mesh */
280   /* vertices */
281   GHASH_ITER (gh_iter, vertHash) {
282     const MVert *v_src;
283     MVert *v_dst;
284     const int i_src = POINTER_AS_INT(BLI_ghashIterator_getKey(&gh_iter));
285     const int i_dst = POINTER_AS_INT(BLI_ghashIterator_getValue(&gh_iter));
286
287     v_src = &mvert_src[i_src];
288     v_dst = &mvert_dst[i_dst];
289
290     *v_dst = *v_src;
291     CustomData_copy_data(&mesh->vdata, &result->vdata, i_src, i_dst, 1);
292   }
293
294   /* edges */
295   GHASH_ITER (gh_iter, edgeHash) {
296     const MEdge *e_src;
297     MEdge *e_dst;
298     const int i_src = POINTER_AS_INT(BLI_ghashIterator_getKey(&gh_iter));
299     const int i_dst = POINTER_AS_INT(BLI_ghashIterator_getValue(&gh_iter));
300
301     e_src = &medge_src[i_src];
302     e_dst = &medge_dst[i_dst];
303
304     CustomData_copy_data(&mesh->edata, &result->edata, i_src, i_dst, 1);
305     *e_dst = *e_src;
306     e_dst->v1 = POINTER_AS_UINT(BLI_ghash_lookup(vertHash, POINTER_FROM_UINT(e_src->v1)));
307     e_dst->v2 = POINTER_AS_UINT(BLI_ghash_lookup(vertHash, POINTER_FROM_UINT(e_src->v2)));
308   }
309
310   /* faces */
311   GHASH_ITER (gh_iter, polyHash) {
312     const int i_src = POINTER_AS_INT(BLI_ghashIterator_getKey(&gh_iter));
313     const int i_dst = POINTER_AS_INT(BLI_ghashIterator_getValue(&gh_iter));
314     const MPoly *mp_src = &mpoly_src[i_src];
315     MPoly *mp_dst = &mpoly_dst[i_dst];
316     const int i_ml_src = mp_src->loopstart;
317     const int i_ml_dst = loop_mapping[i_dst];
318     const MLoop *ml_src = &mloop_src[i_ml_src];
319     MLoop *ml_dst = &mloop_dst[i_ml_dst];
320
321     CustomData_copy_data(&mesh->pdata, &result->pdata, i_src, i_dst, 1);
322     CustomData_copy_data(&mesh->ldata, &result->ldata, i_ml_src, i_ml_dst, mp_src->totloop);
323
324     *mp_dst = *mp_src;
325     mp_dst->loopstart = i_ml_dst;
326     for (i = 0; i < mp_src->totloop; i++) {
327       ml_dst[i].v = POINTER_AS_UINT(BLI_ghash_lookup(vertHash, POINTER_FROM_UINT(ml_src[i].v)));
328       ml_dst[i].e = POINTER_AS_UINT(BLI_ghash_lookup(edgeHash, POINTER_FROM_UINT(ml_src[i].e)));
329     }
330   }
331
332   MEM_freeN(loop_mapping);
333
334   /* why is this needed? - campbell */
335   /* recalculate normals */
336   result->runtime.cd_dirty_vert |= CD_MASK_NORMAL;
337
338   /* free hashes */
339   BLI_ghash_free(vertHash, NULL, NULL);
340   BLI_ghash_free(edgeHash, NULL, NULL);
341   BLI_ghash_free(polyHash, NULL, NULL);
342
343   /* return the new mesh */
344   return result;
345 }
346
347 static bool isDisabled(const struct Scene *UNUSED(scene),
348                        ModifierData *md,
349                        bool UNUSED(useRenderParams))
350 {
351   MaskModifierData *mmd = (MaskModifierData *)md;
352
353   /* The object type check is only needed here in case we have a placeholder
354    * object assigned (because the library containing the armature is missing).
355    *
356    * In other cases it should be impossible to have a type mismatch.
357    */
358   return mmd->ob_arm && mmd->ob_arm->type != OB_ARMATURE;
359 }
360
361 ModifierTypeInfo modifierType_Mask = {
362     /* name */ "Mask",
363     /* structName */ "MaskModifierData",
364     /* structSize */ sizeof(MaskModifierData),
365     /* type */ eModifierTypeType_Nonconstructive,
366     /* flags */ eModifierTypeFlag_AcceptsMesh | eModifierTypeFlag_SupportsMapping |
367         eModifierTypeFlag_SupportsEditmode,
368
369     /* copyData */ modifier_copyData_generic,
370
371     /* deformVerts */ NULL,
372     /* deformMatrices */ NULL,
373     /* deformVertsEM */ NULL,
374     /* deformMatricesEM */ NULL,
375     /* applyModifier */ applyModifier,
376
377     /* initData */ NULL,
378     /* requiredDataMask */ requiredDataMask,
379     /* freeData */ NULL,
380     /* isDisabled */ isDisabled,
381     /* updateDepsgraph */ updateDepsgraph,
382     /* dependsOnTime */ NULL,
383     /* dependsOnNormals */ NULL,
384     /* foreachObjectLink */ foreachObjectLink,
385     /* foreachIDLink */ NULL,
386     /* foreachTexLink */ NULL,
387     /* freeRuntimeData */ NULL,
388 };