Merge branch 'blender2.7'
[blender.git] / source / blender / blenkernel / intern / mesh_runtime.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
24 #include "atomic_ops.h"
25
26 #include "MEM_guardedalloc.h"
27
28 #include "DNA_mesh_types.h"
29 #include "DNA_meshdata_types.h"
30 #include "DNA_object_types.h"
31
32 #include "BLI_math_geom.h"
33 #include "BLI_threads.h"
34
35 #include "BKE_bvhutils.h"
36 #include "BKE_mesh.h"
37 #include "BKE_mesh_runtime.h"
38 #include "BKE_subdiv_ccg.h"
39 #include "BKE_shrinkwrap.h"
40
41 /* -------------------------------------------------------------------- */
42 /** \name Mesh Runtime Struct Utils
43  * \{ */
44
45 static ThreadRWMutex loops_cache_lock = PTHREAD_RWLOCK_INITIALIZER;
46
47 /**
48  * Default values defined at read time.
49  */
50 void BKE_mesh_runtime_reset(Mesh *mesh)
51 {
52   memset(&mesh->runtime, 0, sizeof(mesh->runtime));
53 }
54
55 /* Clear all pointers which we don't want to be shared on copying the datablock.
56  * However, keep all the flags which defines what the mesh is (for example, that
57  * it's deformed only, or that its custom data layers are out of date.) */
58 void BKE_mesh_runtime_reset_on_copy(Mesh *mesh, const int UNUSED(flag))
59 {
60   Mesh_Runtime *runtime = &mesh->runtime;
61
62   runtime->edit_data = NULL;
63   runtime->batch_cache = NULL;
64   runtime->subdiv_ccg = NULL;
65   memset(&runtime->looptris, 0, sizeof(runtime->looptris));
66   runtime->bvh_cache = NULL;
67   runtime->shrinkwrap_data = NULL;
68 }
69
70 void BKE_mesh_runtime_clear_cache(Mesh *mesh)
71 {
72   BKE_mesh_runtime_clear_geometry(mesh);
73   BKE_mesh_batch_cache_free(mesh);
74   BKE_mesh_runtime_clear_edit_data(mesh);
75 }
76
77 /* This is a ported copy of DM_ensure_looptri_data(dm) */
78 /**
79  * Ensure the array is large enough
80  *
81  * \note This function must always be thread-protected by caller. It should only be used by internal code.
82  */
83 static void mesh_ensure_looptri_data(Mesh *mesh)
84 {
85   const unsigned int totpoly = mesh->totpoly;
86   const int looptris_len = poly_to_tri_count(totpoly, mesh->totloop);
87
88   BLI_assert(mesh->runtime.looptris.array_wip == NULL);
89
90   SWAP(MLoopTri *, mesh->runtime.looptris.array, mesh->runtime.looptris.array_wip);
91
92   if ((looptris_len > mesh->runtime.looptris.len_alloc) ||
93       (looptris_len < mesh->runtime.looptris.len_alloc * 2) || (totpoly == 0)) {
94     MEM_SAFE_FREE(mesh->runtime.looptris.array_wip);
95     mesh->runtime.looptris.len_alloc = 0;
96     mesh->runtime.looptris.len = 0;
97   }
98
99   if (totpoly) {
100     if (mesh->runtime.looptris.array_wip == NULL) {
101       mesh->runtime.looptris.array_wip = MEM_malloc_arrayN(
102           looptris_len, sizeof(*mesh->runtime.looptris.array_wip), __func__);
103       mesh->runtime.looptris.len_alloc = looptris_len;
104     }
105
106     mesh->runtime.looptris.len = looptris_len;
107   }
108 }
109
110 /* This is a ported copy of CDDM_recalc_looptri(dm). */
111 void BKE_mesh_runtime_looptri_recalc(Mesh *mesh)
112 {
113   mesh_ensure_looptri_data(mesh);
114   BLI_assert(mesh->totpoly == 0 || mesh->runtime.looptris.array_wip != NULL);
115
116   BKE_mesh_recalc_looptri(mesh->mloop,
117                           mesh->mpoly,
118                           mesh->mvert,
119                           mesh->totloop,
120                           mesh->totpoly,
121                           mesh->runtime.looptris.array_wip);
122
123   BLI_assert(mesh->runtime.looptris.array == NULL);
124   atomic_cas_ptr((void **)&mesh->runtime.looptris.array,
125                  mesh->runtime.looptris.array,
126                  mesh->runtime.looptris.array_wip);
127   mesh->runtime.looptris.array_wip = NULL;
128 }
129
130 /* This is a ported copy of dm_getNumLoopTri(dm). */
131 int BKE_mesh_runtime_looptri_len(const Mesh *mesh)
132 {
133   const int looptri_len = poly_to_tri_count(mesh->totpoly, mesh->totloop);
134   BLI_assert(ELEM(mesh->runtime.looptris.len, 0, looptri_len));
135   return looptri_len;
136 }
137
138 /* This is a ported copy of dm_getLoopTriArray(dm). */
139 const MLoopTri *BKE_mesh_runtime_looptri_ensure(Mesh *mesh)
140 {
141   MLoopTri *looptri;
142
143   BLI_rw_mutex_lock(&loops_cache_lock, THREAD_LOCK_READ);
144   looptri = mesh->runtime.looptris.array;
145   BLI_rw_mutex_unlock(&loops_cache_lock);
146
147   if (looptri != NULL) {
148     BLI_assert(BKE_mesh_runtime_looptri_len(mesh) == mesh->runtime.looptris.len);
149   }
150   else {
151     BLI_rw_mutex_lock(&loops_cache_lock, THREAD_LOCK_WRITE);
152     /* We need to ensure array is still NULL inside mutex-protected code, some other thread might have already
153      * recomputed those looptris. */
154     if (mesh->runtime.looptris.array == NULL) {
155       BKE_mesh_runtime_looptri_recalc(mesh);
156     }
157     looptri = mesh->runtime.looptris.array;
158     BLI_rw_mutex_unlock(&loops_cache_lock);
159   }
160   return looptri;
161 }
162
163 /* This is a copy of DM_verttri_from_looptri(). */
164 void BKE_mesh_runtime_verttri_from_looptri(MVertTri *r_verttri,
165                                            const MLoop *mloop,
166                                            const MLoopTri *looptri,
167                                            int looptri_num)
168 {
169   int i;
170   for (i = 0; i < looptri_num; i++) {
171     r_verttri[i].tri[0] = mloop[looptri[i].tri[0]].v;
172     r_verttri[i].tri[1] = mloop[looptri[i].tri[1]].v;
173     r_verttri[i].tri[2] = mloop[looptri[i].tri[2]].v;
174   }
175 }
176
177 bool BKE_mesh_runtime_ensure_edit_data(struct Mesh *mesh)
178 {
179   if (mesh->runtime.edit_data != NULL) {
180     return false;
181   }
182
183   mesh->runtime.edit_data = MEM_callocN(sizeof(EditMeshData), "EditMeshData");
184   return true;
185 }
186
187 bool BKE_mesh_runtime_clear_edit_data(Mesh *mesh)
188 {
189   if (mesh->runtime.edit_data == NULL) {
190     return false;
191   }
192
193   if (mesh->runtime.edit_data->polyCos != NULL)
194     MEM_freeN((void *)mesh->runtime.edit_data->polyCos);
195   if (mesh->runtime.edit_data->polyNos != NULL)
196     MEM_freeN((void *)mesh->runtime.edit_data->polyNos);
197   if (mesh->runtime.edit_data->vertexCos != NULL)
198     MEM_freeN((void *)mesh->runtime.edit_data->vertexCos);
199   if (mesh->runtime.edit_data->vertexNos != NULL)
200     MEM_freeN((void *)mesh->runtime.edit_data->vertexNos);
201
202   MEM_SAFE_FREE(mesh->runtime.edit_data);
203   return true;
204 }
205
206 void BKE_mesh_runtime_clear_geometry(Mesh *mesh)
207 {
208   bvhcache_free(&mesh->runtime.bvh_cache);
209   MEM_SAFE_FREE(mesh->runtime.looptris.array);
210   /* TODO(sergey): Does this really belong here? */
211   if (mesh->runtime.subdiv_ccg != NULL) {
212     BKE_subdiv_ccg_destroy(mesh->runtime.subdiv_ccg);
213     mesh->runtime.subdiv_ccg = NULL;
214   }
215   BKE_shrinkwrap_discard_boundary_data(mesh);
216 }
217
218 /** \} */
219
220 /* -------------------------------------------------------------------- */
221 /** \name Mesh Batch Cache Callbacks
222  * \{ */
223
224 /* Draw Engine */
225 void (*BKE_mesh_batch_cache_dirty_tag_cb)(Mesh *me, int mode) = NULL;
226 void (*BKE_mesh_batch_cache_free_cb)(Mesh *me) = NULL;
227
228 void BKE_mesh_batch_cache_dirty_tag(Mesh *me, int mode)
229 {
230   if (me->runtime.batch_cache) {
231     BKE_mesh_batch_cache_dirty_tag_cb(me, mode);
232   }
233 }
234 void BKE_mesh_batch_cache_free(Mesh *me)
235 {
236   if (me->runtime.batch_cache) {
237     BKE_mesh_batch_cache_free_cb(me);
238   }
239 }
240
241 /** \} */
242
243 /** \name Mesh runtime debug helpers.
244  * \{ */
245 /* evaluated mesh info printing function,
246  * to help track down differences output */
247
248 #ifndef NDEBUG
249 #  include "BLI_dynstr.h"
250
251 static void mesh_runtime_debug_info_layers(DynStr *dynstr, CustomData *cd)
252 {
253   int type;
254
255   for (type = 0; type < CD_NUMTYPES; type++) {
256     if (CustomData_has_layer(cd, type)) {
257       /* note: doesn't account for multiple layers */
258       const char *name = CustomData_layertype_name(type);
259       const int size = CustomData_sizeof(type);
260       const void *pt = CustomData_get_layer(cd, type);
261       const int pt_size = pt ? (int)(MEM_allocN_len(pt) / size) : 0;
262       const char *structname;
263       int structnum;
264       CustomData_file_write_info(type, &structname, &structnum);
265       BLI_dynstr_appendf(
266           dynstr,
267           "        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
268           name,
269           structname,
270           type,
271           (const void *)pt,
272           size,
273           pt_size);
274     }
275   }
276 }
277
278 char *BKE_mesh_runtime_debug_info(Mesh *me_eval)
279 {
280   DynStr *dynstr = BLI_dynstr_new();
281   char *ret;
282
283   BLI_dynstr_append(dynstr, "{\n");
284   BLI_dynstr_appendf(dynstr, "    'ptr': '%p',\n", (void *)me_eval);
285 #  if 0
286   const char *tstr;
287   switch (me_eval->type) {
288     case DM_TYPE_CDDM:
289       tstr = "DM_TYPE_CDDM";
290       break;
291     case DM_TYPE_CCGDM:
292       tstr = "DM_TYPE_CCGDM";
293       break;
294     default:
295       tstr = "UNKNOWN";
296       break;
297   }
298   BLI_dynstr_appendf(dynstr, "    'type': '%s',\n", tstr);
299 #  endif
300   BLI_dynstr_appendf(dynstr, "    'totvert': %d,\n", me_eval->totvert);
301   BLI_dynstr_appendf(dynstr, "    'totedge': %d,\n", me_eval->totedge);
302   BLI_dynstr_appendf(dynstr, "    'totface': %d,\n", me_eval->totface);
303   BLI_dynstr_appendf(dynstr, "    'totpoly': %d,\n", me_eval->totpoly);
304   BLI_dynstr_appendf(dynstr, "    'deformed_only': %d,\n", me_eval->runtime.deformed_only);
305
306   BLI_dynstr_append(dynstr, "    'vertexLayers': (\n");
307   mesh_runtime_debug_info_layers(dynstr, &me_eval->vdata);
308   BLI_dynstr_append(dynstr, "    ),\n");
309
310   BLI_dynstr_append(dynstr, "    'edgeLayers': (\n");
311   mesh_runtime_debug_info_layers(dynstr, &me_eval->edata);
312   BLI_dynstr_append(dynstr, "    ),\n");
313
314   BLI_dynstr_append(dynstr, "    'loopLayers': (\n");
315   mesh_runtime_debug_info_layers(dynstr, &me_eval->ldata);
316   BLI_dynstr_append(dynstr, "    ),\n");
317
318   BLI_dynstr_append(dynstr, "    'polyLayers': (\n");
319   mesh_runtime_debug_info_layers(dynstr, &me_eval->pdata);
320   BLI_dynstr_append(dynstr, "    ),\n");
321
322   BLI_dynstr_append(dynstr, "    'tessFaceLayers': (\n");
323   mesh_runtime_debug_info_layers(dynstr, &me_eval->fdata);
324   BLI_dynstr_append(dynstr, "    ),\n");
325
326   BLI_dynstr_append(dynstr, "}\n");
327
328   ret = BLI_dynstr_get_cstring(dynstr);
329   BLI_dynstr_free(dynstr);
330   return ret;
331 }
332
333 void BKE_mesh_runtime_debug_print(Mesh *me_eval)
334 {
335   char *str = BKE_mesh_runtime_debug_info(me_eval);
336   puts(str);
337   fflush(stdout);
338   MEM_freeN(str);
339 }
340
341 /* XXX Should go in customdata file? */
342 void BKE_mesh_runtime_debug_print_cdlayers(CustomData *data)
343 {
344   int i;
345   const CustomDataLayer *layer;
346
347   printf("{\n");
348
349   for (i = 0, layer = data->layers; i < data->totlayer; i++, layer++) {
350
351     const char *name = CustomData_layertype_name(layer->type);
352     const int size = CustomData_sizeof(layer->type);
353     const char *structname;
354     int structnum;
355     CustomData_file_write_info(layer->type, &structname, &structnum);
356     printf("        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
357            name,
358            structname,
359            layer->type,
360            (const void *)layer->data,
361            size,
362            (int)(MEM_allocN_len(layer->data) / size));
363   }
364
365   printf("}\n");
366 }
367
368 bool BKE_mesh_runtime_is_valid(Mesh *me_eval)
369 {
370   const bool do_verbose = true;
371   const bool do_fixes = false;
372
373   bool is_valid = true;
374   bool changed = true;
375
376   if (do_verbose) {
377     printf("MESH: %s\n", me_eval->id.name + 2);
378   }
379
380   is_valid &= BKE_mesh_validate_all_customdata(
381       &me_eval->vdata,
382       me_eval->totvert,
383       &me_eval->edata,
384       me_eval->totedge,
385       &me_eval->ldata,
386       me_eval->totloop,
387       &me_eval->pdata,
388       me_eval->totpoly,
389       false, /* setting mask here isn't useful, gives false positives */
390       do_verbose,
391       do_fixes,
392       &changed);
393
394   is_valid &= BKE_mesh_validate_arrays(me_eval,
395                                        me_eval->mvert,
396                                        me_eval->totvert,
397                                        me_eval->medge,
398                                        me_eval->totedge,
399                                        me_eval->mface,
400                                        me_eval->totface,
401                                        me_eval->mloop,
402                                        me_eval->totloop,
403                                        me_eval->mpoly,
404                                        me_eval->totpoly,
405                                        me_eval->dvert,
406                                        do_verbose,
407                                        do_fixes,
408                                        &changed);
409
410   BLI_assert(changed == false);
411
412   return is_valid;
413 }
414
415 #endif /* NDEBUG */
416
417 /** \} */