Armature: use BKE_armature_transform when applying transformation
[blender.git] / source / blender / blenkernel / intern / icons.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) 2006-2007 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <math.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "CLG_log.h"
29
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_brush_types.h"
33 #include "DNA_collection_types.h"
34 #include "DNA_gpencil_types.h"
35 #include "DNA_light_types.h"
36 #include "DNA_material_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_scene_types.h"
39 #include "DNA_screen_types.h"
40 #include "DNA_texture_types.h"
41 #include "DNA_world_types.h"
42
43 #include "BLI_utildefines.h"
44 #include "BLI_ghash.h"
45 #include "BLI_linklist_lockfree.h"
46 #include "BLI_string.h"
47 #include "BLI_fileops.h"
48 #include "BLI_threads.h"
49
50 #include "BKE_icons.h"
51 #include "BKE_global.h" /* only for G.background test */
52 #include "BKE_studiolight.h"
53
54 #include "BLI_sys_types.h"  // for intptr_t support
55
56 #include "GPU_texture.h"
57
58 #include "IMB_imbuf.h"
59 #include "IMB_imbuf_types.h"
60 #include "IMB_thumbs.h"
61
62 /**
63  * Only allow non-managed icons to be removed (by Python for eg).
64  * Previews & ID's have their own functions to remove icons.
65  */
66 enum {
67   ICON_FLAG_MANAGED = (1 << 0),
68 };
69
70 /* GLOBALS */
71
72 static CLG_LogRef LOG = {"bke.icons"};
73
74 static GHash *gIcons = NULL;
75
76 static int gNextIconId = 1;
77
78 static int gFirstIconId = 1;
79
80 static GHash *gCachedPreviews = NULL;
81
82 /* Queue of icons for deferred deletion. */
83 typedef struct DeferredIconDeleteNode {
84   struct DeferredIconDeleteNode *next;
85   int icon_id;
86 } DeferredIconDeleteNode;
87 static LockfreeLinkList g_icon_delete_queue;
88
89 static void icon_free(void *val)
90 {
91   Icon *icon = val;
92
93   if (icon) {
94     if (icon->obj_type == ICON_DATA_GEOM) {
95       struct Icon_Geom *obj = icon->obj;
96       if (obj->mem) {
97         /* coords & colors are part of this memory. */
98         MEM_freeN((void *)obj->mem);
99       }
100       else {
101         MEM_freeN((void *)obj->coords);
102         MEM_freeN((void *)obj->colors);
103       }
104       MEM_freeN(icon->obj);
105     }
106
107     if (icon->drawinfo_free) {
108       icon->drawinfo_free(icon->drawinfo);
109     }
110     else if (icon->drawinfo) {
111       MEM_freeN(icon->drawinfo);
112     }
113     MEM_freeN(icon);
114   }
115 }
116
117 static void icon_free_data(int icon_id, Icon *icon)
118 {
119   if (icon->obj_type == ICON_DATA_ID) {
120     ((ID *)(icon->obj))->icon_id = 0;
121   }
122   else if (icon->obj_type == ICON_DATA_PREVIEW) {
123     ((PreviewImage *)(icon->obj))->icon_id = 0;
124   }
125   else if (icon->obj_type == ICON_DATA_GPLAYER) {
126     ((bGPDlayer *)(icon->obj))->runtime.icon_id = 0;
127   }
128   else if (icon->obj_type == ICON_DATA_GEOM) {
129     ((struct Icon_Geom *)(icon->obj))->icon_id = 0;
130   }
131   else if (icon->obj_type == ICON_DATA_STUDIOLIGHT) {
132     StudioLight *sl = icon->obj;
133     if (sl != NULL) {
134       BKE_studiolight_unset_icon_id(sl, icon_id);
135     }
136   }
137   else {
138     BLI_assert(0);
139   }
140 }
141
142 /* create an id for a new icon and make sure that ids from deleted icons get reused
143  * after the integer number range is used up */
144 static int get_next_free_id(void)
145 {
146   BLI_assert(BLI_thread_is_main());
147   int startId = gFirstIconId;
148
149   /* if we haven't used up the int number range, we just return the next int */
150   if (gNextIconId >= gFirstIconId) {
151     return gNextIconId++;
152   }
153
154   /* now we try to find the smallest icon id not stored in the gIcons hash */
155   while (BLI_ghash_lookup(gIcons, POINTER_FROM_INT(startId)) && startId >= gFirstIconId) {
156     startId++;
157   }
158
159   /* if we found a suitable one that isn't used yet, return it */
160   if (startId >= gFirstIconId) {
161     return startId;
162   }
163
164   /* fail */
165   return 0;
166 }
167
168 void BKE_icons_init(int first_dyn_id)
169 {
170   BLI_assert(BLI_thread_is_main());
171
172   gNextIconId = first_dyn_id;
173   gFirstIconId = first_dyn_id;
174
175   if (!gIcons) {
176     gIcons = BLI_ghash_int_new(__func__);
177     BLI_linklist_lockfree_init(&g_icon_delete_queue);
178   }
179
180   if (!gCachedPreviews) {
181     gCachedPreviews = BLI_ghash_str_new(__func__);
182   }
183 }
184
185 void BKE_icons_free(void)
186 {
187   BLI_assert(BLI_thread_is_main());
188
189   if (gIcons) {
190     BLI_ghash_free(gIcons, NULL, icon_free);
191     gIcons = NULL;
192   }
193
194   if (gCachedPreviews) {
195     BLI_ghash_free(gCachedPreviews, MEM_freeN, BKE_previewimg_freefunc);
196     gCachedPreviews = NULL;
197   }
198
199   BLI_linklist_lockfree_free(&g_icon_delete_queue, MEM_freeN);
200 }
201
202 void BKE_icons_deferred_free(void)
203 {
204   BLI_assert(BLI_thread_is_main());
205
206   for (DeferredIconDeleteNode *node =
207            (DeferredIconDeleteNode *)BLI_linklist_lockfree_begin(&g_icon_delete_queue);
208        node != NULL;
209        node = node->next) {
210     BLI_ghash_remove(gIcons, POINTER_FROM_INT(node->icon_id), NULL, icon_free);
211   }
212   BLI_linklist_lockfree_clear(&g_icon_delete_queue, MEM_freeN);
213 }
214
215 static PreviewImage *previewimg_create_ex(size_t deferred_data_size)
216 {
217   PreviewImage *prv_img = NULL;
218   int i;
219
220   prv_img = MEM_mallocN(sizeof(PreviewImage) + deferred_data_size, "img_prv");
221   memset(prv_img, 0, sizeof(*prv_img)); /* leave deferred data dirty */
222
223   if (deferred_data_size) {
224     prv_img->tag |= PRV_TAG_DEFFERED;
225   }
226
227   for (i = 0; i < NUM_ICON_SIZES; ++i) {
228     prv_img->flag[i] |= PRV_CHANGED;
229     prv_img->changed_timestamp[i] = 0;
230   }
231   return prv_img;
232 }
233
234 PreviewImage *BKE_previewimg_create(void)
235 {
236   return previewimg_create_ex(0);
237 }
238
239 void BKE_previewimg_freefunc(void *link)
240 {
241   PreviewImage *prv = (PreviewImage *)link;
242   if (prv) {
243     int i;
244
245     for (i = 0; i < NUM_ICON_SIZES; ++i) {
246       if (prv->rect[i]) {
247         MEM_freeN(prv->rect[i]);
248       }
249       if (prv->gputexture[i]) {
250         GPU_texture_free(prv->gputexture[i]);
251       }
252     }
253
254     MEM_freeN(prv);
255   }
256 }
257
258 void BKE_previewimg_free(PreviewImage **prv)
259 {
260   if (prv && (*prv)) {
261     BKE_previewimg_freefunc(*prv);
262     *prv = NULL;
263   }
264 }
265
266 void BKE_previewimg_clear_single(struct PreviewImage *prv, enum eIconSizes size)
267 {
268   MEM_SAFE_FREE(prv->rect[size]);
269   if (prv->gputexture[size]) {
270     GPU_texture_free(prv->gputexture[size]);
271   }
272   prv->h[size] = prv->w[size] = 0;
273   prv->flag[size] |= PRV_CHANGED;
274   prv->flag[size] &= ~PRV_USER_EDITED;
275   prv->changed_timestamp[size] = 0;
276 }
277
278 void BKE_previewimg_clear(struct PreviewImage *prv)
279 {
280   int i;
281   for (i = 0; i < NUM_ICON_SIZES; ++i) {
282     BKE_previewimg_clear_single(prv, i);
283   }
284 }
285
286 PreviewImage *BKE_previewimg_copy(const PreviewImage *prv)
287 {
288   PreviewImage *prv_img = NULL;
289   int i;
290
291   if (prv) {
292     prv_img = MEM_dupallocN(prv);
293     for (i = 0; i < NUM_ICON_SIZES; ++i) {
294       if (prv->rect[i]) {
295         prv_img->rect[i] = MEM_dupallocN(prv->rect[i]);
296       }
297       prv_img->gputexture[i] = NULL;
298     }
299   }
300   return prv_img;
301 }
302
303 /**
304  * Duplicate preview image from \a id and clear icon_id,
305  * to be used by datablock copy functions.
306  */
307 void BKE_previewimg_id_copy(ID *new_id, const ID *old_id)
308 {
309   PreviewImage **old_prv_p = BKE_previewimg_id_get_p(old_id);
310   PreviewImage **new_prv_p = BKE_previewimg_id_get_p(new_id);
311
312   if (old_prv_p && *old_prv_p) {
313     BLI_assert(new_prv_p != NULL && ELEM(*new_prv_p, NULL, *old_prv_p));
314     //      const int new_icon_id = get_next_free_id();
315
316     //      if (new_icon_id == 0) {
317     //          return;  /* Failure. */
318     //      }
319     *new_prv_p = BKE_previewimg_copy(*old_prv_p);
320     new_id->icon_id = (*new_prv_p)->icon_id = 0;
321   }
322 }
323
324 PreviewImage **BKE_previewimg_id_get_p(const ID *id)
325 {
326   switch (GS(id->name)) {
327 #define ID_PRV_CASE(id_code, id_struct) \
328   case id_code: { \
329     return &((id_struct *)id)->preview; \
330   } \
331     ((void)0)
332     ID_PRV_CASE(ID_MA, Material);
333     ID_PRV_CASE(ID_TE, Tex);
334     ID_PRV_CASE(ID_WO, World);
335     ID_PRV_CASE(ID_LA, Light);
336     ID_PRV_CASE(ID_IM, Image);
337     ID_PRV_CASE(ID_BR, Brush);
338     ID_PRV_CASE(ID_OB, Object);
339     ID_PRV_CASE(ID_GR, Collection);
340     ID_PRV_CASE(ID_SCE, Scene);
341     ID_PRV_CASE(ID_SCR, bScreen);
342 #undef ID_PRV_CASE
343     default:
344       break;
345   }
346
347   return NULL;
348 }
349
350 void BKE_previewimg_id_free(ID *id)
351 {
352   PreviewImage **prv_p = BKE_previewimg_id_get_p(id);
353   if (prv_p) {
354     BKE_previewimg_free(prv_p);
355   }
356 }
357
358 PreviewImage *BKE_previewimg_id_ensure(ID *id)
359 {
360   PreviewImage **prv_p = BKE_previewimg_id_get_p(id);
361
362   if (prv_p) {
363     if (*prv_p == NULL) {
364       *prv_p = BKE_previewimg_create();
365     }
366     return *prv_p;
367   }
368
369   return NULL;
370 }
371
372 PreviewImage *BKE_previewimg_cached_get(const char *name)
373 {
374   return BLI_ghash_lookup(gCachedPreviews, name);
375 }
376
377 /**
378  * Generate an empty PreviewImage, if not yet existing.
379  */
380 PreviewImage *BKE_previewimg_cached_ensure(const char *name)
381 {
382   PreviewImage *prv = NULL;
383   void **key_p, **prv_p;
384
385   if (!BLI_ghash_ensure_p_ex(gCachedPreviews, name, &key_p, &prv_p)) {
386     *key_p = BLI_strdup(name);
387     *prv_p = BKE_previewimg_create();
388   }
389   prv = *prv_p;
390   BLI_assert(prv);
391
392   return prv;
393 }
394
395 /**
396  * Generate a PreviewImage from given file path, using thumbnails management, if not yet existing.
397  */
398 PreviewImage *BKE_previewimg_cached_thumbnail_read(const char *name,
399                                                    const char *path,
400                                                    const int source,
401                                                    bool force_update)
402 {
403   PreviewImage *prv = NULL;
404   void **prv_p;
405
406   prv_p = BLI_ghash_lookup_p(gCachedPreviews, name);
407
408   if (prv_p) {
409     prv = *prv_p;
410     BLI_assert(prv);
411   }
412
413   if (prv && force_update) {
414     const char *prv_deferred_data = PRV_DEFERRED_DATA(prv);
415     if (((int)prv_deferred_data[0] == source) && STREQ(&prv_deferred_data[1], path)) {
416       /* If same path, no need to re-allocate preview, just clear it up. */
417       BKE_previewimg_clear(prv);
418     }
419     else {
420       BKE_previewimg_free(&prv);
421     }
422   }
423
424   if (!prv) {
425     /* We pack needed data for lazy loading (source type, in a single char, and path). */
426     const size_t deferred_data_size = strlen(path) + 2;
427     char *deferred_data;
428
429     prv = previewimg_create_ex(deferred_data_size);
430     deferred_data = PRV_DEFERRED_DATA(prv);
431     deferred_data[0] = source;
432     memcpy(&deferred_data[1], path, deferred_data_size - 1);
433
434     force_update = true;
435   }
436
437   if (force_update) {
438     if (prv_p) {
439       *prv_p = prv;
440     }
441     else {
442       BLI_ghash_insert(gCachedPreviews, BLI_strdup(name), prv);
443     }
444   }
445
446   return prv;
447 }
448
449 void BKE_previewimg_cached_release_pointer(PreviewImage *prv)
450 {
451   if (prv) {
452     if (prv->tag & PRV_TAG_DEFFERED_RENDERING) {
453       /* We cannot delete the preview while it is being loaded in another thread... */
454       prv->tag |= PRV_TAG_DEFFERED_DELETE;
455       return;
456     }
457     if (prv->icon_id) {
458       BKE_icon_delete(prv->icon_id);
459     }
460     BKE_previewimg_freefunc(prv);
461   }
462 }
463
464 void BKE_previewimg_cached_release(const char *name)
465 {
466   PreviewImage *prv = BLI_ghash_popkey(gCachedPreviews, name, MEM_freeN);
467
468   BKE_previewimg_cached_release_pointer(prv);
469 }
470
471 /** Handle deferred (lazy) loading/generation of preview image, if needed.
472  * For now, only used with file thumbnails. */
473 void BKE_previewimg_ensure(PreviewImage *prv, const int size)
474 {
475   if ((prv->tag & PRV_TAG_DEFFERED) != 0) {
476     const bool do_icon = ((size == ICON_SIZE_ICON) && !prv->rect[ICON_SIZE_ICON]);
477     const bool do_preview = ((size == ICON_SIZE_PREVIEW) && !prv->rect[ICON_SIZE_PREVIEW]);
478
479     if (do_icon || do_preview) {
480       ImBuf *thumb;
481       char *prv_deferred_data = PRV_DEFERRED_DATA(prv);
482       int source = prv_deferred_data[0];
483       char *path = &prv_deferred_data[1];
484       int icon_w, icon_h;
485
486       thumb = IMB_thumb_manage(path, THB_LARGE, source);
487
488       if (thumb) {
489         /* PreviewImage assumes premultiplied alhpa... */
490         IMB_premultiply_alpha(thumb);
491
492         if (do_preview) {
493           prv->w[ICON_SIZE_PREVIEW] = thumb->x;
494           prv->h[ICON_SIZE_PREVIEW] = thumb->y;
495           prv->rect[ICON_SIZE_PREVIEW] = MEM_dupallocN(thumb->rect);
496           prv->flag[ICON_SIZE_PREVIEW] &= ~(PRV_CHANGED | PRV_USER_EDITED);
497         }
498         if (do_icon) {
499           if (thumb->x > thumb->y) {
500             icon_w = ICON_RENDER_DEFAULT_HEIGHT;
501             icon_h = (thumb->y * icon_w) / thumb->x + 1;
502           }
503           else if (thumb->x < thumb->y) {
504             icon_h = ICON_RENDER_DEFAULT_HEIGHT;
505             icon_w = (thumb->x * icon_h) / thumb->y + 1;
506           }
507           else {
508             icon_w = icon_h = ICON_RENDER_DEFAULT_HEIGHT;
509           }
510
511           IMB_scaleImBuf(thumb, icon_w, icon_h);
512           prv->w[ICON_SIZE_ICON] = icon_w;
513           prv->h[ICON_SIZE_ICON] = icon_h;
514           prv->rect[ICON_SIZE_ICON] = MEM_dupallocN(thumb->rect);
515           prv->flag[ICON_SIZE_ICON] &= ~(PRV_CHANGED | PRV_USER_EDITED);
516         }
517         IMB_freeImBuf(thumb);
518       }
519     }
520   }
521 }
522
523 void BKE_icon_changed(const int icon_id)
524 {
525   BLI_assert(BLI_thread_is_main());
526
527   Icon *icon = NULL;
528
529   if (!icon_id || G.background) {
530     return;
531   }
532
533   icon = BLI_ghash_lookup(gIcons, POINTER_FROM_INT(icon_id));
534
535   if (icon) {
536     /* We *only* expect ID-tied icons here, not non-ID icon/preview! */
537     BLI_assert(icon->id_type != 0);
538     BLI_assert(icon->obj_type == ICON_DATA_ID);
539
540     /* Do not enforce creation of previews for valid ID types using BKE_previewimg_id_ensure()
541      * here, we only want to ensure *existing* preview images are properly tagged as
542      * changed/invalid, that's all. */
543     PreviewImage **p_prv = BKE_previewimg_id_get_p((ID *)icon->obj);
544
545     /* If we have previews, they all are now invalid changed. */
546     if (p_prv && *p_prv) {
547       int i;
548       for (i = 0; i < NUM_ICON_SIZES; ++i) {
549         (*p_prv)->flag[i] |= PRV_CHANGED;
550         (*p_prv)->changed_timestamp[i]++;
551       }
552     }
553   }
554 }
555
556 static Icon *icon_create(int icon_id, int obj_type, void *obj)
557 {
558   Icon *new_icon = MEM_mallocN(sizeof(Icon), __func__);
559
560   new_icon->obj_type = obj_type;
561   new_icon->obj = obj;
562   new_icon->id_type = 0;
563   new_icon->flag = 0;
564
565   /* next two lines make sure image gets created */
566   new_icon->drawinfo = NULL;
567   new_icon->drawinfo_free = NULL;
568
569   BLI_ghash_insert(gIcons, POINTER_FROM_INT(icon_id), new_icon);
570
571   return new_icon;
572 }
573
574 static int icon_id_ensure_create_icon(struct ID *id)
575 {
576   BLI_assert(BLI_thread_is_main());
577
578   Icon *icon = icon_create(id->icon_id, ICON_DATA_ID, id);
579   icon->id_type = GS(id->name);
580   icon->flag = ICON_FLAG_MANAGED;
581
582   return id->icon_id;
583 }
584
585 int BKE_icon_id_ensure(struct ID *id)
586 {
587   /* Never handle icons in non-main thread! */
588   BLI_assert(BLI_thread_is_main());
589
590   if (!id || G.background) {
591     return 0;
592   }
593
594   if (id->icon_id) {
595     return id->icon_id;
596   }
597
598   id->icon_id = get_next_free_id();
599
600   if (!id->icon_id) {
601     CLOG_ERROR(&LOG, "not enough IDs");
602     return 0;
603   }
604
605   /* Ensure we synchronize ID icon_id with its previewimage if it has one. */
606   PreviewImage **p_prv = BKE_previewimg_id_get_p(id);
607   if (p_prv && *p_prv) {
608     BLI_assert(ELEM((*p_prv)->icon_id, 0, id->icon_id));
609     (*p_prv)->icon_id = id->icon_id;
610   }
611
612   return icon_id_ensure_create_icon(id);
613 }
614
615 static int icon_gplayer_color_ensure_create_icon(bGPDlayer *gpl)
616 {
617   BLI_assert(BLI_thread_is_main());
618
619   /* NOTE: The color previews for GP Layers don't really need
620    * to be "rendered" to image per se (as it will just be a plain
621    * colored rectangle), we need to define icon data here so that
622    * we can store a pointer to the layer data in icon->obj.
623    */
624   Icon *icon = icon_create(gpl->runtime.icon_id, ICON_DATA_GPLAYER, gpl);
625   icon->flag = ICON_FLAG_MANAGED;
626
627   return gpl->runtime.icon_id;
628 }
629
630 int BKE_icon_gplayer_color_ensure(bGPDlayer *gpl)
631 {
632   /* Never handle icons in non-main thread! */
633   BLI_assert(BLI_thread_is_main());
634
635   if (!gpl || G.background) {
636     return 0;
637   }
638
639   if (gpl->runtime.icon_id) {
640     return gpl->runtime.icon_id;
641   }
642
643   gpl->runtime.icon_id = get_next_free_id();
644
645   if (!gpl->runtime.icon_id) {
646     CLOG_ERROR(&LOG, "not enough IDs");
647     return 0;
648   }
649
650   return icon_gplayer_color_ensure_create_icon(gpl);
651 }
652
653 /**
654  * Return icon id of given preview, or create new icon if not found.
655  */
656 int BKE_icon_preview_ensure(ID *id, PreviewImage *preview)
657 {
658   if (!preview || G.background) {
659     return 0;
660   }
661
662   if (id) {
663     BLI_assert(BKE_previewimg_id_ensure(id) == preview);
664   }
665
666   if (preview->icon_id) {
667     BLI_assert(!id || !id->icon_id || id->icon_id == preview->icon_id);
668     return preview->icon_id;
669   }
670
671   if (id && id->icon_id) {
672     preview->icon_id = id->icon_id;
673     return preview->icon_id;
674   }
675
676   preview->icon_id = get_next_free_id();
677
678   if (!preview->icon_id) {
679     CLOG_ERROR(&LOG, "not enough IDs");
680     return 0;
681   }
682
683   /* Ensure we synchronize ID icon_id with its previewimage if available,
684    * and generate suitable 'ID' icon. */
685   if (id) {
686     id->icon_id = preview->icon_id;
687     return icon_id_ensure_create_icon(id);
688   }
689
690   Icon *icon = icon_create(preview->icon_id, ICON_DATA_PREVIEW, preview);
691   icon->flag = ICON_FLAG_MANAGED;
692
693   return preview->icon_id;
694 }
695
696 Icon *BKE_icon_get(const int icon_id)
697 {
698   BLI_assert(BLI_thread_is_main());
699
700   Icon *icon = NULL;
701
702   icon = BLI_ghash_lookup(gIcons, POINTER_FROM_INT(icon_id));
703
704   if (!icon) {
705     CLOG_ERROR(&LOG, "no icon for icon ID: %d", icon_id);
706     return NULL;
707   }
708
709   return icon;
710 }
711
712 void BKE_icon_set(const int icon_id, struct Icon *icon)
713 {
714   BLI_assert(BLI_thread_is_main());
715
716   void **val_p;
717
718   if (BLI_ghash_ensure_p(gIcons, POINTER_FROM_INT(icon_id), &val_p)) {
719     CLOG_ERROR(&LOG, "icon already set: %d", icon_id);
720     return;
721   }
722
723   *val_p = icon;
724 }
725
726 static void icon_add_to_deferred_delete_queue(int icon_id)
727 {
728   DeferredIconDeleteNode *node = MEM_mallocN(sizeof(DeferredIconDeleteNode), __func__);
729   node->icon_id = icon_id;
730   BLI_linklist_lockfree_insert(&g_icon_delete_queue, (LockfreeLinkNode *)node);
731 }
732
733 void BKE_icon_id_delete(struct ID *id)
734 {
735   const int icon_id = id->icon_id;
736   if (!icon_id) {
737     return; /* no icon defined for library object */
738   }
739   id->icon_id = 0;
740
741   if (!BLI_thread_is_main()) {
742     icon_add_to_deferred_delete_queue(icon_id);
743     return;
744   }
745
746   BKE_icons_deferred_free();
747   BLI_ghash_remove(gIcons, POINTER_FROM_INT(icon_id), NULL, icon_free);
748 }
749
750 /**
751  * Remove icon and free data.
752  */
753 bool BKE_icon_delete(const int icon_id)
754 {
755   if (icon_id == 0) {
756     /* no icon defined for library object */
757     return false;
758   }
759
760   Icon *icon = BLI_ghash_popkey(gIcons, POINTER_FROM_INT(icon_id), NULL);
761   if (icon) {
762     icon_free_data(icon_id, icon);
763     icon_free(icon);
764     return true;
765   }
766   else {
767     return false;
768   }
769 }
770
771 bool BKE_icon_delete_unmanaged(const int icon_id)
772 {
773   if (icon_id == 0) {
774     /* no icon defined for library object */
775     return false;
776   }
777
778   Icon *icon = BLI_ghash_popkey(gIcons, POINTER_FROM_INT(icon_id), NULL);
779   if (icon) {
780     if (UNLIKELY(icon->flag & ICON_FLAG_MANAGED)) {
781       BLI_ghash_insert(gIcons, POINTER_FROM_INT(icon_id), icon);
782       return false;
783     }
784     else {
785       icon_free_data(icon_id, icon);
786       icon_free(icon);
787       return true;
788     }
789   }
790   else {
791     return false;
792   }
793 }
794
795 /* -------------------------------------------------------------------- */
796 /** \name Geometry Icon
797  * \{ */
798
799 int BKE_icon_geom_ensure(struct Icon_Geom *geom)
800 {
801   BLI_assert(BLI_thread_is_main());
802
803   if (geom->icon_id) {
804     return geom->icon_id;
805   }
806
807   geom->icon_id = get_next_free_id();
808
809   icon_create(geom->icon_id, ICON_DATA_GEOM, geom);
810   /* Not managed for now, we may want this to be configurable per icon). */
811
812   return geom->icon_id;
813 }
814
815 struct Icon_Geom *BKE_icon_geom_from_memory(const uchar *data, size_t data_len)
816 {
817   BLI_assert(BLI_thread_is_main());
818   if (data_len <= 8) {
819     goto fail;
820   }
821   /* Skip the header. */
822   data_len -= 8;
823   const int div = 3 * 2 * 3;
824   const int coords_len = data_len / div;
825   if (coords_len * div != data_len) {
826     goto fail;
827   }
828
829   const uchar header[4] = {'V', 'C', 'O', 0};
830   const uchar *p = data;
831   if (memcmp(p, header, ARRAY_SIZE(header)) != 0) {
832     goto fail;
833   }
834   p += 4;
835
836   struct Icon_Geom *geom = MEM_mallocN(sizeof(*geom), __func__);
837   geom->coords_range[0] = (int)*p++;
838   geom->coords_range[1] = (int)*p++;
839   /* x, y ignored for now */
840   p += 2;
841
842   geom->coords_len = coords_len;
843   geom->coords = (const void *)p;
844   geom->colors = (const void *)(p + (data_len / 3));
845   geom->icon_id = 0;
846   geom->mem = data;
847   return geom;
848
849 fail:
850   MEM_freeN((void *)data);
851   return NULL;
852 }
853
854 struct Icon_Geom *BKE_icon_geom_from_file(const char *filename)
855 {
856   BLI_assert(BLI_thread_is_main());
857   size_t data_len;
858   uchar *data = BLI_file_read_binary_as_mem(filename, 0, &data_len);
859   if (data == NULL) {
860     return NULL;
861   }
862   return BKE_icon_geom_from_memory(data, data_len);
863 }
864
865 /** \} */
866
867 /** \name Studio Light Icon
868  * \{ */
869 int BKE_icon_ensure_studio_light(struct StudioLight *sl, int id_type)
870 {
871   int icon_id = get_next_free_id();
872   Icon *icon = icon_create(icon_id, ICON_DATA_STUDIOLIGHT, sl);
873   icon->id_type = id_type;
874   return icon_id;
875 }
876 /** \} */