source/blender/blenkernel/intern/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/blenkernel/intern/crazyspace.c
  29  *  \ingroup bke
  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_crazyspace.h"
  45 #include "BKE_DerivedMesh.h"
  46 #include "BKE_modifier.h"
  47 #include "BKE_multires.h"
  48 #include "BKE_mesh.h"
  49 #include "BKE_editmesh.h"
  50
  51 BLI_INLINE void tan_calc_quat_v3(
  52         float r_quat[4],
  53         const float co_1[3], const float co_2[3], const float co_3[3])
  54 {
  55         float vec_u[3], vec_v[3];
  56         float nor[3];
  57
  58         sub_v3_v3v3(vec_u, co_1, co_2);
  59         sub_v3_v3v3(vec_v, co_1, co_3);
  60
  61         cross_v3_v3v3(nor, vec_u, vec_v);
  62
  63         if (normalize_v3(nor) > FLT_EPSILON) {
  64                 const float zero_vec[3] = {0.0f};
  65                 tri_to_quat_ex(r_quat, zero_vec, vec_u, vec_v, nor);
  66         }
  67         else {
  68                 unit_qt(r_quat);
  69         }
  70 }
  71
  72 static void set_crazy_vertex_quat(
  73         float r_quat[4],
  74         const float co_1[3], const float co_2[3], const float co_3[3],
  75         const float vd_1[3], const float vd_2[3], const float vd_3[3])
  76 {
  77         float q1[4], q2[4];
  78
  79         tan_calc_quat_v3(q1, co_1, co_2, co_3);
  80         tan_calc_quat_v3(q2, vd_1, vd_2, vd_3);
  81
  82         sub_qt_qtqt(r_quat, q2, q1);
  83 }
  84
  85 static int modifiers_disable_subsurf_temporary(Object *ob)
  86 {
  87         ModifierData *md;
  88         int disabled = 0;
  89
  90         for (md = ob->modifiers.first; md; md = md->next)
  91                 if (md->type == eModifierType_Subsurf)
  92                         if (md->mode & eModifierMode_OnCage) {
  93                                 md->mode ^= eModifierMode_DisableTemporary;
  94                                 disabled = 1;
  95                         }
  96
  97         return disabled;
  98 }
  99
 100 /* disable subsurf temporal, get mapped cos, and enable it */
 101 float (*BKE_crazyspace_get_mapped_editverts(Scene *scene, Object *obedit))[3]
 102 {
 103         Mesh *me = obedit->data;
 104         DerivedMesh *dm;
 105         float (*vertexcos)[3];
 106         int nverts = me->edit_btmesh->bm->totvert;
 107
 108         /* disable subsurf temporal, get mapped cos, and enable it */
 109         if (modifiers_disable_subsurf_temporary(obedit)) {
 110                 /* need to make new derivemesh */
 111                 makeDerivedMesh(scene, obedit, me->edit_btmesh, CD_MASK_BAREMESH, 0);
 112         }
 113
 114         /* now get the cage */
 115         vertexcos = MEM_mallocN(sizeof(*vertexcos) * nverts, "vertexcos map");
 116
 117         dm = editbmesh_get_derived_cage(scene, obedit, me->edit_btmesh, CD_MASK_BAREMESH);
 118
 119         mesh_get_mapped_verts_coords(dm, vertexcos, nverts);
 120
 121         dm->release(dm);
 122
 123         /* set back the flag, no new cage needs to be built, transform does it */
 124         modifiers_disable_subsurf_temporary(obedit);
 125
 126         return vertexcos;
 127 }
 128
 129 void BKE_crazyspace_set_quats_editmesh(BMEditMesh *em, float (*origcos)[3], float (*mappedcos)[3], float (*quats)[4],
 130                                    const bool use_select)
 131 {
 132         BMFace *f;
 133         BMIter iter;
 134         int index;
 135
 136         {
 137                 BMVert *v;
 138                 BM_ITER_MESH_INDEX (v, &iter, em->bm, BM_VERTS_OF_MESH, index) {
 139                         BM_elem_flag_disable(v, BM_ELEM_TAG);
 140                         BM_elem_index_set(v, index);  /* set_inline */
 141                 }
 142                 em->bm->elem_index_dirty &= ~BM_VERT;
 143         }
 144
 145         BM_ITER_MESH (f, &iter, em->bm, BM_FACES_OF_MESH) {
 146                 BMLoop *l_iter, *l_first;
 147
 148                 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
 149                 do {
 150                         if (BM_elem_flag_test(l_iter->v, BM_ELEM_HIDDEN) ||
 151                             BM_elem_flag_test(l_iter->v, BM_ELEM_TAG) ||
 152                             (use_select && !BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)))
 153                         {
 154                                 continue;
 155                         }
 156
 157                         if (!BM_elem_flag_test(l_iter->v, BM_ELEM_TAG)) {
 158                                 const float *co_prev, *co_curr, *co_next;  /* orig */
 159                                 const float *vd_prev, *vd_curr, *vd_next;  /* deform */
 160
 161                                 const int i_prev = BM_elem_index_get(l_iter->prev->v);
 162                                 const int i_curr = BM_elem_index_get(l_iter->v);
 163                                 const int i_next = BM_elem_index_get(l_iter->next->v);
 164
 165                                 /* retrieve mapped coordinates */
 166                                 vd_prev = mappedcos[i_prev];
 167                                 vd_curr = mappedcos[i_curr];
 168                                 vd_next = mappedcos[i_next];
 169
 170                                 if (origcos) {
 171                                         co_prev = origcos[i_prev];
 172                                         co_curr = origcos[i_curr];
 173                                         co_next = origcos[i_next];
 174                                 }
 175                                 else {
 176                                         co_prev = l_iter->prev->v->co;
 177                                         co_curr = l_iter->v->co;
 178                                         co_next = l_iter->next->v->co;
 179                                 }
 180
 181                                 set_crazy_vertex_quat(quats[i_curr],
 182                                                       co_curr, co_next, co_prev,
 183                                                       vd_curr, vd_next, vd_prev);
 184
 185                                 BM_elem_flag_enable(l_iter->v, BM_ELEM_TAG);
 186                         }
 187                 } while ((l_iter = l_iter->next) != l_first);
 188         }
 189 }
 190
 191 void BKE_crazyspace_set_quats_mesh(Mesh *me, float (*origcos)[3], float (*mappedcos)[3], float (*quats)[4])
 192 {
 193         int i;
 194         MVert *mvert;
 195         MLoop *mloop;
 196         MPoly *mp;
 197
 198         mvert = me->mvert;
 199         for (i = 0; i < me->totvert; i++, mvert++)
 200                 mvert->flag &= ~ME_VERT_TMP_TAG;
 201
 202         /* first store two sets of tangent vectors in vertices, we derive it just from the face-edges */
 203         mvert = me->mvert;
 204         mp = me->mpoly;
 205         mloop = me->mloop;
 206
 207         for (i = 0; i < me->totpoly; i++, mp++) {
 208                 MLoop *ml_prev, *ml_curr, *ml_next;
 209                 int j;
 210
 211                 ml_next = &mloop[mp->loopstart];
 212                 ml_curr = &ml_next[mp->totloop - 1];
 213                 ml_prev = &ml_next[mp->totloop - 2];
 214
 215                 for (j = 0; j < mp->totloop; j++) {
 216                         if ((mvert[ml_curr->v].flag & ME_VERT_TMP_TAG) == 0) {
 217                                 const float *co_prev, *co_curr, *co_next;  /* orig */
 218                                 const float *vd_prev, *vd_curr, *vd_next;  /* deform */
 219
 220                                 /* retrieve mapped coordinates */
 221                                 vd_prev = mappedcos[ml_prev->v];
 222                                 vd_curr = mappedcos[ml_curr->v];
 223                                 vd_next = mappedcos[ml_next->v];
 224
 225                                 if (origcos) {
 226                                         co_prev = origcos[ml_prev->v];
 227                                         co_curr = origcos[ml_curr->v];
 228                                         co_next = origcos[ml_next->v];
 229                                 }
 230                                 else {
 231                                         co_prev = mvert[ml_prev->v].co;
 232                                         co_curr = mvert[ml_curr->v].co;
 233                                         co_next = mvert[ml_next->v].co;
 234                                 }
 235
 236                                 set_crazy_vertex_quat(quats[ml_curr->v],
 237                                                       co_curr, co_next, co_prev,
 238                                                       vd_curr, vd_next, vd_prev);
 239
 240                                 mvert[ml_curr->v].flag |= ME_VERT_TMP_TAG;
 241                         }
 242
 243                         ml_prev = ml_curr;
 244                         ml_curr = ml_next;
 245                         ml_next++;
 246                 }
 247         }
 248 }
 249
 250 int editbmesh_get_first_deform_matrices(Scene *scene, Object *ob, BMEditMesh *em,
 251                                         float (**deformmats)[3][3], float (**deformcos)[3])
 252 {
 253         ModifierData *md;
 254         DerivedMesh *dm;
 255         int i, a, numleft = 0, numVerts = 0;
 256         int cageIndex = modifiers_getCageIndex(scene, ob, NULL, 1);
 257         float (*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
 258         VirtualModifierData virtualModifierData;
 259
 260         modifiers_clearErrors(ob);
 261
 262         dm = NULL;
 263         md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 264
 265         /* compute the deformation matrices and coordinates for the first
 266          * modifiers with on cage editing that are enabled and support computing
 267          * deform matrices */
 268         for (i = 0; md && i <= cageIndex; i++, md = md->next) {
 269                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 270
 271                 if (!editbmesh_modifier_is_enabled(scene, md, dm))
 272                         continue;
 273
 274                 if (mti->type == eModifierTypeType_OnlyDeform && mti->deformMatricesEM) {
 275                         if (!defmats) {
 276                                 dm = getEditDerivedBMesh(em, ob, NULL);
 277                                 deformedVerts = editbmesh_get_vertex_cos(em, &numVerts);
 278                                 defmats = MEM_mallocN(sizeof(*defmats) * numVerts, "defmats");
 279
 280                                 for (a = 0; a < numVerts; a++)
 281                                         unit_m3(defmats[a]);
 282                         }
 283
 284                         mti->deformMatricesEM(md, ob, em, dm, deformedVerts, defmats,
 285                                               numVerts);
 286                 }
 287                 else
 288                         break;
 289         }
 290
 291         for (; md && i <= cageIndex; md = md->next, i++)
 292                 if (editbmesh_modifier_is_enabled(scene, md, dm) && modifier_isCorrectableDeformed(md))
 293                         numleft++;
 294
 295         if (dm)
 296                 dm->release(dm);
 297
 298         *deformmats = defmats;
 299         *deformcos = deformedVerts;
 300
 301         return numleft;
 302 }
 303
 304 int BKE_sculpt_get_first_deform_matrices(Scene *scene, Object *ob, float (**deformmats)[3][3], float (**deformcos)[3])
 305 {
 306         ModifierData *md;
 307         DerivedMesh *dm;
 308         int a, numVerts = 0;
 309         float (*defmats)[3][3] = NULL, (*deformedVerts)[3] = NULL;
 310         MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
 311         const bool has_multires = mmd != NULL && mmd->sculptlvl > 0;
 312         int numleft = 0;
 313         VirtualModifierData virtualModifierData;
 314
 315         if (has_multires) {
 316                 *deformmats = NULL;
 317                 *deformcos = NULL;
 318                 return numleft;
 319         }
 320
 321         dm = NULL;
 322         md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 323
 324         for (; md; md = md->next) {
 325                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 326
 327                 if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
 328
 329                 if (mti->type == eModifierTypeType_OnlyDeform) {
 330                         if (!defmats) {
 331                                 Mesh *me = (Mesh *)ob->data;
 332                                 dm = mesh_create_derived(me, NULL);
 333                                 deformedVerts = BKE_mesh_vertexCos_get(me, &numVerts);
 334                                 defmats = MEM_callocN(sizeof(*defmats) * numVerts, "defmats");
 335
 336                                 for (a = 0; a < numVerts; a++)
 337                                         unit_m3(defmats[a]);
 338                         }
 339
 340                         if (mti->deformMatrices) mti->deformMatrices(md, ob, dm, deformedVerts, defmats, numVerts);
 341                         else break;
 342                 }
 343         }
 344
 345         for (; md; md = md->next) {
 346                 const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 347
 348                 if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
 349
 350                 if (mti->type == eModifierTypeType_OnlyDeform)
 351                         numleft++;
 352         }
 353
 354         if (dm)
 355                 dm->release(dm);
 356
 357         *deformmats = defmats;
 358         *deformcos = deformedVerts;
 359
 360         return numleft;
 361 }
 362
 363 void BKE_crazyspace_build_sculpt(Scene *scene, Object *ob, float (**deformmats)[3][3], float (**deformcos)[3])
 364 {
 365         int totleft = BKE_sculpt_get_first_deform_matrices(scene, ob, deformmats, deformcos);
 366
 367         if (totleft) {
 368                 /* there are deformation modifier which doesn't support deformation matrices
 369                  * calculation. Need additional crazyspace correction */
 370
 371                 float (*deformedVerts)[3] = *deformcos;
 372                 float (*origVerts)[3] = MEM_dupallocN(deformedVerts);
 373                 float (*quats)[4];
 374                 int i, deformed = 0;
 375                 VirtualModifierData virtualModifierData;
 376                 ModifierData *md = modifiers_getVirtualModifierList(ob, &virtualModifierData);
 377                 Mesh *me = (Mesh *)ob->data;
 378
 379                 for (; md; md = md->next) {
 380                         const ModifierTypeInfo *mti = modifierType_getInfo(md->type);
 381
 382                         if (!modifier_isEnabled(scene, md, eModifierMode_Realtime)) continue;
 383
 384                         if (mti->type == eModifierTypeType_OnlyDeform) {
 385                                 /* skip leading modifiers which have been already
 386                                  * handled in sculpt_get_first_deform_matrices */
 387                                 if (mti->deformMatrices && !deformed)
 388                                         continue;
 389
 390                                 mti->deformVerts(md, ob, NULL, deformedVerts, me->totvert, 0);
 391                                 deformed = 1;
 392                         }
 393                 }
 394
 395                 quats = MEM_mallocN(me->totvert * sizeof(*quats), "crazy quats");
 396
 397                 BKE_crazyspace_set_quats_mesh(me, origVerts, deformedVerts, quats);
 398
 399                 for (i = 0; i < me->totvert; i++) {
 400                         float qmat[3][3], tmat[3][3];
 401
 402                         quat_to_mat3(qmat, quats[i]);
 403                         mul_m3_m3m3(tmat, qmat, (*deformmats)[i]);
 404                         copy_m3_m3((*deformmats)[i], tmat);
 405                 }
 406
 407                 MEM_freeN(origVerts);
 408                 MEM_freeN(quats);
 409         }
 410
 411         if (*deformmats == NULL) {
 412                 int a, numVerts;
 413                 Mesh *me = (Mesh *)ob->data;
 414
 415                 *deformcos = BKE_mesh_vertexCos_get(me, &numVerts);
 416                 *deformmats = MEM_callocN(sizeof(*(*deformmats)) * numVerts, "defmats");
 417
 418                 for (a = 0; a < numVerts; a++)
 419                         unit_m3((*deformmats)[a]);
 420         }
 421 }