patch [#31104] Correct comment for mul_qt_v3
[blender.git] / source / blender / editors / util / crazyspace.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 Blender Foundation.
19  * All rights reserved.
20  *
21  *
22  * Contributor(s): Blender Foundation,
23  *                 Sergey Sharybin
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/util/crazyspace.c
29  *  \ingroup edutil
30  */
31
32
33 #include "MEM_guardedalloc.h"
34
35 #include "DNA_scene_types.h"
36 #include "DNA_object_types.h"
37 #include "DNA_modifier_types.h"
38 #include "DNA_mesh_types.h"
39 #include "DNA_meshdata_types.h"
40
41 #include "BLI_utildefines.h"
42 #include "BLI_math.h"
43
44 #include "BKE_DerivedMesh.h"
45 #include "BKE_modifier.h"
46 #include "BKE_multires.h"
47 #include "BKE_mesh.h"
48 #include "BKE_tessmesh.h"
49
50 #include "ED_util.h"
51
52 typedef struct {
53         float *vertexcos;
54         short *flags;
55 } MappedUserData;
56
57 #define TAN_MAKE_VEC(a, b, c)   a[0] = b[0] + 0.2f * (b[0] - c[0]); a[1] = b[1] + 0.2f * (b[1] - c[1]); a[2] = b[2] + 0.2f * (b[2] - c[2])
58 static void set_crazy_vertex_quat(float *quat, float *v1, float *v2, float *v3, float *def1, float *def2, float *def3)
59 {
60         float vecu[3], vecv[3];
61         float q1[4], q2[4];
62
63         TAN_MAKE_VEC(vecu, v1, v2);
64         TAN_MAKE_VEC(vecv, v1, v3);
65         tri_to_quat(q1, v1, vecu, vecv);
66
67         TAN_MAKE_VEC(vecu, def1, def2);
68         TAN_MAKE_VEC(vecv, def1, def3);
69         tri_to_quat(q2, def1, vecu, vecv);
70
71         sub_qt_qtqt(quat, q2, q1);
72 }
73 #undef TAN_MAKE_VEC
74
75 static void make_vertexcos__mapFunc(void *userData, int index, const float co[3],
76                                     const float UNUSED(no_f[3]), const short UNUSED(no_s[3]))
77 {
78         MappedUserData *mappedData = (MappedUserData *)userData;
79         float *vec = mappedData->vertexcos;
80
81         vec += 3 * index;
82         if (!mappedData->flags[index]) {
83                 /* we need coord from prototype vertex, not it clones or images,
84                  * suppose they stored in the beginning of vertex array stored in DM */
85                 copy_v3_v3(vec, co);
86                 mappedData->flags[index] = 1;
87         }
88 }
89
90 static int modifiers_disable_subsurf_temporary(Object *ob)
91 {
92         ModifierData *md;
93         int disabled = 0;
94
95         for (md = ob->modifiers.first; md; md = md->next)
96                 if (md->type == eModifierType_Subsurf)
97                         if (md->mode & eModifierMode_OnCage) {
98                                 md->mode ^= eModifierMode_DisableTemporary;
99                                 disabled = 1;
100                         }
101
102         return disabled;
103 }
104
105 /* disable subsurf temporal, get mapped cos, and enable it */
106 float *crazyspace_get_mapped_editverts(Scene *scene, Object *obedit)
107 {
108         Mesh *me = obedit->data;
109         DerivedMesh *dm;
110         float *vertexcos;
111         int nverts = me->edit_btmesh->bm->totvert;
112         short *flags;
113         MappedUserData userData;
114
115         /* disable subsurf temporal, get mapped cos, and enable it */
116         if (modifiers_disable_subsurf_temporary(obedit)) {
117                 /* need to make new derivemesh */
118                 makeDerivedMesh(scene, obedit, me->edit_btmesh, CD_MASK_BAREMESH, 0);
119         }
120
121         /* now get the cage */
122         dm = editbmesh_get_derived_cage(scene, obedit, me->edit_btmesh, CD_MASK_BAREMESH);
123
124         vertexcos = MEM_callocN(3 * sizeof(float) * nverts, "vertexcos map");
125         flags = MEM_callocN(sizeof(short) * nverts, "vertexcos flags");
126
127         userData.vertexcos = vertexcos;
128         userData.flags = flags;
129         dm->foreachMappedVert(dm, make_vertexcos__mapFunc, &userData);
130
131         dm->release(dm);
132
133         /* set back the flag, no new cage needs to be built, transform does it */
134         modifiers_disable_subsurf_temporary(obedit);
135
136         MEM_freeN(flags);
137
138         return vertexcos;
139 }
140
141 void crazyspace_set_quats_editmesh(BMEditMesh *em, float *origcos, float *mappedcos, float *quats)
142 {
143         BMVert *v;
144         BMIter iter, liter;
145         BMLoop *l;
146         float *v1, *v2, *v3, *co1, *co2, *co3;
147         int *vert_table = MEM_callocN(sizeof(int) * em->bm->totvert, "vert_table");
148         int index = 0;
149
150         BM_mesh_elem_index_ensure(em->bm, BM_VERT);
151
152         BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
153                 if (!BM_elem_flag_test(v, BM_ELEM_SELECT) || BM_elem_flag_test(v, BM_ELEM_HIDDEN))
154                         continue;
155                 
156                 BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
157                         BMLoop *l2 = BM_face_other_edge_loop(l->f, l->e, v);
158                         
159                         /* retrieve mapped coordinates */
160                         v1 = mappedcos + 3 * BM_elem_index_get(l->v);
161                         v2 = mappedcos + 3 * BM_elem_index_get(BM_edge_other_vert(l2->e, l->v));
162                         v3 = mappedcos + 3 * BM_elem_index_get(BM_edge_other_vert(l->e, l->v));
163
164                         co1 = (origcos) ? origcos + 3 * BM_elem_index_get(l->v) : l->v->co;
165                         co2 = (origcos) ? origcos + 3 * BM_elem_index_get(BM_edge_other_vert(l2->e, l->v)) : BM_edge_other_vert(l2->e, l->v)->co;
166                         co3 = (origcos) ? origcos + 3 * BM_elem_index_get(BM_edge_other_vert(l->e, l->v)) : BM_edge_other_vert(l->e, l->v)->co;
167                         
168                         set_crazy_vertex_quat(quats, v1, v2, v3, co1, co2, co3);
169                         quats += 4;
170                         
171                         vert_table[BM_elem_index_get(l->v)] = index + 1;
172                         
173                         index++;
174                         break; /*just do one corner*/
175                 }
176         }
177
178         index = 0;
179         BM_ITER_MESH (v, &iter, em->bm, BM_VERTS_OF_MESH) {
180                 if (vert_table[index] != 0)
181                         BM_elem_index_set(v, vert_table[index] - 1);  /* set_dirty! */
182                 else
183                         BM_elem_index_set(v, -1);  /* set_dirty! */
184                 
185                 index++;
186         }
187         em->bm->elem_index_dirty |= BM_VERT;
188
189         MEM_freeN(vert_table);
190 #if 0
191         BMEditVert *eve, *prev;
192         BMEditFace *efa;
193         BMIter iter;
194         float *v1, *v2, *v3, *v4, *co1, *co2, *co3, *co4;
195         intptr_t index = 0;
196
197         /* two abused locations in vertices */
198         for (eve = em->verts.first; eve; eve = eve->next, index++) {
199                 eve->tmp.p = NULL;
200                 eve->prev = (EditVert *)index;
201         }
202
203         /* first store two sets of tangent vectors in vertices, we derive it just from the face-edges */
204         for (efa = em->faces.first; efa; efa = efa->next) {
205
206                 /* retrieve mapped coordinates */
207                 v1 = mappedcos + 3 * (intptr_t)(efa->v1->prev);
208                 v2 = mappedcos + 3 * (intptr_t)(efa->v2->prev);
209                 v3 = mappedcos + 3 * (intptr_t)(efa->v3->prev);
210
211                 co1 = (origcos) ? origcos + 3 * (intptr_t)(efa->v1->prev) : efa->v1->co;
212                 co2 = (origcos) ? origcos + 3 * (intptr_t)(efa->v2->prev) : efa->v2->co;
213                 co3 = (origcos) ? origcos + 3 * (intptr_t)(efa->v3->prev) : efa->v3->co;
214
215                 if (efa->v2->tmp.p == NULL && efa->v2->f1) {
216                         set_crazy_vertex_quat(quats, co2, co3, co1, v2, v3, v1);
217                         efa->v2->tmp.p = (void *)quats;
218                         quats += 4;
219                 }
220
221                 if (efa->v4) {
222                         v4 = mappedcos + 3 * (intptr_t)(efa->v4->prev);
223                         co4 = (origcos) ? origcos + 3 * (intptr_t)(efa->v4->prev) : efa->v4->co;
224
225                         if (efa->v1->tmp.p == NULL && efa->v1->f1) {
226                                 set_crazy_vertex_quat(quats, co1, co2, co4, v1, v2, v4);
227                                 efa->v1->tmp.p = (void *)quats;
228                                 quats += 4;
229                         }
230                         if (efa->v3->tmp.p == NULL && efa->v3->f1) {
231                                 set_crazy_vertex_quat(quats, co3, co4, co2, v3, v4, v2);
232                                 efa->v3->tmp.p = (void *)quats;
233                                 quats += 4;
234                         }
235                         if (efa->v4->tmp.p == NULL && efa->v4->f1) {
236                                 set_crazy_vertex_quat(quats, co4, co1, co3, v4, v1, v3);
237                                 efa->v4->tmp.p = (void *)quats;
238                                 quats += 4;
239                         }
240                 }
241                 else {
242                         if (efa->v1->tmp.p == NULL && efa->v1->f1) {
243                                 set_crazy_vertex_quat(quats, co1, co2, co3, v1, v2, v3);
244                                 efa->v1->tmp.p = (void *)quats;
245                                 quats += 4;
246                         }
247                         if (efa->v3->tmp.p == NULL && efa->v3->f1) {
248                                 set_crazy_vertex_quat(quats, co3, co1, co2, v3, v1, v2);
249                                 efa->v3->tmp.p = (void *)quats;
250                                 quats += 4;
251                         }
252                 }
253         }
254
255         /* restore abused prev pointer */
256         for (prev = NULL, eve = em->verts.first; eve; prev = eve, eve = eve->next)
257                 eve->prev = prev;
258 #endif
259 }
260
261 /* BMESH_TODO - use MPolys over MFace's */
262
263 void crazyspace_set_quats_mesh(Mesh *me, float *origcos, float *mappedcos, float *quats)
264 {
265         int i;
266         MVert *mvert;
267         MFace *mface;
268         float *v1, *v2, *v3, *v4, *co1, *co2, *co3, *co4;
269
270         mvert = me->mvert;
271         for (i = 0; i < me->totvert; i++, mvert++)
272                 mvert->flag &= ~ME_VERT_TMP_TAG;
273
274         /* first store two sets of tangent vectors in vertices, we derive it just from the face-edges */
275         mvert = me->mvert;
276         mface = me->mface;
277         for (i = 0; i < me->totface; i++, mface++) {
278
279                 /* retrieve mapped coordinates */
280                 v1 = mappedcos + 3 * mface->v1;
281                 v2 = mappedcos + 3 * mface->v2;
282                 v3 = mappedcos + 3 * mface->v3;
283
284                 co1 = (origcos) ? origcos + 3 * mface->v1 : mvert[mface->v1].co;
285                 co2 = (origcos) ? origcos + 3 * mface->v2 : mvert[mface->v2].co;
286                 co3 = (origcos) ? origcos + 3 * mface->v3 : mvert[mface->v3].co;
287
288                 if ((mvert[mface->v2].flag & ME_VERT_TMP_TAG) == 0) {
289                         set_crazy_vertex_quat(&quats[mface->v2 * 4], co2, co3, co1, v2, v3, v1);
290                         mvert[mface->v2].flag |= ME_VERT_TMP_TAG;
291                 }
292
293                 if (mface->v4) {
294                         v4 = mappedcos + 3 * mface->v4;
295                         co4 = (origcos) ? origcos + 3 * mface->v4 : mvert[mface->v4].co;
296
297                         if ((mvert[mface->v1].flag & ME_VERT_TMP_TAG) == 0) {
298                                 set_crazy_vertex_quat(&quats[mface->v1 * 4], co1, co2, co4, v1, v2, v4);
299                                 mvert[mface->v1].flag |= ME_VERT_TMP_TAG;
300                         }
301                         if ((mvert[mface->v3].flag & ME_VERT_TMP_TAG) == 0) {
302                                 set_crazy_vertex_quat(&quats[mface->v3 * 4], co3, co4, co2, v3, v4, v2);
303                                 mvert[mface->v3].flag |= ME_VERT_TMP_TAG;
304                         }
305                         if ((mvert[mface->v4].flag & ME_VERT_TMP_TAG) == 0) {
306                                 set_crazy_vertex_quat(&quats[mface->v4 * 4], co4, co1, co3, v4, v1, v3);
307                                 mvert[mface->v4].flag |= ME_VERT_TMP_TAG;
308                         }
309                 }
310                 else {
311                         if ((mvert[mface->v1].flag & ME_VERT_TMP_TAG) == 0) {
312                                 set_crazy_vertex_quat(&quats[mface->v1 * 4], co1, co2, co3, v1, v2, v3);
313                                 mvert[mface->v1].flag |= ME_VERT_TMP_TAG;
314                         }
315                         if ((mvert[mface->v3].flag & ME_VERT_TMP_TAG) == 0) {
316                                 set_crazy_vertex_quat(&quats[mface->v3 * 4], co3, co1, co2, v3, v1, v2);
317                                 mvert[mface->v3].flag |= ME_VERT_TMP_TAG;
318                         }
319                 }
320         }
321 }
322
323 int editbmesh_get_first_deform_matrices(Scene *scene, Object *ob, BMEditMesh *em, 
324                                         float (**deformmats)[3][3], float (**deformcos)[3])
325 {
326         ModifierData *md;
327         DerivedMesh *dm;
328         int i, a, numleft = 0, numVerts = 0;
329         int cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
330         float (*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
331
332         modifiers_clearErrors(ob);
333
334         dm = NULL;
335         md = modifiers_getVirtualModifierList(ob);
336
337         /* compute the deformation matrices and coordinates for the first
338          * modifiers with on cage editing that are enabled and support computing
339          * deform matrices */
340         for (i = 0; md && i <= cageIndex; i++, md = md->next) {
341                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
342
343                 if (!editbmesh_modifier_is_enabled(scene, md, dm))
344                         continue;
345
346                 if (mti->type == eModifierTypeType_OnlyDeform && mti->deformMatricesEM) {
347                         if (!defmats) {
348                                 dm = getEditDerivedBMesh(em, ob, NULL);
349                                 deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
350                                 defmats = MEM_callocN(sizeof(*defmats) * numVerts, "defmats");
351
352                                 for (a = 0; a < numVerts; a++)
353                                         unit_m3(defmats[a]);
354                         }
355
356                         mti->deformMatricesEM(md, ob, em, dm, deformedVerts, defmats,
357                                               numVerts);
358                 }
359                 else
360                         break;
361         }
362
363         for (; md && i <= cageIndex; md = md->next, i++)
364                 if (editbmesh_modifier_is_enabled(scene, md, dm) && modifier_isCorrectableDeformed(md))
365                         numleft++;
366
367         if (dm)
368                 dm->release(dm);
369
370         *deformmats = defmats;
371         *deformcos = deformedVerts;
372
373         return numleft;
374 }
375
376 int sculpt_get_first_deform_matrices(Scene *scene, Object *ob, float (**deformmats)[3][3], float (**deformcos)[3])
377 {
378         ModifierData *md;
379         DerivedMesh *dm;
380         int a, numVerts = 0;
381         float (*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
382         MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
383         int has_multires = mmd != NULL && mmd->sculptlvl > 0;
384         int numleft = 0;
385
386         if (has_multires) {
387                 *deformmats = NULL;
388                 *deformcos = NULL;
389                 return numleft;
390         }
391
392         dm = NULL;
393         md = modifiers_getVirtualModifierList(ob);
394
395         for (; md; md = md->next) {
396                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
397
398                 if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
399
400                 if (mti->type == eModifierTypeType_OnlyDeform) {
401                         if (!defmats) {
402                                 Mesh *me = (Mesh *)ob->data;
403                                 dm = mesh_create_derived(me, ob, NULL);
404                                 deformedVerts = mesh_getVertexCos(me, &numVerts);
405                                 defmats = MEM_callocN(sizeof(*defmats) * numVerts, "defmats");
406
407                                 for (a = 0; a < numVerts; a++)
408                                         unit_m3(defmats[a]);
409                         }
410
411                         if (mti->deformMatrices) mti->deformMatrices(md, ob, dm, deformedVerts, defmats, numVerts);
412                         else break;
413                 }
414         }
415
416         for (; md; md = md->next) {
417                 ModifierTypeInfo *mti = modifierType_getInfo(md->type);
418
419                 if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
420
421                 if (mti->type == eModifierTypeType_OnlyDeform)
422                         numleft++;
423         }
424
425         if (dm)
426                 dm->release(dm);
427
428         *deformmats = defmats;
429         *deformcos = deformedVerts;
430
431         return numleft;
432 }
433
434 void crazyspace_build_sculpt(Scene *scene, Object *ob, float (**deformmats)[3][3], float (**deformcos)[3])
435 {
436         int totleft = sculpt_get_first_deform_matrices(scene, ob, deformmats, deformcos);
437
438         if (totleft) {
439                 /* there are deformation modifier which doesn't support deformation matrices
440                  * calculation. Need additional crazyspace correction */
441
442                 float (*deformedVerts)[3] = *deformcos;
443                 float (*origVerts)[3] = MEM_dupallocN(deformedVerts);
444                 float *quats = NULL;
445                 int i, deformed = 0;
446                 ModifierData *md = modifiers_getVirtualModifierList(ob);
447                 Mesh *me = (Mesh *)ob->data;
448
449                 for (; md; md = md->next) {
450                         ModifierTypeInfo *mti = modifierType_getInfo(md->type);
451
452                         if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
453
454                         if (mti->type == eModifierTypeType_OnlyDeform) {
455                                 /* skip leading modifiers which have been already
456                                  * handled in sculpt_get_first_deform_matrices */
457                                 if (mti->deformMatrices && !deformed)
458                                         continue;
459
460                                 mti->deformVerts(md, ob, NULL, deformedVerts, me->totvert, 0, 0);
461                                 deformed = 1;
462                         }
463                 }
464
465                 quats = MEM_mallocN(me->totvert * sizeof(float) * 4, "crazy quats");
466
467                 crazyspace_set_quats_mesh(me, (float *)origVerts, (float *)deformedVerts, quats);
468
469                 for (i = 0; i < me->totvert; i++) {
470                         float qmat[3][3], tmat[3][3];
471
472                         quat_to_mat3(qmat, &quats[i * 4]);
473                         mul_m3_m3m3(tmat, qmat, (*deformmats)[i]);
474                         copy_m3_m3((*deformmats)[i], tmat);
475                 }
476
477                 MEM_freeN(origVerts);
478                 MEM_freeN(quats);
479         }
480
481         if (!*deformmats) {
482                 int a, numVerts;
483                 Mesh *me = (Mesh *)ob->data;
484
485                 *deformcos = mesh_getVertexCos(me, &numVerts);
486                 *deformmats = MEM_callocN(sizeof(*(*deformmats)) * numVerts, "defmats");
487
488                 for (a = 0; a < numVerts; a++)
489                         unit_m3((*deformmats)[a]);
490         }
491 }