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