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