Cleanup: comments (long lines) in blenkernel
[blender.git] / source / blender / blenkernel / intern / main.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) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  *
23  * Contains management of #Main database itself.
24  */
25
26 #include <string.h>
27
28 #include "MEM_guardedalloc.h"
29
30 #include "BLI_blenlib.h"
31 #include "BLI_ghash.h"
32 #include "BLI_mempool.h"
33 #include "BLI_threads.h"
34
35 #include "DNA_ID.h"
36
37 #include "BKE_global.h"
38 #include "BKE_library.h"
39 #include "BKE_library_query.h"
40 #include "BKE_main.h"
41
42 #include "IMB_imbuf.h"
43 #include "IMB_imbuf_types.h"
44
45 Main *BKE_main_new(void)
46 {
47   Main *bmain = MEM_callocN(sizeof(Main), "new main");
48   bmain->lock = MEM_mallocN(sizeof(SpinLock), "main lock");
49   BLI_spin_init((SpinLock *)bmain->lock);
50   return bmain;
51 }
52
53 void BKE_main_free(Main *mainvar)
54 {
55   /* also call when reading a file, erase all, etc */
56   ListBase *lbarray[MAX_LIBARRAY];
57   int a;
58
59   /* Since we are removing whole main, no need to bother 'properly'
60    * (and slowly) removing each ID from it. */
61   const int free_flag = (LIB_ID_FREE_NO_MAIN | LIB_ID_FREE_NO_UI_USER |
62                          LIB_ID_FREE_NO_USER_REFCOUNT | LIB_ID_FREE_NO_DEG_TAG);
63
64   MEM_SAFE_FREE(mainvar->blen_thumb);
65
66   a = set_listbasepointers(mainvar, lbarray);
67   while (a--) {
68     ListBase *lb = lbarray[a];
69     ID *id, *id_next;
70
71     for (id = lb->first; id != NULL; id = id_next) {
72       id_next = id->next;
73 #if 1
74       BKE_id_free_ex(mainvar, id, free_flag, false);
75 #else
76       /* errors freeing ID's can be hard to track down,
77        * enable this so valgrind will give the line number in its error log */
78       switch (a) {
79         case 0:
80           BKE_id_free_ex(mainvar, id, free_flag, false);
81           break;
82         case 1:
83           BKE_id_free_ex(mainvar, id, free_flag, false);
84           break;
85         case 2:
86           BKE_id_free_ex(mainvar, id, free_flag, false);
87           break;
88         case 3:
89           BKE_id_free_ex(mainvar, id, free_flag, false);
90           break;
91         case 4:
92           BKE_id_free_ex(mainvar, id, free_flag, false);
93           break;
94         case 5:
95           BKE_id_free_ex(mainvar, id, free_flag, false);
96           break;
97         case 6:
98           BKE_id_free_ex(mainvar, id, free_flag, false);
99           break;
100         case 7:
101           BKE_id_free_ex(mainvar, id, free_flag, false);
102           break;
103         case 8:
104           BKE_id_free_ex(mainvar, id, free_flag, false);
105           break;
106         case 9:
107           BKE_id_free_ex(mainvar, id, free_flag, false);
108           break;
109         case 10:
110           BKE_id_free_ex(mainvar, id, free_flag, false);
111           break;
112         case 11:
113           BKE_id_free_ex(mainvar, id, free_flag, false);
114           break;
115         case 12:
116           BKE_id_free_ex(mainvar, id, free_flag, false);
117           break;
118         case 13:
119           BKE_id_free_ex(mainvar, id, free_flag, false);
120           break;
121         case 14:
122           BKE_id_free_ex(mainvar, id, free_flag, false);
123           break;
124         case 15:
125           BKE_id_free_ex(mainvar, id, free_flag, false);
126           break;
127         case 16:
128           BKE_id_free_ex(mainvar, id, free_flag, false);
129           break;
130         case 17:
131           BKE_id_free_ex(mainvar, id, free_flag, false);
132           break;
133         case 18:
134           BKE_id_free_ex(mainvar, id, free_flag, false);
135           break;
136         case 19:
137           BKE_id_free_ex(mainvar, id, free_flag, false);
138           break;
139         case 20:
140           BKE_id_free_ex(mainvar, id, free_flag, false);
141           break;
142         case 21:
143           BKE_id_free_ex(mainvar, id, free_flag, false);
144           break;
145         case 22:
146           BKE_id_free_ex(mainvar, id, free_flag, false);
147           break;
148         case 23:
149           BKE_id_free_ex(mainvar, id, free_flag, false);
150           break;
151         case 24:
152           BKE_id_free_ex(mainvar, id, free_flag, false);
153           break;
154         case 25:
155           BKE_id_free_ex(mainvar, id, free_flag, false);
156           break;
157         case 26:
158           BKE_id_free_ex(mainvar, id, free_flag, false);
159           break;
160         case 27:
161           BKE_id_free_ex(mainvar, id, free_flag, false);
162           break;
163         case 28:
164           BKE_id_free_ex(mainvar, id, free_flag, false);
165           break;
166         case 29:
167           BKE_id_free_ex(mainvar, id, free_flag, false);
168           break;
169         case 30:
170           BKE_id_free_ex(mainvar, id, free_flag, false);
171           break;
172         case 31:
173           BKE_id_free_ex(mainvar, id, free_flag, false);
174           break;
175         case 32:
176           BKE_id_free_ex(mainvar, id, free_flag, false);
177           break;
178         case 33:
179           BKE_id_free_ex(mainvar, id, free_flag, false);
180           break;
181         case 34:
182           BKE_id_free_ex(mainvar, id, free_flag, false);
183           break;
184         default:
185           BLI_assert(0);
186           break;
187       }
188 #endif
189     }
190     BLI_listbase_clear(lb);
191   }
192
193   if (mainvar->relations) {
194     BKE_main_relations_free(mainvar);
195   }
196
197   BLI_spin_end((SpinLock *)mainvar->lock);
198   MEM_freeN(mainvar->lock);
199   MEM_freeN(mainvar);
200 }
201
202 void BKE_main_lock(struct Main *bmain)
203 {
204   BLI_spin_lock((SpinLock *)bmain->lock);
205 }
206
207 void BKE_main_unlock(struct Main *bmain)
208 {
209   BLI_spin_unlock((SpinLock *)bmain->lock);
210 }
211
212 static int main_relations_create_idlink_cb(void *user_data,
213                                            ID *id_self,
214                                            ID **id_pointer,
215                                            int cb_flag)
216 {
217   MainIDRelations *rel = user_data;
218
219   if (*id_pointer) {
220     MainIDRelationsEntry *entry, **entry_p;
221
222     entry = BLI_mempool_alloc(rel->entry_pool);
223     if (BLI_ghash_ensure_p(rel->id_user_to_used, id_self, (void ***)&entry_p)) {
224       entry->next = *entry_p;
225     }
226     else {
227       entry->next = NULL;
228     }
229     entry->id_pointer = id_pointer;
230     entry->usage_flag = cb_flag;
231     *entry_p = entry;
232
233     entry = BLI_mempool_alloc(rel->entry_pool);
234     if (BLI_ghash_ensure_p(rel->id_used_to_user, *id_pointer, (void ***)&entry_p)) {
235       entry->next = *entry_p;
236     }
237     else {
238       entry->next = NULL;
239     }
240     entry->id_pointer = (ID **)id_self;
241     entry->usage_flag = cb_flag;
242     *entry_p = entry;
243   }
244
245   return IDWALK_RET_NOP;
246 }
247
248 /** Generate the mappings between used IDs and their users, and vice-versa. */
249 void BKE_main_relations_create(Main *bmain)
250 {
251   if (bmain->relations != NULL) {
252     BKE_main_relations_free(bmain);
253   }
254
255   bmain->relations = MEM_mallocN(sizeof(*bmain->relations), __func__);
256   bmain->relations->id_used_to_user = BLI_ghash_new(
257       BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
258   bmain->relations->id_user_to_used = BLI_ghash_new(
259       BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
260   bmain->relations->entry_pool = BLI_mempool_create(
261       sizeof(MainIDRelationsEntry), 128, 128, BLI_MEMPOOL_NOP);
262
263   ID *id;
264   FOREACH_MAIN_ID_BEGIN (bmain, id) {
265     BKE_library_foreach_ID_link(
266         NULL, id, main_relations_create_idlink_cb, bmain->relations, IDWALK_READONLY);
267   }
268   FOREACH_MAIN_ID_END;
269 }
270
271 void BKE_main_relations_free(Main *bmain)
272 {
273   if (bmain->relations) {
274     if (bmain->relations->id_used_to_user) {
275       BLI_ghash_free(bmain->relations->id_used_to_user, NULL, NULL);
276     }
277     if (bmain->relations->id_user_to_used) {
278       BLI_ghash_free(bmain->relations->id_user_to_used, NULL, NULL);
279     }
280     BLI_mempool_destroy(bmain->relations->entry_pool);
281     MEM_freeN(bmain->relations);
282     bmain->relations = NULL;
283   }
284 }
285
286 /**
287  * Create a GSet storing all IDs present in given \a bmain, by their pointers.
288  *
289  * \param gset: If not NULL, given GSet will be extended with IDs from given \a bmain,
290  * instead of creating a new one.
291  */
292 GSet *BKE_main_gset_create(Main *bmain, GSet *gset)
293 {
294   if (gset == NULL) {
295     gset = BLI_gset_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
296   }
297
298   ID *id;
299   FOREACH_MAIN_ID_BEGIN (bmain, id) {
300     BLI_gset_add(gset, id);
301   }
302   FOREACH_MAIN_ID_END;
303   return gset;
304 }
305
306 /**
307  * Generates a raw .blend file thumbnail data from given image.
308  *
309  * \param bmain: If not NULL, also store generated data in this Main.
310  * \param img: ImBuf image to generate thumbnail data from.
311  * \return The generated .blend file raw thumbnail data.
312  */
313 BlendThumbnail *BKE_main_thumbnail_from_imbuf(Main *bmain, ImBuf *img)
314 {
315   BlendThumbnail *data = NULL;
316
317   if (bmain) {
318     MEM_SAFE_FREE(bmain->blen_thumb);
319   }
320
321   if (img) {
322     const size_t sz = BLEN_THUMB_MEMSIZE(img->x, img->y);
323     data = MEM_mallocN(sz, __func__);
324
325     IMB_rect_from_float(img); /* Just in case... */
326     data->width = img->x;
327     data->height = img->y;
328     memcpy(data->rect, img->rect, sz - sizeof(*data));
329   }
330
331   if (bmain) {
332     bmain->blen_thumb = data;
333   }
334   return data;
335 }
336
337 /**
338  * Generates an image from raw .blend file thumbnail \a data.
339  *
340  * \param bmain: Use this bmain->blen_thumb data if given \a data is NULL.
341  * \param data: Raw .blend file thumbnail data.
342  * \return An ImBuf from given data, or NULL if invalid.
343  */
344 ImBuf *BKE_main_thumbnail_to_imbuf(Main *bmain, BlendThumbnail *data)
345 {
346   ImBuf *img = NULL;
347
348   if (!data && bmain) {
349     data = bmain->blen_thumb;
350   }
351
352   if (data) {
353     /* Note: we cannot use IMB_allocFromBuffer(), since it tries to dupalloc passed buffer,
354      *       which will fail here (we do not want to pass the first two ints!). */
355     img = IMB_allocImBuf(
356         (unsigned int)data->width, (unsigned int)data->height, 32, IB_rect | IB_metadata);
357     memcpy(img->rect, data->rect, BLEN_THUMB_MEMSIZE(data->width, data->height) - sizeof(*data));
358   }
359
360   return img;
361 }
362
363 /**
364  * Generates an empty (black) thumbnail for given Main.
365  */
366 void BKE_main_thumbnail_create(struct Main *bmain)
367 {
368   MEM_SAFE_FREE(bmain->blen_thumb);
369
370   bmain->blen_thumb = MEM_callocN(BLEN_THUMB_MEMSIZE(BLEN_THUMB_SIZE, BLEN_THUMB_SIZE), __func__);
371   bmain->blen_thumb->width = BLEN_THUMB_SIZE;
372   bmain->blen_thumb->height = BLEN_THUMB_SIZE;
373 }
374
375 /**
376  * Return filepath of given \a main.
377  */
378 const char *BKE_main_blendfile_path(const Main *bmain)
379 {
380   return bmain->name;
381 }
382
383 /**
384  * Return filepath of global main #G_MAIN.
385  *
386  * \warning Usage is not recommended,
387  * you should always try to get a valid Main pointer from context...
388  */
389 const char *BKE_main_blendfile_path_from_global(void)
390 {
391   return BKE_main_blendfile_path(G_MAIN);
392 }
393
394 /**
395  * \return A pointer to the \a ListBase of given \a bmain for requested \a type ID type.
396  */
397 ListBase *which_libbase(Main *bmain, short type)
398 {
399   switch ((ID_Type)type) {
400     case ID_SCE:
401       return &(bmain->scenes);
402     case ID_LI:
403       return &(bmain->libraries);
404     case ID_OB:
405       return &(bmain->objects);
406     case ID_ME:
407       return &(bmain->meshes);
408     case ID_CU:
409       return &(bmain->curves);
410     case ID_MB:
411       return &(bmain->metaballs);
412     case ID_MA:
413       return &(bmain->materials);
414     case ID_TE:
415       return &(bmain->textures);
416     case ID_IM:
417       return &(bmain->images);
418     case ID_LT:
419       return &(bmain->lattices);
420     case ID_LA:
421       return &(bmain->lights);
422     case ID_CA:
423       return &(bmain->cameras);
424     case ID_IP:
425       return &(bmain->ipo);
426     case ID_KE:
427       return &(bmain->shapekeys);
428     case ID_WO:
429       return &(bmain->worlds);
430     case ID_SCR:
431       return &(bmain->screens);
432     case ID_VF:
433       return &(bmain->fonts);
434     case ID_TXT:
435       return &(bmain->texts);
436     case ID_SPK:
437       return &(bmain->speakers);
438     case ID_LP:
439       return &(bmain->lightprobes);
440     case ID_SO:
441       return &(bmain->sounds);
442     case ID_GR:
443       return &(bmain->collections);
444     case ID_AR:
445       return &(bmain->armatures);
446     case ID_AC:
447       return &(bmain->actions);
448     case ID_NT:
449       return &(bmain->nodetrees);
450     case ID_BR:
451       return &(bmain->brushes);
452     case ID_PA:
453       return &(bmain->particles);
454     case ID_WM:
455       return &(bmain->wm);
456     case ID_GD:
457       return &(bmain->gpencils);
458     case ID_MC:
459       return &(bmain->movieclips);
460     case ID_MSK:
461       return &(bmain->masks);
462     case ID_LS:
463       return &(bmain->linestyles);
464     case ID_PAL:
465       return &(bmain->palettes);
466     case ID_PC:
467       return &(bmain->paintcurves);
468     case ID_CF:
469       return &(bmain->cachefiles);
470     case ID_WS:
471       return &(bmain->workspaces);
472   }
473   return NULL;
474 }
475
476 /**
477  * puts into array *lb pointers to all the #ListBase structs in main,
478  * and returns the number of them as the function result. This is useful for
479  * generic traversal of all the blocks in a Main (by traversing all the
480  * lists in turn), without worrying about block types.
481  *
482  * \note #MAX_LIBARRAY define should match this code */
483 int set_listbasepointers(Main *bmain, ListBase **lb)
484 {
485   /* BACKWARDS! also watch order of free-ing! (mesh<->mat), first items freed last.
486    * This is important because freeing data decreases usercounts of other datablocks,
487    * if this data is its self freed it can crash. */
488   lb[INDEX_ID_LI] = &(
489       bmain->libraries); /* Libraries may be accessed from pretty much any other ID... */
490   lb[INDEX_ID_IP] = &(bmain->ipo);
491   lb[INDEX_ID_AC] = &(
492       bmain->actions); /* moved here to avoid problems when freeing with animato (aligorith) */
493   lb[INDEX_ID_KE] = &(bmain->shapekeys);
494   lb[INDEX_ID_PAL] = &(
495       bmain->palettes); /* referenced by gpencil, so needs to be before that to avoid crashes */
496   lb[INDEX_ID_GD] = &(
497       bmain->gpencils); /* referenced by nodes, objects, view, scene etc, before to free after. */
498   lb[INDEX_ID_NT] = &(bmain->nodetrees);
499   lb[INDEX_ID_IM] = &(bmain->images);
500   lb[INDEX_ID_TE] = &(bmain->textures);
501   lb[INDEX_ID_MA] = &(bmain->materials);
502   lb[INDEX_ID_VF] = &(bmain->fonts);
503
504   /* Important!: When adding a new object type,
505    * the specific data should be inserted here
506    */
507
508   lb[INDEX_ID_AR] = &(bmain->armatures);
509
510   lb[INDEX_ID_CF] = &(bmain->cachefiles);
511   lb[INDEX_ID_ME] = &(bmain->meshes);
512   lb[INDEX_ID_CU] = &(bmain->curves);
513   lb[INDEX_ID_MB] = &(bmain->metaballs);
514
515   lb[INDEX_ID_LT] = &(bmain->lattices);
516   lb[INDEX_ID_LA] = &(bmain->lights);
517   lb[INDEX_ID_CA] = &(bmain->cameras);
518
519   lb[INDEX_ID_TXT] = &(bmain->texts);
520   lb[INDEX_ID_SO] = &(bmain->sounds);
521   lb[INDEX_ID_GR] = &(bmain->collections);
522   lb[INDEX_ID_PAL] = &(bmain->palettes);
523   lb[INDEX_ID_PC] = &(bmain->paintcurves);
524   lb[INDEX_ID_BR] = &(bmain->brushes);
525   lb[INDEX_ID_PA] = &(bmain->particles);
526   lb[INDEX_ID_SPK] = &(bmain->speakers);
527   lb[INDEX_ID_LP] = &(bmain->lightprobes);
528
529   lb[INDEX_ID_WO] = &(bmain->worlds);
530   lb[INDEX_ID_MC] = &(bmain->movieclips);
531   lb[INDEX_ID_SCR] = &(bmain->screens);
532   lb[INDEX_ID_OB] = &(bmain->objects);
533   lb[INDEX_ID_LS] = &(bmain->linestyles); /* referenced by scenes */
534   lb[INDEX_ID_SCE] = &(bmain->scenes);
535   lb[INDEX_ID_WS] = &(bmain->workspaces); /* before wm, so it's freed after it! */
536   lb[INDEX_ID_WM] = &(bmain->wm);
537   lb[INDEX_ID_MSK] = &(bmain->masks);
538
539   lb[INDEX_ID_NULL] = NULL;
540
541   return (MAX_LIBARRAY - 1);
542 }