Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / editderivedmesh.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 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  *
23  * basic design:
24  *
25  * the bmesh derivedmesh exposes the mesh as triangles.  it stores pointers
26  * to three loops per triangle.  the derivedmesh stores a cache of tessellations
27  * for each face.  this cache will smartly update as needed (though at first
28  * it'll simply be more brute force).  keeping track of face/edge counts may
29  * be a small problem.
30  *
31  * this won't be the most efficient thing, considering that internal edges and
32  * faces of tessellations are exposed.  looking up an edge by index in particular
33  * is likely to be a little slow.
34  */
35
36 #include "atomic_ops.h"
37
38 #include "BLI_math.h"
39 #include "BLI_jitter_2d.h"
40 #include "BLI_bitmap.h"
41 #include "BLI_task.h"
42
43 #include "BKE_cdderivedmesh.h"
44 #include "BKE_deform.h"
45 #include "BKE_mesh.h"
46 #include "BKE_mesh_iterators.h"
47 #include "BKE_editmesh.h"
48 #include "BKE_editmesh_bvh.h"
49 #include "BKE_editmesh_cache.h"
50 #include "BKE_editmesh_tangent.h"
51
52 #include "DNA_scene_types.h"
53 #include "DNA_object_types.h"
54 #include "DNA_mesh_types.h"
55
56 #include "MEM_guardedalloc.h"
57
58 /* -------------------------------------------------------------------- */
59 /* StatVis Functions */
60
61 static void axis_from_enum_v3(float v[3], const char axis)
62 {
63   zero_v3(v);
64   if (axis < 3) {
65     v[axis] = 1.0f;
66   }
67   else {
68     v[axis - 3] = -1.0f;
69   }
70 }
71
72 static void statvis_calc_overhang(BMEditMesh *em,
73                                   const float (*polyNos)[3],
74                                   /* values for calculating */
75                                   const float min,
76                                   const float max,
77                                   const char axis,
78                                   /* result */
79                                   unsigned char (*r_face_colors)[4])
80 {
81   BMIter iter;
82   BMesh *bm = em->bm;
83   BMFace *f;
84   float dir[3];
85   int index;
86   const float minmax_irange = 1.0f / (max - min);
87   bool is_max;
88
89   /* fallback */
90   unsigned char col_fallback[4] = {64, 64, 64, 255};  /* gray */
91   unsigned char col_fallback_max[4] = {0, 0, 0, 255}; /* max color */
92
93   BLI_assert(min <= max);
94
95   axis_from_enum_v3(dir, axis);
96
97   if (LIKELY(em->ob)) {
98     mul_transposed_mat3_m4_v3(em->ob->obmat, dir);
99     normalize_v3(dir);
100   }
101
102   /* fallback max */
103   {
104     float fcol[3];
105     BKE_defvert_weight_to_rgb(fcol, 1.0f);
106     rgb_float_to_uchar(col_fallback_max, fcol);
107   }
108
109   /* now convert into global space */
110   BM_ITER_MESH_INDEX (f, &iter, bm, BM_FACES_OF_MESH, index) {
111     float fac = angle_normalized_v3v3(polyNos ? polyNos[index] : f->no, dir) / (float)M_PI;
112
113     /* remap */
114     if ((is_max = (fac <= max)) && (fac >= min)) {
115       float fcol[3];
116       fac = (fac - min) * minmax_irange;
117       fac = 1.0f - fac;
118       CLAMP(fac, 0.0f, 1.0f);
119       BKE_defvert_weight_to_rgb(fcol, fac);
120       rgb_float_to_uchar(r_face_colors[index], fcol);
121     }
122     else {
123       const unsigned char *fallback = is_max ? col_fallback_max : col_fallback;
124       copy_v4_v4_uchar(r_face_colors[index], fallback);
125     }
126   }
127 }
128
129 /* so we can use jitter values for face interpolation */
130 static void uv_from_jitter_v2(float uv[2])
131 {
132   uv[0] += 0.5f;
133   uv[1] += 0.5f;
134   if (uv[0] + uv[1] > 1.0f) {
135     uv[0] = 1.0f - uv[0];
136     uv[1] = 1.0f - uv[1];
137   }
138
139   CLAMP(uv[0], 0.0f, 1.0f);
140   CLAMP(uv[1], 0.0f, 1.0f);
141 }
142
143 static void statvis_calc_thickness(BMEditMesh *em,
144                                    const float (*vertexCos)[3],
145                                    /* values for calculating */
146                                    const float min,
147                                    const float max,
148                                    const int samples,
149                                    /* result */
150                                    unsigned char (*r_face_colors)[4])
151 {
152   const float eps_offset = 0.00002f;          /* values <= 0.00001 give errors */
153   float *face_dists = (float *)r_face_colors; /* cheating */
154   const bool use_jit = samples < 32;
155   float jit_ofs[32][2];
156   BMesh *bm = em->bm;
157   const int tottri = em->tottri;
158   const float minmax_irange = 1.0f / (max - min);
159   int i;
160
161   struct BMLoop *(*looptris)[3] = em->looptris;
162
163   /* fallback */
164   const unsigned char col_fallback[4] = {64, 64, 64, 255};
165
166   struct BMBVHTree *bmtree;
167
168   BLI_assert(min <= max);
169
170   copy_vn_fl(face_dists, em->bm->totface, max);
171
172   if (use_jit) {
173     int j;
174     BLI_assert(samples < 32);
175     BLI_jitter_init(jit_ofs, samples);
176
177     for (j = 0; j < samples; j++) {
178       uv_from_jitter_v2(jit_ofs[j]);
179     }
180   }
181
182   BM_mesh_elem_index_ensure(bm, BM_FACE);
183   if (vertexCos) {
184     BM_mesh_elem_index_ensure(bm, BM_VERT);
185   }
186
187   bmtree = BKE_bmbvh_new_from_editmesh(em, 0, vertexCos, false);
188
189   for (i = 0; i < tottri; i++) {
190     BMFace *f_hit;
191     BMLoop **ltri = looptris[i];
192     const int index = BM_elem_index_get(ltri[0]->f);
193     const float *cos[3];
194     float ray_co[3];
195     float ray_no[3];
196
197     if (vertexCos) {
198       cos[0] = vertexCos[BM_elem_index_get(ltri[0]->v)];
199       cos[1] = vertexCos[BM_elem_index_get(ltri[1]->v)];
200       cos[2] = vertexCos[BM_elem_index_get(ltri[2]->v)];
201     }
202     else {
203       cos[0] = ltri[0]->v->co;
204       cos[1] = ltri[1]->v->co;
205       cos[2] = ltri[2]->v->co;
206     }
207
208     normal_tri_v3(ray_no, cos[2], cos[1], cos[0]);
209
210 #define FACE_RAY_TEST_ANGLE \
211   f_hit = BKE_bmbvh_ray_cast(bmtree, ray_co, ray_no, 0.0f, &dist, NULL, NULL); \
212   if (f_hit && dist < face_dists[index]) { \
213     float angle_fac = fabsf(dot_v3v3(ltri[0]->f->no, f_hit->no)); \
214     angle_fac = 1.0f - angle_fac; \
215     angle_fac = angle_fac * angle_fac * angle_fac; \
216     angle_fac = 1.0f - angle_fac; \
217     dist /= angle_fac; \
218     if (dist < face_dists[index]) { \
219       face_dists[index] = dist; \
220     } \
221   } \
222   (void)0
223
224     if (use_jit) {
225       int j;
226       for (j = 0; j < samples; j++) {
227         float dist = face_dists[index];
228         interp_v3_v3v3v3_uv(ray_co, cos[0], cos[1], cos[2], jit_ofs[j]);
229         madd_v3_v3fl(ray_co, ray_no, eps_offset);
230
231         FACE_RAY_TEST_ANGLE;
232       }
233     }
234     else {
235       float dist = face_dists[index];
236       mid_v3_v3v3v3(ray_co, cos[0], cos[1], cos[2]);
237       madd_v3_v3fl(ray_co, ray_no, eps_offset);
238
239       FACE_RAY_TEST_ANGLE;
240     }
241   }
242
243   BKE_bmbvh_free(bmtree);
244
245   /* convert floats into color! */
246   for (i = 0; i < bm->totface; i++) {
247     float fac = face_dists[i];
248
249     /* important not '<=' */
250     if (fac < max) {
251       float fcol[3];
252       fac = (fac - min) * minmax_irange;
253       fac = 1.0f - fac;
254       CLAMP(fac, 0.0f, 1.0f);
255       BKE_defvert_weight_to_rgb(fcol, fac);
256       rgb_float_to_uchar(r_face_colors[i], fcol);
257     }
258     else {
259       copy_v4_v4_uchar(r_face_colors[i], col_fallback);
260     }
261   }
262 }
263
264 static void statvis_calc_intersect(BMEditMesh *em,
265                                    const float (*vertexCos)[3],
266                                    /* result */
267                                    unsigned char (*r_face_colors)[4])
268 {
269   BMesh *bm = em->bm;
270   int i;
271
272   /* fallback */
273   // const char col_fallback[4] = {64, 64, 64, 255};
274   float fcol[3];
275   unsigned char col[3];
276
277   struct BMBVHTree *bmtree;
278   BVHTreeOverlap *overlap;
279   unsigned int overlap_len;
280
281   memset(r_face_colors, 64, sizeof(int) * em->bm->totface);
282
283   BM_mesh_elem_index_ensure(bm, BM_FACE);
284   if (vertexCos) {
285     BM_mesh_elem_index_ensure(bm, BM_VERT);
286   }
287
288   bmtree = BKE_bmbvh_new_from_editmesh(em, 0, vertexCos, false);
289
290   overlap = BKE_bmbvh_overlap(bmtree, bmtree, &overlap_len);
291
292   /* same for all faces */
293   BKE_defvert_weight_to_rgb(fcol, 1.0f);
294   rgb_float_to_uchar(col, fcol);
295
296   if (overlap) {
297     for (i = 0; i < overlap_len; i++) {
298       BMFace *f_hit_pair[2] = {
299           em->looptris[overlap[i].indexA][0]->f,
300           em->looptris[overlap[i].indexB][0]->f,
301       };
302       int j;
303
304       for (j = 0; j < 2; j++) {
305         BMFace *f_hit = f_hit_pair[j];
306         int index;
307
308         index = BM_elem_index_get(f_hit);
309
310         copy_v3_v3_uchar(r_face_colors[index], col);
311       }
312     }
313     MEM_freeN(overlap);
314   }
315
316   BKE_bmbvh_free(bmtree);
317 }
318
319 static void statvis_calc_distort(BMEditMesh *em,
320                                  const float (*vertexCos)[3],
321                                  const float (*polyNos)[3],
322                                  /* values for calculating */
323                                  const float min,
324                                  const float max,
325                                  /* result */
326                                  unsigned char (*r_face_colors)[4])
327 {
328   BMIter iter;
329   BMesh *bm = em->bm;
330   BMFace *f;
331   const float *f_no;
332   int index;
333   const float minmax_irange = 1.0f / (max - min);
334
335   /* fallback */
336   const unsigned char col_fallback[4] = {64, 64, 64, 255};
337
338   /* now convert into global space */
339   BM_ITER_MESH_INDEX (f, &iter, bm, BM_FACES_OF_MESH, index) {
340     float fac;
341
342     if (f->len == 3) {
343       fac = -1.0f;
344     }
345     else {
346       BMLoop *l_iter, *l_first;
347       if (vertexCos) {
348         f_no = polyNos[index];
349       }
350       else {
351         f_no = f->no;
352       }
353
354       fac = 0.0f;
355       l_iter = l_first = BM_FACE_FIRST_LOOP(f);
356       do {
357         float no_corner[3];
358         if (vertexCos) {
359           normal_tri_v3(no_corner,
360                         vertexCos[BM_elem_index_get(l_iter->prev->v)],
361                         vertexCos[BM_elem_index_get(l_iter->v)],
362                         vertexCos[BM_elem_index_get(l_iter->next->v)]);
363         }
364         else {
365           BM_loop_calc_face_normal_safe(l_iter, no_corner);
366         }
367         /* simple way to detect (what is most likely) concave */
368         if (dot_v3v3(f_no, no_corner) < 0.0f) {
369           negate_v3(no_corner);
370         }
371         fac = max_ff(fac, angle_normalized_v3v3(f_no, no_corner));
372       } while ((l_iter = l_iter->next) != l_first);
373       fac *= 2.0f;
374     }
375
376     /* remap */
377     if (fac >= min) {
378       float fcol[3];
379       fac = (fac - min) * minmax_irange;
380       CLAMP(fac, 0.0f, 1.0f);
381       BKE_defvert_weight_to_rgb(fcol, fac);
382       rgb_float_to_uchar(r_face_colors[index], fcol);
383     }
384     else {
385       copy_v4_v4_uchar(r_face_colors[index], col_fallback);
386     }
387   }
388 }
389
390 static void statvis_calc_sharp(BMEditMesh *em,
391                                const float (*vertexCos)[3],
392                                /* values for calculating */
393                                const float min,
394                                const float max,
395                                /* result */
396                                unsigned char (*r_vert_colors)[4])
397 {
398   float *vert_angles = (float *)r_vert_colors; /* cheating */
399   BMIter iter;
400   BMesh *bm = em->bm;
401   BMEdge *e;
402   //float f_no[3];
403   const float minmax_irange = 1.0f / (max - min);
404   int i;
405
406   /* fallback */
407   const unsigned char col_fallback[4] = {64, 64, 64, 255};
408
409   (void)vertexCos; /* TODO */
410
411   copy_vn_fl(vert_angles, em->bm->totvert, -M_PI);
412
413   /* first assign float values to verts */
414   BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
415     float angle = BM_edge_calc_face_angle_signed(e);
416     float *col1 = &vert_angles[BM_elem_index_get(e->v1)];
417     float *col2 = &vert_angles[BM_elem_index_get(e->v2)];
418     *col1 = max_ff(*col1, angle);
419     *col2 = max_ff(*col2, angle);
420   }
421
422   /* convert floats into color! */
423   for (i = 0; i < bm->totvert; i++) {
424     float fac = vert_angles[i];
425
426     /* important not '<=' */
427     if (fac > min) {
428       float fcol[3];
429       fac = (fac - min) * minmax_irange;
430       CLAMP(fac, 0.0f, 1.0f);
431       BKE_defvert_weight_to_rgb(fcol, fac);
432       rgb_float_to_uchar(r_vert_colors[i], fcol);
433     }
434     else {
435       copy_v4_v4_uchar(r_vert_colors[i], col_fallback);
436     }
437   }
438 }
439
440 void BKE_editmesh_statvis_calc(BMEditMesh *em, EditMeshData *emd, const MeshStatVis *statvis)
441 {
442   switch (statvis->type) {
443     case SCE_STATVIS_OVERHANG: {
444       BKE_editmesh_color_ensure(em, BM_FACE);
445       statvis_calc_overhang(em,
446                             emd ? emd->polyNos : NULL,
447                             statvis->overhang_min / (float)M_PI,
448                             statvis->overhang_max / (float)M_PI,
449                             statvis->overhang_axis,
450                             em->derivedFaceColor);
451       break;
452     }
453     case SCE_STATVIS_THICKNESS: {
454       const float scale = 1.0f / mat4_to_scale(em->ob->obmat);
455       BKE_editmesh_color_ensure(em, BM_FACE);
456       statvis_calc_thickness(em,
457                              emd ? emd->vertexCos : NULL,
458                              statvis->thickness_min * scale,
459                              statvis->thickness_max * scale,
460                              statvis->thickness_samples,
461                              em->derivedFaceColor);
462       break;
463     }
464     case SCE_STATVIS_INTERSECT: {
465       BKE_editmesh_color_ensure(em, BM_FACE);
466       statvis_calc_intersect(em, emd ? emd->vertexCos : NULL, em->derivedFaceColor);
467       break;
468     }
469     case SCE_STATVIS_DISTORT: {
470       BKE_editmesh_color_ensure(em, BM_FACE);
471
472       if (emd) {
473         BKE_editmesh_cache_ensure_poly_normals(em, emd);
474       }
475
476       statvis_calc_distort(em,
477                            emd ? emd->vertexCos : NULL,
478                            emd ? emd->polyNos : NULL,
479                            statvis->distort_min,
480                            statvis->distort_max,
481                            em->derivedFaceColor);
482       break;
483     }
484     case SCE_STATVIS_SHARP: {
485       BKE_editmesh_color_ensure(em, BM_VERT);
486       statvis_calc_sharp(em,
487                          emd ? emd->vertexCos : NULL,
488                          statvis->sharp_min,
489                          statvis->sharp_max,
490                          /* in this case they are vertex colors */
491                          em->derivedVertColor);
492       break;
493     }
494   }
495 }
496
497 /* -------------------------------------------------------------------- */
498 /* Editmesh Vert Coords */
499
500 struct CageUserData {
501   int totvert;
502   float (*cos_cage)[3];
503   BLI_bitmap *visit_bitmap;
504 };
505
506 static void cage_mapped_verts_callback(void *userData,
507                                        int index,
508                                        const float co[3],
509                                        const float UNUSED(no_f[3]),
510                                        const short UNUSED(no_s[3]))
511 {
512   struct CageUserData *data = userData;
513
514   if ((index >= 0 && index < data->totvert) && (!BLI_BITMAP_TEST(data->visit_bitmap, index))) {
515     BLI_BITMAP_ENABLE(data->visit_bitmap, index);
516     copy_v3_v3(data->cos_cage[index], co);
517   }
518 }
519
520 float (*BKE_editmesh_vertexCos_get(
521     struct Depsgraph *depsgraph, BMEditMesh *em, Scene *scene, int *r_numVerts))[3]
522 {
523   Mesh *cage;
524   BLI_bitmap *visit_bitmap;
525   struct CageUserData data;
526   float(*cos_cage)[3];
527
528   cage = editbmesh_get_eval_cage(depsgraph, scene, em->ob, em, &CD_MASK_BAREMESH);
529   cos_cage = MEM_callocN(sizeof(*cos_cage) * em->bm->totvert, "bmbvh cos_cage");
530
531   /* when initializing cage verts, we only want the first cage coordinate for each vertex,
532    * so that e.g. mirror or array use original vertex coordinates and not mirrored or duplicate */
533   visit_bitmap = BLI_BITMAP_NEW(em->bm->totvert, __func__);
534
535   data.totvert = em->bm->totvert;
536   data.cos_cage = cos_cage;
537   data.visit_bitmap = visit_bitmap;
538
539   BKE_mesh_foreach_mapped_vert(cage, cage_mapped_verts_callback, &data, MESH_FOREACH_NOP);
540
541   MEM_freeN(visit_bitmap);
542
543   if (r_numVerts) {
544     *r_numVerts = em->bm->totvert;
545   }
546
547   return cos_cage;
548 }