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) ||
94             (totpoly == 0))
95         {
96                 MEM_SAFE_FREE(mesh->runtime.looptris.array_wip);
97                 mesh->runtime.looptris.len_alloc = 0;
98                 mesh->runtime.looptris.len = 0;
99         }
100
101         if (totpoly) {
102                 if (mesh->runtime.looptris.array_wip == NULL) {
103                         mesh->runtime.looptris.array_wip = MEM_malloc_arrayN(looptris_len, sizeof(*mesh->runtime.looptris.array_wip), __func__);
104                         mesh->runtime.looptris.len_alloc = looptris_len;
105                 }
106
107                 mesh->runtime.looptris.len = looptris_len;
108         }
109 }
110
111 /* This is a ported copy of CDDM_recalc_looptri(dm). */
112 void BKE_mesh_runtime_looptri_recalc(Mesh *mesh)
113 {
114         mesh_ensure_looptri_data(mesh);
115         BLI_assert(mesh->totpoly == 0 || mesh->runtime.looptris.array_wip != NULL);
116
117         BKE_mesh_recalc_looptri(
118                 mesh->mloop, mesh->mpoly,
119                 mesh->mvert,
120                 mesh->totloop, 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, mesh->runtime.looptris.array, mesh->runtime.looptris.array_wip);
125         mesh->runtime.looptris.array_wip = NULL;
126 }
127
128 /* This is a ported copy of dm_getNumLoopTri(dm). */
129 int BKE_mesh_runtime_looptri_len(const Mesh *mesh)
130 {
131         const int looptri_len = poly_to_tri_count(mesh->totpoly, mesh->totloop);
132         BLI_assert(ELEM(mesh->runtime.looptris.len, 0, looptri_len));
133         return looptri_len;
134 }
135
136 /* This is a ported copy of dm_getLoopTriArray(dm). */
137 const MLoopTri *BKE_mesh_runtime_looptri_ensure(Mesh *mesh)
138 {
139         MLoopTri *looptri;
140
141         BLI_rw_mutex_lock(&loops_cache_lock, THREAD_LOCK_READ);
142         looptri = mesh->runtime.looptris.array;
143         BLI_rw_mutex_unlock(&loops_cache_lock);
144
145         if (looptri != NULL) {
146                 BLI_assert(BKE_mesh_runtime_looptri_len(mesh) == mesh->runtime.looptris.len);
147         }
148         else {
149                 BLI_rw_mutex_lock(&loops_cache_lock, THREAD_LOCK_WRITE);
150                 /* We need to ensure array is still NULL inside mutex-protected code, some other thread might have already
151                  * recomputed those looptris. */
152                 if (mesh->runtime.looptris.array == NULL) {
153                         BKE_mesh_runtime_looptri_recalc(mesh);
154                 }
155                 looptri = mesh->runtime.looptris.array;
156                 BLI_rw_mutex_unlock(&loops_cache_lock);
157         }
158         return looptri;
159 }
160
161 /* This is a copy of DM_verttri_from_looptri(). */
162 void BKE_mesh_runtime_verttri_from_looptri(
163         MVertTri *r_verttri, const MLoop *mloop,
164         const MLoopTri *looptri, int looptri_num)
165 {
166         int i;
167         for (i = 0; i < looptri_num; i++) {
168                 r_verttri[i].tri[0] = mloop[looptri[i].tri[0]].v;
169                 r_verttri[i].tri[1] = mloop[looptri[i].tri[1]].v;
170                 r_verttri[i].tri[2] = mloop[looptri[i].tri[2]].v;
171         }
172 }
173
174
175 bool BKE_mesh_runtime_ensure_edit_data(struct Mesh *mesh)
176 {
177         if (mesh->runtime.edit_data != NULL) {
178                 return false;
179         }
180
181         mesh->runtime.edit_data = MEM_callocN(sizeof(EditMeshData), "EditMeshData");
182         return true;
183 }
184
185 bool BKE_mesh_runtime_clear_edit_data(Mesh *mesh)
186 {
187         if (mesh->runtime.edit_data == NULL) {
188                 return false;
189         }
190
191         if (mesh->runtime.edit_data->polyCos != NULL)
192                 MEM_freeN((void *)mesh->runtime.edit_data->polyCos);
193         if (mesh->runtime.edit_data->polyNos != NULL)
194                 MEM_freeN((void *)mesh->runtime.edit_data->polyNos);
195         if (mesh->runtime.edit_data->vertexCos != NULL)
196                 MEM_freeN((void *)mesh->runtime.edit_data->vertexCos);
197         if (mesh->runtime.edit_data->vertexNos != NULL)
198                 MEM_freeN((void *)mesh->runtime.edit_data->vertexNos);
199
200         MEM_SAFE_FREE(mesh->runtime.edit_data);
201         return true;
202 }
203
204 void BKE_mesh_runtime_clear_geometry(Mesh *mesh)
205 {
206         bvhcache_free(&mesh->runtime.bvh_cache);
207         MEM_SAFE_FREE(mesh->runtime.looptris.array);
208         /* TODO(sergey): Does this really belong here? */
209         if (mesh->runtime.subdiv_ccg != NULL) {
210                 BKE_subdiv_ccg_destroy(mesh->runtime.subdiv_ccg);
211                 mesh->runtime.subdiv_ccg = NULL;
212         }
213         BKE_shrinkwrap_discard_boundary_data(mesh);
214 }
215
216 /** \} */
217
218 /* -------------------------------------------------------------------- */
219 /** \name Mesh Batch Cache Callbacks
220  * \{ */
221
222 /* Draw Engine */
223 void (*BKE_mesh_batch_cache_dirty_tag_cb)(Mesh *me, int mode) = NULL;
224 void (*BKE_mesh_batch_cache_free_cb)(Mesh *me) = NULL;
225
226 void BKE_mesh_batch_cache_dirty_tag(Mesh *me, int mode)
227 {
228         if (me->runtime.batch_cache) {
229                 BKE_mesh_batch_cache_dirty_tag_cb(me, mode);
230         }
231 }
232 void BKE_mesh_batch_cache_free(Mesh *me)
233 {
234         if (me->runtime.batch_cache) {
235                 BKE_mesh_batch_cache_free_cb(me);
236         }
237 }
238
239 /** \} */
240
241 /** \name Mesh runtime debug helpers.
242  * \{ */
243 /* evaluated mesh info printing function,
244  * to help track down differences output */
245
246 #ifndef NDEBUG
247 #include "BLI_dynstr.h"
248
249 static void mesh_runtime_debug_info_layers(
250         DynStr *dynstr, CustomData *cd)
251 {
252         int type;
253
254         for (type = 0; type < CD_NUMTYPES; type++) {
255                 if (CustomData_has_layer(cd, type)) {
256                         /* note: doesn't account for multiple layers */
257                         const char *name = CustomData_layertype_name(type);
258                         const int size = CustomData_sizeof(type);
259                         const void *pt = CustomData_get_layer(cd, type);
260                         const int pt_size = pt ? (int)(MEM_allocN_len(pt) / size) : 0;
261                         const char *structname;
262                         int structnum;
263                         CustomData_file_write_info(type, &structname, &structnum);
264                         BLI_dynstr_appendf(
265                                 dynstr,
266                                 "        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
267                                 name, structname, type, (const void *)pt, size, pt_size);
268                 }
269         }
270 }
271
272 char *BKE_mesh_runtime_debug_info(Mesh *me_eval)
273 {
274         DynStr *dynstr = BLI_dynstr_new();
275         char *ret;
276
277         BLI_dynstr_append(dynstr, "{\n");
278         BLI_dynstr_appendf(dynstr, "    'ptr': '%p',\n", (void *)me_eval);
279 #if 0
280         const char *tstr;
281         switch (me_eval->type) {
282                 case DM_TYPE_CDDM:     tstr = "DM_TYPE_CDDM";     break;
283                 case DM_TYPE_CCGDM:    tstr = "DM_TYPE_CCGDM";     break;
284                 default:               tstr = "UNKNOWN";           break;
285         }
286         BLI_dynstr_appendf(dynstr, "    'type': '%s',\n", tstr);
287 #endif
288         BLI_dynstr_appendf(dynstr, "    'totvert': %d,\n", me_eval->totvert);
289         BLI_dynstr_appendf(dynstr, "    'totedge': %d,\n", me_eval->totedge);
290         BLI_dynstr_appendf(dynstr, "    'totface': %d,\n", me_eval->totface);
291         BLI_dynstr_appendf(dynstr, "    'totpoly': %d,\n", me_eval->totpoly);
292         BLI_dynstr_appendf(dynstr, "    'deformed_only': %d,\n", me_eval->runtime.deformed_only);
293
294         BLI_dynstr_append(dynstr, "    'vertexLayers': (\n");
295         mesh_runtime_debug_info_layers(dynstr, &me_eval->vdata);
296         BLI_dynstr_append(dynstr, "    ),\n");
297
298         BLI_dynstr_append(dynstr, "    'edgeLayers': (\n");
299         mesh_runtime_debug_info_layers(dynstr, &me_eval->edata);
300         BLI_dynstr_append(dynstr, "    ),\n");
301
302         BLI_dynstr_append(dynstr, "    'loopLayers': (\n");
303         mesh_runtime_debug_info_layers(dynstr, &me_eval->ldata);
304         BLI_dynstr_append(dynstr, "    ),\n");
305
306         BLI_dynstr_append(dynstr, "    'polyLayers': (\n");
307         mesh_runtime_debug_info_layers(dynstr, &me_eval->pdata);
308         BLI_dynstr_append(dynstr, "    ),\n");
309
310         BLI_dynstr_append(dynstr, "    'tessFaceLayers': (\n");
311         mesh_runtime_debug_info_layers(dynstr, &me_eval->fdata);
312         BLI_dynstr_append(dynstr, "    ),\n");
313
314         BLI_dynstr_append(dynstr, "}\n");
315
316         ret = BLI_dynstr_get_cstring(dynstr);
317         BLI_dynstr_free(dynstr);
318         return ret;
319 }
320
321 void BKE_mesh_runtime_debug_print(Mesh *me_eval)
322 {
323         char *str = BKE_mesh_runtime_debug_info(me_eval);
324         puts(str);
325         fflush(stdout);
326         MEM_freeN(str);
327 }
328
329 /* XXX Should go in customdata file? */
330 void BKE_mesh_runtime_debug_print_cdlayers(CustomData *data)
331 {
332         int i;
333         const CustomDataLayer *layer;
334
335         printf("{\n");
336
337         for (i = 0, layer = data->layers; i < data->totlayer; i++, layer++) {
338
339                 const char *name = CustomData_layertype_name(layer->type);
340                 const int size = CustomData_sizeof(layer->type);
341                 const char *structname;
342                 int structnum;
343                 CustomData_file_write_info(layer->type, &structname, &structnum);
344                 printf("        dict(name='%s', struct='%s', type=%d, ptr='%p', elem=%d, length=%d),\n",
345                        name, structname, layer->type, (const void *)layer->data, size, (int)(MEM_allocN_len(layer->data) / size));
346         }
347
348         printf("}\n");
349 }
350
351 bool BKE_mesh_runtime_is_valid(Mesh *me_eval)
352 {
353         const bool do_verbose = true;
354         const bool do_fixes = false;
355
356         bool is_valid = true;
357         bool changed = true;
358
359         if (do_verbose) {
360                 printf("MESH: %s\n", me_eval->id.name + 2);
361         }
362
363         is_valid &= BKE_mesh_validate_all_customdata(
364                 &me_eval->vdata, me_eval->totvert,
365                 &me_eval->edata, me_eval->totedge,
366                 &me_eval->ldata, me_eval->totloop,
367                 &me_eval->pdata, me_eval->totpoly,
368                 false,  /* setting mask here isn't useful, gives false positives */
369                 do_verbose, do_fixes,
370                 &changed);
371
372         is_valid &= BKE_mesh_validate_arrays(
373                 me_eval,
374                 me_eval->mvert, me_eval->totvert,
375                 me_eval->medge, me_eval->totedge,
376                 me_eval->mface, me_eval->totface,
377                 me_eval->mloop, me_eval->totloop,
378                 me_eval->mpoly, me_eval->totpoly,
379                 me_eval->dvert,
380                 do_verbose, do_fixes,
381                 &changed);
382
383         BLI_assert(changed == false);
384
385         return is_valid;
386 }
387
388 #endif  /* NDEBUG */
389
390 /** \} */