Blender V5.3
interface_icons.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "DNA_ID_enums.h"
10#include "MEM_guardedalloc.h"
11
12#include "GPU_immediate.hh"
13#include "GPU_state.hh"
14
15#include "BLF_api.hh"
16
17#include "BLI_math_color_c.hh"
18#include "BLI_math_vector_c.hh"
19#include "BLI_string.hh"
20
21#include "BLT_translation.hh"
22
28#include "DNA_screen_types.h"
29#include "DNA_sequence_types.h"
30
31#include "RNA_access.hh"
32#include "RNA_prototypes.hh"
33
34#include "BKE_context.hh"
35#include "BKE_global.hh"
36#include "BKE_icons.hh"
37#include "BKE_paint.hh"
38#include "BKE_preview_image.hh"
39#include "BKE_studiolight.h"
40
41#include "IMB_imbuf.hh"
42#include "IMB_thumbs.hh"
43
44#include "BIF_glutil.hh"
45
46#include "ED_keyframes_draw.hh"
48#include "ED_node.hh"
49#include "ED_render.hh"
50
51#include "UI_interface_icons.hh"
52
53#include "WM_api.hh"
54
55#include "CLG_log.h"
56
57#include "interface_intern.hh"
58
59#include <fmt/format.h>
60
61namespace blender::ui {
62
63static CLG_LogRef LOG = {"ui.icon"};
64
65struct IconImage {
66 int w;
67 int h;
71};
72
74 void (*)(float x, float y, float w, float h, float alpha, const uchar mono_rgba[4]);
75
76#define ICON_TYPE_PREVIEW 0
77#define ICON_TYPE_SVG_COLOR 1
78#define ICON_TYPE_SVG_MONO 2
79#define ICON_TYPE_BUFFER 3
80#define ICON_TYPE_IMBUF 4
81#define ICON_TYPE_VECTOR 5
82#define ICON_TYPE_GEOM 6
83#define ICON_TYPE_EVENT 7 /* draw keymap entries using custom renderer. */
84#define ICON_TYPE_GPLAYER 8
85#define ICON_TYPE_BLANK 9
86
87struct DrawInfo {
88 int type;
89
90 union {
91 /* type specific data */
92 struct {
94 } vector;
95 struct {
97 bool inverted;
98 } geom;
99 struct {
101 } buffer;
102 struct {
103 int theme_color;
104 } texture;
105 struct {
106 /* Can be packed into a single int. */
107 short event_type;
108 short event_value;
109 int icon;
110 /* Allow lookups. */
111 DrawInfo *next;
112 } input;
114};
115
116struct IconType {
117 int type;
119};
120
121#ifndef WITH_HEADLESS
122
123static const IconType icontypes[] = {
124# define DEF_ICON(name) {ICON_TYPE_SVG_MONO, 0},
125# define DEF_ICON_COLOR(name) {ICON_TYPE_SVG_COLOR, 0},
126# define DEF_ICON_SCENE(name) {ICON_TYPE_SVG_MONO, TH_ICON_SCENE},
127# define DEF_ICON_COLLECTION(name) {ICON_TYPE_SVG_MONO, TH_ICON_COLLECTION},
128# define DEF_ICON_OBJECT(name) {ICON_TYPE_SVG_MONO, TH_ICON_OBJECT},
129# define DEF_ICON_OBJECT_DATA(name) {ICON_TYPE_SVG_MONO, TH_ICON_OBJECT_DATA},
130# define DEF_ICON_MODIFIER(name) {ICON_TYPE_SVG_MONO, TH_ICON_MODIFIER},
131# define DEF_ICON_SHADING(name) {ICON_TYPE_SVG_MONO, TH_ICON_SHADING},
132# define DEF_ICON_FOLDER(name) {ICON_TYPE_SVG_MONO, TH_ICON_FOLDER},
133# define DEF_ICON_FUND(name) {ICON_TYPE_SVG_MONO, TH_ICON_FUND},
134# define DEF_ICON_VECTOR(name) {ICON_TYPE_VECTOR, 0},
135# define DEF_ICON_BLANK(name) {ICON_TYPE_BLANK, 0},
136# include "UI_icons.hh"
137};
138
139/* **************************************************** */
140
142 ImBuf *bbuf, int icon_id, int xofs, int yofs, int size, int type, int theme_color)
143{
144 Icon *new_icon = MEM_new_zeroed<Icon>(__func__);
145
146 new_icon->obj = nullptr; /* icon is not for library object */
147 new_icon->id_type = 0;
148
149 DrawInfo *di = MEM_new_zeroed<DrawInfo>(__func__);
150 di->type = type;
151
152 if (type == ICON_TYPE_SVG_MONO) {
153 di->data.texture.theme_color = theme_color;
154 }
155 else if (type == ICON_TYPE_BUFFER) {
156 IconImage *iimg = MEM_new_zeroed<IconImage>(__func__);
157 iimg->w = size;
158 iimg->h = size;
159
160 /* icon buffers can get initialized runtime now, via datatoc */
161 if (bbuf) {
162 int y, imgsize;
163
164 iimg->rect = MEM_new_array_uninitialized<uint8_t>(size * size * sizeof(uint), __func__);
165
166 /* Here we store the rect in the icon - same as before */
167 if (size == bbuf->x && size == bbuf->y && xofs == 0 && yofs == 0) {
168 memcpy(iimg->rect, bbuf->byte_data(), size * size * 4 * sizeof(uint8_t));
169 }
170 else {
171 /* this code assumes square images */
172 imgsize = bbuf->x;
173 const uchar *data = bbuf->byte_data();
174 for (y = 0; y < size; y++) {
175 memcpy(&iimg->rect[y * size],
176 &data[(y + yofs) * imgsize + xofs],
177 size * 4 * sizeof(uint8_t));
178 }
179 }
180 }
181 di->data.buffer.image = iimg;
182 }
183
185 new_icon->drawinfo = di;
186
187 BKE_icon_set(icon_id, new_icon);
188
189 return di;
190}
191
192static void def_internal_vicon(int icon_id, VectorDrawFunc drawFunc)
193{
194 Icon *new_icon = MEM_new_zeroed<Icon>("texicon");
195
196 new_icon->obj = nullptr; /* icon is not for library object */
197 new_icon->id_type = 0;
198
199 DrawInfo *di = MEM_new_zeroed<DrawInfo>("drawinfo");
201 di->data.vector.func = drawFunc;
202
203 new_icon->drawinfo_free = nullptr;
204 new_icon->drawinfo = di;
205
206 BKE_icon_set(icon_id, new_icon);
207}
208
209/* Vector Icon Drawing Routines */
210
212 float x, float y, float w, float h, const float color[4], float bg_alpha)
213{
214 rctf rect = {x, x + w, y, y + h};
215 const float color_bg[4] = {color[0], color[1], color[2], bg_alpha};
217 draw_roundbox_4fv_ex(&rect, color_bg, nullptr, 1.0f, color, U.pixelsize, 2.0f * UI_SCALE_FAC);
218}
219
221 float x, float y, float w, float h, const char *str, const uchar mono_rgba[4])
222{
223 const int font_id = BLF_default();
224 const size_t len = strlen(str);
225 BLF_size(font_id, (h - 3 * UI_SCALE_FAC));
226 float width, height;
227 BLF_width_and_height(font_id, str, len, &width, &height);
228 const float pos_x = x + (w - width) / 2.0f;
229 const float pos_y = y + (h - height) / 2.0f;
230 BLF_position(font_id, pos_x, pos_y, 0);
231 BLF_color4ubv(font_id, mono_rgba);
232 BLF_draw(font_id, str, len);
233}
234
236 float x, float y, float w, float h, float alpha, const uchar mono_rgba[4])
237{
238 const float color[4] = {0.5f, 0.0f, 0.0f, 1.0f * alpha};
239 vicon_rgb_color_draw(x, y, w, h, color, 0.25f * alpha);
240 const char *text = CTX_IFACE_(BLT_I18NCONTEXT_COLOR, "R");
241 vicon_rgb_text_draw(x, y, w, h, text, mono_rgba);
242}
243
245 float x, float y, float w, float h, float alpha, const uchar mono_rgba[4])
246{
247 const float color[4] = {0.0f, 0.4f, 0.0f, 1.0f * alpha};
248 vicon_rgb_color_draw(x, y, w, h, color, 0.2f * alpha);
249 const char *text = CTX_IFACE_(BLT_I18NCONTEXT_COLOR, "G");
250 vicon_rgb_text_draw(x, y, w, h, text, mono_rgba);
251}
252
254 float x, float y, float w, float h, float alpha, const uchar mono_rgba[4])
255{
256 const float color[4] = {0.0f, 0.0f, 1.0f, 1.0f * alpha};
257 vicon_rgb_color_draw(x, y, w, h, color, 0.3f * alpha);
258 const char *text = CTX_IFACE_(BLT_I18NCONTEXT_COLOR, "B");
259 vicon_rgb_text_draw(x, y, w, h, text, mono_rgba);
260}
261
262/* Utilities */
263
264static void vicon_keytype_draw_wrapper(const float x,
265 const float y,
266 const float w,
267 const float h,
268 const float alpha,
269 const eBezTriple_KeyframeType key_type,
270 const short handle_type)
271{
272 /* Initialize dummy theme state for Action Editor - where these colors are defined
273 * (since we're doing this off-screen, free from any particular space_id). */
274 theme::bThemeState theme_state;
275
276 theme::theme_store(&theme_state);
278
279 /* The "x" and "y" given are the bottom-left coordinates of the icon,
280 * while the #draw_keyframe_shape() function needs the midpoint for the keyframe. */
281 const float xco = x + (w / 2.0f);
282 const float yco = y + (h / 2.0f);
283
284 GPUVertFormat *format = immVertexFormat();
285 KeyframeShaderBindings sh_bindings;
286 sh_bindings.pos_id = GPU_vertformat_attr_add(format, "pos", gpu::VertAttrType::SFLOAT_32_32);
287 sh_bindings.size_id = GPU_vertformat_attr_add(format, "size", gpu::VertAttrType::SFLOAT_32);
288 sh_bindings.color_id = GPU_vertformat_attr_add(
289 format, "color", gpu::VertAttrType::UNORM_8_8_8_8);
291 format, "outlineColor", gpu::VertAttrType::UNORM_8_8_8_8);
292 sh_bindings.flags_id = GPU_vertformat_attr_add(format, "flags", gpu::VertAttrType::UINT_32);
293
296 immUniform1f("outline_scale", 1.0f);
297 immUniform2f("ViewportSize", -1.0f, -1.0f);
299
300 /* draw keyframe
301 * - size: (default icon size == 16, default dope-sheet icon size == 10)
302 * - sel: true unless in handle-type icons
303 * (so that "keyframe" state shows the iconic yellow icon).
304 */
305 const bool sel = (handle_type == KEYFRAME_HANDLE_NONE);
306
308 yco,
309 (10.0f / 16.0f) * h,
310 sel,
311 key_type,
313 alpha,
314 &sh_bindings,
315 handle_type,
317
318 immEnd();
321
322 theme::theme_restore(&theme_state);
323}
324
326 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
327{
329}
330
332 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
333{
335}
336
338 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
339{
341}
342
344 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
345{
347}
348
350 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
351{
353}
354
356 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
357{
359}
360
362 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
363{
365}
366
368 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
369{
371}
372
374 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
375{
377}
378
380 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
381{
383}
384
386 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/)
387{
389}
390
392 int socket_type, float x, float y, float w, float h, float /*alpha*/)
393{
394 /* Factor to account for the draw function of the node socket being based on the widget unit,
395 * which is 10 pixels by default, which differs from icons. */
396 constexpr float size_factor = 10.0f / float(ICON_DEFAULT_WIDTH);
397
398 const float socket_radius = w * 0.5f * size_factor;
399 const float2 center = {x + 0.5f * w, y + 0.5f * h};
400 const rctf rect = {
401 center.x - socket_radius,
402 center.x + socket_radius,
403 center.y - socket_radius,
404 center.y + socket_radius,
405 };
406
407 float color_inner[4];
408 ed::space_node::std_node_socket_colors_get(socket_type, color_inner);
409
410 float color_outer[4] = {0};
412 color_outer[3] = 1.0f;
413
415 &rect, color_inner, color_outer, U.pixelsize, SOCK_DISPLAY_SHAPE_CIRCLE, 1.0f);
416}
417
418static void vicon_colorset_draw(int index, int x, int y, int w, int h, float /*alpha*/)
419{
420 const bTheme *btheme = theme::theme_get();
421 const ThemeWireColor *cs = &btheme->tarm[index];
422
423 /* Draw three bands of color: One per color
424 * x-----a-----b-----c
425 * | N | S | A |
426 * x-----a-----b-----c
427 */
428 const int a = x + w / 3;
429 const int b = x + w / 3 * 2;
430 const int c = x + w;
431
432 uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", gpu::VertAttrType::SFLOAT_32_32);
434
435 /* XXX: Include alpha into this... */
436 /* normal */
438 immRectf(pos, x, y, a, y + h);
439
440 /* selected */
442 immRectf(pos, a, y, b, y + h);
443
444 /* active */
446 immRectf(pos, b, y, c, y + h);
447
449}
450
451# define DEF_ICON_VECTOR_COLORSET_DRAW_NTH(prefix, index) \
452 static void vicon_colorset_draw_##prefix( \
453 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/) \
454 { \
455 vicon_colorset_draw(index, int(x), int(y), int(w), int(h), alpha); \
456 }
457
478
479# undef DEF_ICON_VECTOR_COLORSET_DRAW_NTH
480
482 short color_tag, float x, float y, float w, float /*h*/, float /*alpha*/)
483{
484 const bTheme *btheme = theme::theme_get();
485 const ThemeStripColor *strip_color = &btheme->strip_color[color_tag];
486
487 const float aspect = float(ICON_DEFAULT_WIDTH) / w;
488
490 y,
491 ICON_SNAP_FACE,
492 aspect,
493 1.0f,
494 0.0f,
495 strip_color->color,
496 btheme->tui.icon_border_intensity > 0.0f,
498}
499
500# define DEF_ICON_STRIP_COLOR_DRAW(index, color) \
501 static void vicon_strip_color_draw_##index( \
502 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/) \
503 { \
504 vicon_strip_color_draw(color, x, y, w, h, alpha); \
505 }
506
516
517# undef DEF_ICON_STRIP_COLOR_DRAW
518
519# define ICON_INDIRECT_DATA_ALPHA 0.6f
520
522 float x, float y, float w, float /*h*/, float alpha, const uchar * /*mono_rgba[4]*/)
523{
524 const float aspect = float(ICON_DEFAULT_WIDTH) / w;
525
527 y,
528 ICON_LIBRARY_DATA_DIRECT,
529 aspect,
531 0.0f,
532 nullptr,
533 false,
535}
536
538 float x, float y, float w, float /*h*/, float alpha, const uchar * /*mono_rgba[4]*/)
539{
540 const float aspect = float(ICON_DEFAULT_WIDTH) / w;
541
543 y,
544 ICON_PACKAGE,
545 aspect,
547 0.0f,
548 nullptr,
549 false,
551}
552
554 float x, float y, float w, float /*h*/, float alpha, const uchar * /*mono_rgba[4]*/)
555{
556 const float aspect = float(ICON_DEFAULT_WIDTH) / w;
557
559 y,
560 ICON_LIBRARY_DATA_OVERRIDE,
561 aspect,
562 ICON_INDIRECT_DATA_ALPHA * alpha * 0.75f,
563 0.0f,
564 nullptr,
565 false,
567}
568
570 short color_tag, float x, float y, float w, float /*h*/, float /*alpha*/)
571{
572 const bTheme *btheme = theme::theme_get();
573 const ThemeCollectionColor *layergroup_color = &btheme->collection_color[color_tag];
574
575 const float aspect = float(ICON_DEFAULT_WIDTH) / w;
576
578 y,
579 ICON_GREASEPENCIL_LAYER_GROUP,
580 aspect,
581 1.0f,
582 0.0f,
583 layergroup_color->color,
584 btheme->tui.icon_border_intensity > 0.0f,
586}
587
588# define DEF_ICON_LAYERGROUP_COLOR_DRAW(index, color) \
589 static void vicon_layergroup_color_draw_##index( \
590 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/) \
591 { \
592 vicon_layergroup_color_draw(color, x, y, w, h, alpha); \
593 }
594
603
604# undef DEF_ICON_LAYERGROUP_COLOR_DRAW
605
606# define DEF_ICON_NODE_SOCKET_DRAW(name, socket_type) \
607 static void icon_node_socket_draw_##name( \
608 float x, float y, float w, float h, float alpha, const uchar * /*mono_rgba[4]*/) \
609 { \
610 icon_node_socket_draw(socket_type, x, y, w, h, alpha); \
611 }
612
637
638/* Dynamically render icon instead of rendering a plain color to a texture/buffer
639 * This is not strictly a "vicon", as it needs access to icon->obj to get the color info,
640 * but it works in a very similar way.
641 */
642static void vicon_gplayer_color_draw(Icon *icon, int x, int y, int w, int h)
643{
644 bGPDlayer *gpl = static_cast<bGPDlayer *>(icon->obj);
645
646 /* Just draw a colored rect - Like for vicon_colorset_draw() */
647 /* TODO: Make this have rounded corners, and maybe be a bit smaller.
648 * However, draw_roundbox_aa() draws the colors too dark, so can't be used.
649 */
650 uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", gpu::VertAttrType::SFLOAT_32_32);
652
654 immRectf(pos, x, y, x + w - 1, y + h - 1);
655
657}
658
659static DrawInfo *g_di_event_list = nullptr;
660
661int icon_from_event_type(short event_type, short event_value)
662{
663 if (event_type == EVT_RIGHTSHIFTKEY) {
664 event_type = EVT_LEFTSHIFTKEY;
665 }
666 else if (event_type == EVT_RIGHTCTRLKEY) {
667 event_type = EVT_LEFTCTRLKEY;
668 }
669 else if (event_type == EVT_RIGHTALTKEY) {
670 event_type = EVT_LEFTALTKEY;
671 }
672
674 do {
675 if (di->data.input.event_type == event_type) {
676 return di->data.input.icon;
677 }
678 } while ((di = di->data.input.next));
679
680 if (event_type == LEFTMOUSE) {
681 if (event_value == KM_DBL_CLICK) {
682 return ICON_MOUSE_LMB_2X;
683 }
684 return (event_value == KM_PRESS_DRAG) ? ICON_MOUSE_LMB_DRAG : ICON_MOUSE_LMB;
685 }
686 if (event_type == MIDDLEMOUSE) {
687 return (event_value == KM_PRESS_DRAG) ? ICON_MOUSE_MMB_DRAG : ICON_MOUSE_MMB;
688 }
689 if (event_type == RIGHTMOUSE) {
690 return (event_value == KM_PRESS_DRAG) ? ICON_MOUSE_MMB_DRAG : ICON_MOUSE_RMB;
691 }
692
693 return ICON_NONE;
694}
695
696int icon_from_keymap_item(const wmKeyMapItem *kmi, int r_icon_mod[KM_MOD_NUM])
697{
698 if (r_icon_mod) {
699 memset(r_icon_mod, 0x0, sizeof(int[KM_MOD_NUM]));
700 int i = 0;
701 if (kmi->ctrl == KM_MOD_HELD) {
702 r_icon_mod[i++] = ICON_EVENT_CTRL;
703 }
704 if (kmi->alt == KM_MOD_HELD) {
705 r_icon_mod[i++] = ICON_EVENT_ALT;
706 }
707 if (kmi->shift == KM_MOD_HELD) {
708 r_icon_mod[i++] = ICON_EVENT_SHIFT;
709 }
710 if (kmi->oskey == KM_MOD_HELD) {
711 r_icon_mod[i++] = ICON_EVENT_OS;
712 }
713 if (!ELEM(kmi->hyper, KM_NOTHING, KM_ANY)) {
714 r_icon_mod[i++] = ICON_EVENT_HYPER;
715 }
716 }
717 return icon_from_event_type(kmi->type, kmi->val);
718}
719
720static void init_event_icons()
721{
722 DrawInfo *di_next = nullptr;
723
724# define INIT_EVENT_ICON(icon_id, type, value) \
725 { \
726 DrawInfo *di = def_internal_icon(nullptr, icon_id, 0, 0, w, ICON_TYPE_EVENT, 0); \
727 di->data.input.event_type = type; \
728 di->data.input.event_value = value; \
729 di->data.input.icon = icon_id; \
730 di->data.input.next = di_next; \
731 di_next = di; \
732 } \
733 ((void)0)
734 /* end INIT_EVENT_ICON */
735
736 const int w = 16; /* DUMMY */
737
738 INIT_EVENT_ICON(ICON_EVENT_A, EVT_AKEY, KM_ANY);
739 INIT_EVENT_ICON(ICON_EVENT_B, EVT_BKEY, KM_ANY);
740 INIT_EVENT_ICON(ICON_EVENT_C, EVT_CKEY, KM_ANY);
741 INIT_EVENT_ICON(ICON_EVENT_D, EVT_DKEY, KM_ANY);
742 INIT_EVENT_ICON(ICON_EVENT_E, EVT_EKEY, KM_ANY);
743 INIT_EVENT_ICON(ICON_EVENT_F, EVT_FKEY, KM_ANY);
744 INIT_EVENT_ICON(ICON_EVENT_G, EVT_GKEY, KM_ANY);
745 INIT_EVENT_ICON(ICON_EVENT_H, EVT_HKEY, KM_ANY);
746 INIT_EVENT_ICON(ICON_EVENT_I, EVT_IKEY, KM_ANY);
747 INIT_EVENT_ICON(ICON_EVENT_J, EVT_JKEY, KM_ANY);
748 INIT_EVENT_ICON(ICON_EVENT_K, EVT_KKEY, KM_ANY);
749 INIT_EVENT_ICON(ICON_EVENT_L, EVT_LKEY, KM_ANY);
750 INIT_EVENT_ICON(ICON_EVENT_M, EVT_MKEY, KM_ANY);
751 INIT_EVENT_ICON(ICON_EVENT_N, EVT_NKEY, KM_ANY);
752 INIT_EVENT_ICON(ICON_EVENT_O, EVT_OKEY, KM_ANY);
753 INIT_EVENT_ICON(ICON_EVENT_P, EVT_PKEY, KM_ANY);
754 INIT_EVENT_ICON(ICON_EVENT_Q, EVT_QKEY, KM_ANY);
755 INIT_EVENT_ICON(ICON_EVENT_R, EVT_RKEY, KM_ANY);
756 INIT_EVENT_ICON(ICON_EVENT_S, EVT_SKEY, KM_ANY);
757 INIT_EVENT_ICON(ICON_EVENT_T, EVT_TKEY, KM_ANY);
758 INIT_EVENT_ICON(ICON_EVENT_U, EVT_UKEY, KM_ANY);
759 INIT_EVENT_ICON(ICON_EVENT_V, EVT_VKEY, KM_ANY);
760 INIT_EVENT_ICON(ICON_EVENT_W, EVT_WKEY, KM_ANY);
761 INIT_EVENT_ICON(ICON_EVENT_X, EVT_XKEY, KM_ANY);
762 INIT_EVENT_ICON(ICON_EVENT_Y, EVT_YKEY, KM_ANY);
763 INIT_EVENT_ICON(ICON_EVENT_Z, EVT_ZKEY, KM_ANY);
764 INIT_EVENT_ICON(ICON_EVENT_SHIFT, EVT_LEFTSHIFTKEY, KM_ANY);
765 INIT_EVENT_ICON(ICON_EVENT_CTRL, EVT_LEFTCTRLKEY, KM_ANY);
766 INIT_EVENT_ICON(ICON_EVENT_ALT, EVT_LEFTALTKEY, KM_ANY);
767 INIT_EVENT_ICON(ICON_EVENT_OS, EVT_OSKEY, KM_ANY);
768 INIT_EVENT_ICON(ICON_EVENT_HYPER, EVT_HYPER, KM_ANY);
769 INIT_EVENT_ICON(ICON_EVENT_F1, EVT_F1KEY, KM_ANY);
770 INIT_EVENT_ICON(ICON_EVENT_F2, EVT_F2KEY, KM_ANY);
771 INIT_EVENT_ICON(ICON_EVENT_F3, EVT_F3KEY, KM_ANY);
772 INIT_EVENT_ICON(ICON_EVENT_F4, EVT_F4KEY, KM_ANY);
773 INIT_EVENT_ICON(ICON_EVENT_F5, EVT_F5KEY, KM_ANY);
774 INIT_EVENT_ICON(ICON_EVENT_F6, EVT_F6KEY, KM_ANY);
775 INIT_EVENT_ICON(ICON_EVENT_F7, EVT_F7KEY, KM_ANY);
776 INIT_EVENT_ICON(ICON_EVENT_F8, EVT_F8KEY, KM_ANY);
777 INIT_EVENT_ICON(ICON_EVENT_F9, EVT_F9KEY, KM_ANY);
778 INIT_EVENT_ICON(ICON_EVENT_F10, EVT_F10KEY, KM_ANY);
779 INIT_EVENT_ICON(ICON_EVENT_F11, EVT_F11KEY, KM_ANY);
780 INIT_EVENT_ICON(ICON_EVENT_F12, EVT_F12KEY, KM_ANY);
781 INIT_EVENT_ICON(ICON_EVENT_ESC, EVT_ESCKEY, KM_ANY);
782 INIT_EVENT_ICON(ICON_EVENT_TAB, EVT_TABKEY, KM_ANY);
783 INIT_EVENT_ICON(ICON_EVENT_PAGEUP, EVT_PAGEUPKEY, KM_ANY);
784 INIT_EVENT_ICON(ICON_EVENT_PAGEDOWN, EVT_PAGEDOWNKEY, KM_ANY);
785 INIT_EVENT_ICON(ICON_EVENT_RETURN, EVT_RETKEY, KM_ANY);
786 INIT_EVENT_ICON(ICON_EVENT_SPACEKEY, EVT_SPACEKEY, KM_ANY);
787
788 INIT_EVENT_ICON(ICON_EVENT_ZEROKEY, EVT_ZEROKEY, KM_ANY);
789 INIT_EVENT_ICON(ICON_EVENT_ONEKEY, EVT_ONEKEY, KM_ANY);
790 INIT_EVENT_ICON(ICON_EVENT_TWOKEY, EVT_TWOKEY, KM_ANY);
791 INIT_EVENT_ICON(ICON_EVENT_THREEKEY, EVT_THREEKEY, KM_ANY);
792 INIT_EVENT_ICON(ICON_EVENT_FOURKEY, EVT_FOURKEY, KM_ANY);
793 INIT_EVENT_ICON(ICON_EVENT_FIVEKEY, EVT_FIVEKEY, KM_ANY);
794 INIT_EVENT_ICON(ICON_EVENT_SIXKEY, EVT_SIXKEY, KM_ANY);
795 INIT_EVENT_ICON(ICON_EVENT_SEVENKEY, EVT_SEVENKEY, KM_ANY);
796 INIT_EVENT_ICON(ICON_EVENT_EIGHTKEY, EVT_EIGHTKEY, KM_ANY);
797 INIT_EVENT_ICON(ICON_EVENT_NINEKEY, EVT_NINEKEY, KM_ANY);
798
799 INIT_EVENT_ICON(ICON_EVENT_PAD0, EVT_PAD0, KM_ANY);
800 INIT_EVENT_ICON(ICON_EVENT_PAD1, EVT_PAD1, KM_ANY);
801 INIT_EVENT_ICON(ICON_EVENT_PAD2, EVT_PAD2, KM_ANY);
802 INIT_EVENT_ICON(ICON_EVENT_PAD3, EVT_PAD3, KM_ANY);
803 INIT_EVENT_ICON(ICON_EVENT_PAD4, EVT_PAD4, KM_ANY);
804 INIT_EVENT_ICON(ICON_EVENT_PAD5, EVT_PAD5, KM_ANY);
805 INIT_EVENT_ICON(ICON_EVENT_PAD6, EVT_PAD6, KM_ANY);
806 INIT_EVENT_ICON(ICON_EVENT_PAD7, EVT_PAD7, KM_ANY);
807 INIT_EVENT_ICON(ICON_EVENT_PAD8, EVT_PAD8, KM_ANY);
808 INIT_EVENT_ICON(ICON_EVENT_PAD9, EVT_PAD9, KM_ANY);
809 INIT_EVENT_ICON(ICON_EVENT_PADASTER, EVT_PADASTERKEY, KM_ANY);
810 INIT_EVENT_ICON(ICON_EVENT_PADSLASH, EVT_PADSLASHKEY, KM_ANY);
811 INIT_EVENT_ICON(ICON_EVENT_PADMINUS, EVT_PADMINUS, KM_ANY);
812 INIT_EVENT_ICON(ICON_EVENT_PADENTER, EVT_PADENTER, KM_ANY);
813 INIT_EVENT_ICON(ICON_EVENT_PADPLUS, EVT_PADPLUSKEY, KM_ANY);
814 INIT_EVENT_ICON(ICON_EVENT_PADPERIOD, EVT_PADPERIOD, KM_ANY);
815
816 INIT_EVENT_ICON(ICON_EVENT_MOUSE_4, BUTTON4MOUSE, KM_ANY);
817 INIT_EVENT_ICON(ICON_EVENT_MOUSE_5, BUTTON5MOUSE, KM_ANY);
818 INIT_EVENT_ICON(ICON_EVENT_MOUSE_6, BUTTON6MOUSE, KM_ANY);
819 INIT_EVENT_ICON(ICON_EVENT_MOUSE_7, BUTTON7MOUSE, KM_ANY);
820 INIT_EVENT_ICON(ICON_EVENT_TABLET_STYLUS, TABLET_STYLUS, KM_ANY);
821 INIT_EVENT_ICON(ICON_EVENT_TABLET_ERASER, TABLET_ERASER, KM_ANY);
822 INIT_EVENT_ICON(ICON_EVENT_LEFT_ARROW, EVT_LEFTARROWKEY, KM_ANY);
823 INIT_EVENT_ICON(ICON_EVENT_DOWN_ARROW, EVT_DOWNARROWKEY, KM_ANY);
824 INIT_EVENT_ICON(ICON_EVENT_RIGHT_ARROW, EVT_RIGHTARROWKEY, KM_ANY);
825 INIT_EVENT_ICON(ICON_EVENT_UP_ARROW, EVT_UPARROWKEY, KM_ANY);
826 INIT_EVENT_ICON(ICON_EVENT_PAUSE, EVT_PAUSEKEY, KM_ANY);
827 INIT_EVENT_ICON(ICON_EVENT_INSERT, EVT_INSERTKEY, KM_ANY);
828 INIT_EVENT_ICON(ICON_EVENT_HOME, EVT_HOMEKEY, KM_ANY);
829 INIT_EVENT_ICON(ICON_EVENT_END, EVT_ENDKEY, KM_ANY);
830 INIT_EVENT_ICON(ICON_EVENT_UNKNOWN, EVT_UNKNOWNKEY, KM_ANY);
831 INIT_EVENT_ICON(ICON_EVENT_GRLESS, EVT_GRLESSKEY, KM_ANY);
832 INIT_EVENT_ICON(ICON_EVENT_MEDIAPLAY, EVT_MEDIAPLAY, KM_ANY);
833 INIT_EVENT_ICON(ICON_EVENT_MEDIASTOP, EVT_MEDIASTOP, KM_ANY);
834 INIT_EVENT_ICON(ICON_EVENT_MEDIAFIRST, EVT_MEDIAFIRST, KM_ANY);
835 INIT_EVENT_ICON(ICON_EVENT_MEDIALAST, EVT_MEDIALAST, KM_ANY);
836 INIT_EVENT_ICON(ICON_EVENT_APP, EVT_APPKEY, KM_ANY);
837 INIT_EVENT_ICON(ICON_EVENT_CAPSLOCK, EVT_CAPSLOCKKEY, KM_ANY);
838 INIT_EVENT_ICON(ICON_EVENT_BACKSPACE, EVT_BACKSPACEKEY, KM_ANY);
839 INIT_EVENT_ICON(ICON_EVENT_DEL, EVT_DELKEY, KM_ANY);
840 INIT_EVENT_ICON(ICON_EVENT_SEMICOLON, EVT_SEMICOLONKEY, KM_ANY);
841 INIT_EVENT_ICON(ICON_EVENT_PERIOD, EVT_PERIODKEY, KM_ANY);
842 INIT_EVENT_ICON(ICON_EVENT_COMMA, EVT_COMMAKEY, KM_ANY);
843 INIT_EVENT_ICON(ICON_EVENT_QUOTE, EVT_QUOTEKEY, KM_ANY);
844 INIT_EVENT_ICON(ICON_EVENT_ACCENTGRAVE, EVT_ACCENTGRAVEKEY, KM_ANY);
845 INIT_EVENT_ICON(ICON_EVENT_MINUS, EVT_MINUSKEY, KM_ANY);
846 INIT_EVENT_ICON(ICON_EVENT_PLUS, EVT_PLUSKEY, KM_ANY);
847 INIT_EVENT_ICON(ICON_EVENT_SLASH, EVT_SLASHKEY, KM_ANY);
848 INIT_EVENT_ICON(ICON_EVENT_BACKSLASH, EVT_BACKSLASHKEY, KM_ANY);
849 INIT_EVENT_ICON(ICON_EVENT_EQUAL, EVT_EQUALKEY, KM_ANY);
850 INIT_EVENT_ICON(ICON_EVENT_LEFTBRACKET, EVT_LEFTBRACKETKEY, KM_ANY);
851 INIT_EVENT_ICON(ICON_EVENT_RIGHTBRACKET, EVT_RIGHTBRACKETKEY, KM_ANY);
852
853 INIT_EVENT_ICON(ICON_EVENT_PAD_PAN, MOUSEPAN, KM_ANY);
854 INIT_EVENT_ICON(ICON_EVENT_PAD_ROTATE, MOUSEROTATE, KM_ANY);
855 INIT_EVENT_ICON(ICON_EVENT_PAD_ZOOM, MOUSEZOOM, KM_ANY);
856
857 INIT_EVENT_ICON(ICON_EVENT_F13, EVT_F13KEY, KM_ANY);
858 INIT_EVENT_ICON(ICON_EVENT_F14, EVT_F14KEY, KM_ANY);
859 INIT_EVENT_ICON(ICON_EVENT_F15, EVT_F15KEY, KM_ANY);
860 INIT_EVENT_ICON(ICON_EVENT_F16, EVT_F16KEY, KM_ANY);
861 INIT_EVENT_ICON(ICON_EVENT_F17, EVT_F17KEY, KM_ANY);
862 INIT_EVENT_ICON(ICON_EVENT_F18, EVT_F18KEY, KM_ANY);
863 INIT_EVENT_ICON(ICON_EVENT_F19, EVT_F19KEY, KM_ANY);
864 INIT_EVENT_ICON(ICON_EVENT_F20, EVT_F20KEY, KM_ANY);
865 INIT_EVENT_ICON(ICON_EVENT_F21, EVT_F21KEY, KM_ANY);
866 INIT_EVENT_ICON(ICON_EVENT_F22, EVT_F22KEY, KM_ANY);
867 INIT_EVENT_ICON(ICON_EVENT_F23, EVT_F23KEY, KM_ANY);
868 INIT_EVENT_ICON(ICON_EVENT_F24, EVT_F24KEY, KM_ANY);
869
870 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_V1, NDOF_BUTTON_V1, KM_ANY);
871 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_V2, NDOF_BUTTON_V2, KM_ANY);
872 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_V3, NDOF_BUTTON_V3, KM_ANY);
873 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_SAVE_V1, NDOF_BUTTON_SAVE_V1, KM_ANY);
874 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_SAVE_V2, NDOF_BUTTON_SAVE_V2, KM_ANY);
875 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_SAVE_V3, NDOF_BUTTON_SAVE_V3, KM_ANY);
876 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_1, NDOF_BUTTON_1, KM_ANY);
877 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_2, NDOF_BUTTON_2, KM_ANY);
878 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_3, NDOF_BUTTON_3, KM_ANY);
879 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_4, NDOF_BUTTON_4, KM_ANY);
880 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_5, NDOF_BUTTON_5, KM_ANY);
881 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_6, NDOF_BUTTON_6, KM_ANY);
882 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_7, NDOF_BUTTON_7, KM_ANY);
883 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_8, NDOF_BUTTON_8, KM_ANY);
884 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_9, NDOF_BUTTON_9, KM_ANY);
885 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_10, NDOF_BUTTON_10, KM_ANY);
886 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_11, NDOF_BUTTON_11, KM_ANY);
887 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_12, NDOF_BUTTON_12, KM_ANY);
888 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_MENU, NDOF_BUTTON_MENU, KM_ANY);
889 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_FIT, NDOF_BUTTON_FIT, KM_ANY);
890 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_TOP, NDOF_BUTTON_TOP, KM_ANY);
891 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_BOTTOM, NDOF_BUTTON_BOTTOM, KM_ANY);
892 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_LEFT, NDOF_BUTTON_LEFT, KM_ANY);
893 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_RIGHT, NDOF_BUTTON_RIGHT, KM_ANY);
894 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_FRONT, NDOF_BUTTON_FRONT, KM_ANY);
895 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_BACK, NDOF_BUTTON_BACK, KM_ANY);
896 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_ISO1, NDOF_BUTTON_ISO1, KM_ANY);
897 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_ISO2, NDOF_BUTTON_ISO2, KM_ANY);
898 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_ROLL_CW, NDOF_BUTTON_ROLL_CW, KM_ANY);
899 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_ROLL_CCW, NDOF_BUTTON_ROLL_CCW, KM_ANY);
900 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_SPIN_CW, NDOF_BUTTON_SPIN_CW, KM_ANY);
901 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_SPIN_CCW, NDOF_BUTTON_SPIN_CCW, KM_ANY);
902 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_TILT_CW, NDOF_BUTTON_TILT_CW, KM_ANY);
903 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_TILT_CCW, NDOF_BUTTON_TILT_CCW, KM_ANY);
904 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_ROTATE, NDOF_BUTTON_ROTATE, KM_ANY);
905 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_PANZOOM, NDOF_BUTTON_PANZOOM, KM_ANY);
906 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_DOMINANT, NDOF_BUTTON_DOMINANT, KM_ANY);
907 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_PLUS, NDOF_BUTTON_PLUS, KM_ANY);
908 INIT_EVENT_ICON(ICON_EVENT_NDOF_BUTTON_MINUS, NDOF_BUTTON_MINUS, KM_ANY);
909
910 g_di_event_list = di_next;
911
912# undef INIT_EVENT_ICON
913}
914
916{
917 /* if it has own rect, things are all OK */
918 if (iimg->rect) {
919 return;
920 }
921
922 if (iimg->datatoc_rect) {
924 iimg->datatoc_rect, iimg->datatoc_size, ImBufFlags::ByteData, "<matcap icon>");
925 /* w and h were set on initialize */
926 if (bbuf->x != iimg->h && bbuf->y != iimg->w) {
927 IMB_scale(bbuf, iimg->w, iimg->h, IMBScaleFilter::Box, false);
928 }
929
930 const size_t size_in_bytes = size_t(bbuf->x) * size_t(bbuf->y) * sizeof(uint);
931 iimg->rect = MEM_new_array_uninitialized<uchar>(size_in_bytes, __func__);
932 memcpy(iimg->rect, reinterpret_cast<const uint *>(bbuf->byte_data()), size_in_bytes);
933 IMB_freeImBuf(bbuf);
934 }
935}
936
938{
939 /* Define icons. */
940 for (int x = ICON_NONE; x < ICON_BLANK_LAST_SVG_ITEM; x++) {
941 const IconType icontype = icontypes[x];
943 continue;
944 }
945 def_internal_icon(nullptr, x, 0, 0, 0, icontype.type, icontype.theme_color);
946 }
947
951
952 def_internal_vicon(ICON_KEYTYPE_KEYFRAME_VEC, vicon_keytype_keyframe_draw);
953 def_internal_vicon(ICON_KEYTYPE_BREAKDOWN_VEC, vicon_keytype_breakdown_draw);
954 def_internal_vicon(ICON_KEYTYPE_EXTREME_VEC, vicon_keytype_extreme_draw);
955 def_internal_vicon(ICON_KEYTYPE_JITTER_VEC, vicon_keytype_jitter_draw);
956 def_internal_vicon(ICON_KEYTYPE_MOVING_HOLD_VEC, vicon_keytype_moving_hold_draw);
957 def_internal_vicon(ICON_KEYTYPE_GENERATED_VEC, vicon_keytype_generated_draw);
958
959 def_internal_vicon(ICON_HANDLETYPE_FREE_VEC, vicon_handletype_free_draw);
960 def_internal_vicon(ICON_HANDLETYPE_ALIGNED_VEC, vicon_handletype_aligned_draw);
961 def_internal_vicon(ICON_HANDLETYPE_VECTOR_VEC, vicon_handletype_vector_draw);
962 def_internal_vicon(ICON_HANDLETYPE_AUTO_VEC, vicon_handletype_auto_draw);
963 def_internal_vicon(ICON_HANDLETYPE_AUTO_CLAMP_VEC, vicon_handletype_auto_clamp_draw);
964
965 def_internal_vicon(ICON_COLORSET_01_VEC, vicon_colorset_draw_01);
966 def_internal_vicon(ICON_COLORSET_02_VEC, vicon_colorset_draw_02);
967 def_internal_vicon(ICON_COLORSET_03_VEC, vicon_colorset_draw_03);
968 def_internal_vicon(ICON_COLORSET_04_VEC, vicon_colorset_draw_04);
969 def_internal_vicon(ICON_COLORSET_05_VEC, vicon_colorset_draw_05);
970 def_internal_vicon(ICON_COLORSET_06_VEC, vicon_colorset_draw_06);
971 def_internal_vicon(ICON_COLORSET_07_VEC, vicon_colorset_draw_07);
972 def_internal_vicon(ICON_COLORSET_08_VEC, vicon_colorset_draw_08);
973 def_internal_vicon(ICON_COLORSET_09_VEC, vicon_colorset_draw_09);
974 def_internal_vicon(ICON_COLORSET_10_VEC, vicon_colorset_draw_10);
975 def_internal_vicon(ICON_COLORSET_11_VEC, vicon_colorset_draw_11);
976 def_internal_vicon(ICON_COLORSET_12_VEC, vicon_colorset_draw_12);
977 def_internal_vicon(ICON_COLORSET_13_VEC, vicon_colorset_draw_13);
978 def_internal_vicon(ICON_COLORSET_14_VEC, vicon_colorset_draw_14);
979 def_internal_vicon(ICON_COLORSET_15_VEC, vicon_colorset_draw_15);
980 def_internal_vicon(ICON_COLORSET_16_VEC, vicon_colorset_draw_16);
981 def_internal_vicon(ICON_COLORSET_17_VEC, vicon_colorset_draw_17);
982 def_internal_vicon(ICON_COLORSET_18_VEC, vicon_colorset_draw_18);
983 def_internal_vicon(ICON_COLORSET_19_VEC, vicon_colorset_draw_19);
984 def_internal_vicon(ICON_COLORSET_20_VEC, vicon_colorset_draw_20);
985
986 def_internal_vicon(ICON_STRIP_COLOR_01, vicon_strip_color_draw_01);
987 def_internal_vicon(ICON_STRIP_COLOR_02, vicon_strip_color_draw_02);
988 def_internal_vicon(ICON_STRIP_COLOR_03, vicon_strip_color_draw_03);
989 def_internal_vicon(ICON_STRIP_COLOR_04, vicon_strip_color_draw_04);
990 def_internal_vicon(ICON_STRIP_COLOR_05, vicon_strip_color_draw_05);
991 def_internal_vicon(ICON_STRIP_COLOR_06, vicon_strip_color_draw_06);
992 def_internal_vicon(ICON_STRIP_COLOR_07, vicon_strip_color_draw_07);
993 def_internal_vicon(ICON_STRIP_COLOR_08, vicon_strip_color_draw_08);
994 def_internal_vicon(ICON_STRIP_COLOR_09, vicon_strip_color_draw_09);
995
997 def_internal_vicon(ICON_LIBRARY_DATA_OVERRIDE_NONEDITABLE,
1000
1001 def_internal_vicon(ICON_LAYERGROUP_COLOR_01, vicon_layergroup_color_draw_01);
1002 def_internal_vicon(ICON_LAYERGROUP_COLOR_02, vicon_layergroup_color_draw_02);
1003 def_internal_vicon(ICON_LAYERGROUP_COLOR_03, vicon_layergroup_color_draw_03);
1004 def_internal_vicon(ICON_LAYERGROUP_COLOR_04, vicon_layergroup_color_draw_04);
1005 def_internal_vicon(ICON_LAYERGROUP_COLOR_05, vicon_layergroup_color_draw_05);
1006 def_internal_vicon(ICON_LAYERGROUP_COLOR_06, vicon_layergroup_color_draw_06);
1007 def_internal_vicon(ICON_LAYERGROUP_COLOR_07, vicon_layergroup_color_draw_07);
1008 def_internal_vicon(ICON_LAYERGROUP_COLOR_08, vicon_layergroup_color_draw_08);
1009
1010 def_internal_vicon(ICON_NODE_SOCKET_FLOAT, icon_node_socket_draw_float);
1011 def_internal_vicon(ICON_NODE_SOCKET_VECTOR, icon_node_socket_draw_vector);
1012 def_internal_vicon(ICON_NODE_SOCKET_RGBA, icon_node_socket_draw_rgba);
1013 def_internal_vicon(ICON_NODE_SOCKET_SHADER, icon_node_socket_draw_shader);
1014 def_internal_vicon(ICON_NODE_SOCKET_BOOLEAN, icon_node_socket_draw_boolean);
1015 def_internal_vicon(ICON_NODE_SOCKET_INT, icon_node_socket_draw_int);
1016 def_internal_vicon(ICON_NODE_SOCKET_STRING, icon_node_socket_draw_string);
1017 def_internal_vicon(ICON_NODE_SOCKET_OBJECT, icon_node_socket_draw_object);
1018 def_internal_vicon(ICON_NODE_SOCKET_IMAGE, icon_node_socket_draw_image);
1019 def_internal_vicon(ICON_NODE_SOCKET_GEOMETRY, icon_node_socket_draw_geometry);
1020 def_internal_vicon(ICON_NODE_SOCKET_COLLECTION, icon_node_socket_draw_collection);
1021 def_internal_vicon(ICON_NODE_SOCKET_TEXTURE, icon_node_socket_draw_texture);
1022 def_internal_vicon(ICON_NODE_SOCKET_MATERIAL, icon_node_socket_draw_material);
1023 def_internal_vicon(ICON_NODE_SOCKET_ROTATION, icon_node_socket_draw_rotation);
1024 def_internal_vicon(ICON_NODE_SOCKET_MENU, icon_node_socket_draw_menu);
1025 def_internal_vicon(ICON_NODE_SOCKET_MATRIX, icon_node_socket_draw_matrix);
1026 def_internal_vicon(ICON_NODE_SOCKET_BUNDLE, icon_node_socket_draw_bundle);
1027 def_internal_vicon(ICON_NODE_SOCKET_CLOSURE, icon_node_socket_draw_closure);
1028 def_internal_vicon(ICON_NODE_SOCKET_FONT, icon_node_socket_draw_font);
1029 def_internal_vicon(ICON_NODE_SOCKET_SCENE, icon_node_socket_draw_scene);
1030 def_internal_vicon(ICON_NODE_SOCKET_TEXT, icon_node_socket_draw_text);
1031 def_internal_vicon(ICON_NODE_SOCKET_MASK, icon_node_socket_draw_mask);
1032 def_internal_vicon(ICON_NODE_SOCKET_SOUND, icon_node_socket_draw_sound);
1033 def_internal_vicon(ICON_NODE_SOCKET_INT_VECTOR, icon_node_socket_draw_int_vector);
1034}
1035
1036#else
1037
1038#endif /* WITH_HEADLESS */
1039
1041{
1044}
1045
1046void icons_free_drawinfo(void *drawinfo)
1047{
1048 DrawInfo *di = static_cast<DrawInfo *>(drawinfo);
1049
1050 if (di == nullptr) {
1051 return;
1052 }
1053
1054 if (di->type == ICON_TYPE_BUFFER) {
1055 if (di->data.buffer.image) {
1056 if (di->data.buffer.image->rect) {
1057 MEM_delete(di->data.buffer.image->rect);
1058 }
1059 MEM_delete(di->data.buffer.image);
1060 }
1061 }
1062 else if (di->type == ICON_TYPE_GEOM) {
1063 if (di->data.geom.image_cache) {
1064 IMB_freeImBuf(di->data.geom.image_cache);
1065 }
1066 }
1067
1068 MEM_delete(di);
1069}
1070
1075{
1076 const int icon_data_type = icon->obj_type;
1077
1078 DrawInfo *di = MEM_new_zeroed<DrawInfo>("di_icon");
1079
1080 if (ELEM(icon_data_type, ICON_DATA_ID, ICON_DATA_PREVIEW)) {
1081 di->type = ICON_TYPE_PREVIEW;
1082 }
1083 else if (icon_data_type == ICON_DATA_IMBUF) {
1084 di->type = ICON_TYPE_IMBUF;
1085 }
1086 else if (icon_data_type == ICON_DATA_GEOM) {
1087 di->type = ICON_TYPE_GEOM;
1088 }
1089 else if (icon_data_type == ICON_DATA_STUDIOLIGHT) {
1090 di->type = ICON_TYPE_BUFFER;
1091 }
1092 else if (icon_data_type == ICON_DATA_GPLAYER) {
1093 di->type = ICON_TYPE_GPLAYER;
1094 }
1095 else {
1096 BLI_assert(0);
1097 }
1098
1099 return di;
1100}
1101
1103{
1104 if (icon->drawinfo) {
1105 return static_cast<DrawInfo *>(icon->drawinfo);
1106 }
1107 DrawInfo *di = icon_create_drawinfo(icon);
1108 icon->drawinfo = di;
1110 return di;
1111}
1112
1113bool icon_get_theme_color(int icon_id, uchar color[4])
1114{
1115 Icon *icon = BKE_icon_get(icon_id);
1116 if (icon == nullptr) {
1117 return false;
1118 }
1119
1120 DrawInfo *di = icon_ensure_drawinfo(icon);
1121 return theme::get_icon_color_4ubv(di->data.texture.theme_color, color);
1122}
1123
1125{
1126#ifndef WITH_HEADLESS
1129#endif
1130}
1131
1133{
1134 switch (size) {
1135 case ICON_SIZE_ICON:
1137 case ICON_SIZE_PREVIEW:
1139 default:
1140 return 0;
1141 }
1142}
1143
1144/* Create rect for the icon
1145 */
1146static void icon_create_rect(PreviewImage *prv_img, enum eIconSizes size)
1147{
1148 const uint render_size = icon_preview_to_render_size(size);
1149
1150 if (!prv_img) {
1151 if (G.debug & G_DEBUG) {
1152 CLOG_WARN(&LOG, "%s, error: requested preview image does not exist", __func__);
1153 }
1154 }
1155 else if (!prv_img->rect[size]) {
1156 prv_img->flag[size] |= PRV_CHANGED;
1157 prv_img->changed_timestamp[size] = 0;
1158 if (!ED_preview_use_image_size(prv_img, size)) {
1159 prv_img->w[size] = render_size;
1160 prv_img->h[size] = render_size;
1161 prv_img->rect[size] = MEM_new_array_zeroed<uint>(render_size * render_size, "prv_rect");
1162 }
1163 }
1164}
1165
1167 const bContext *C, Scene *scene, ID *id, PreviewImage *pi, int size, const bool use_job);
1168
1169static void studiolight_icon_job_exec(void *customdata, wmJobWorkerStatus * /*worker_status*/)
1170{
1171 Icon **tmp = static_cast<Icon **>(customdata);
1172 Icon *icon = *tmp;
1173 DrawInfo *di = icon_ensure_drawinfo(icon);
1174 StudioLight *sl = static_cast<StudioLight *>(icon->obj);
1176 reinterpret_cast<uint *>(di->data.buffer.image->rect), sl, icon->id_type);
1177}
1178
1180{
1181 Icon *icon = BKE_icon_get(icon_id);
1183 icon->obj = nullptr;
1184}
1185
1187{
1188 wmWindowManager *wm = static_cast<wmWindowManager *>(data);
1189
1190 /* Happens if job was canceled or already finished. */
1191 if (wm == nullptr) {
1192 return;
1193 }
1194
1195 /* get icons_id, get icons and kill wm jobs */
1196 if (sl->icon_id_radiance) {
1198 }
1199 if (sl->icon_id_irradiance) {
1201 }
1202 if (sl->icon_id_matcap) {
1204 }
1205 if (sl->icon_id_matcap_flipped) {
1207 }
1208}
1209
1210static void studiolight_icon_job_end(void *customdata)
1211{
1212 Icon **tmp = static_cast<Icon **>(customdata);
1213 Icon *icon = *tmp;
1214 StudioLight *sl = static_cast<StudioLight *>(icon->obj);
1216}
1217
1218void icon_ensure_deferred(const bContext *C, const int icon_id, const bool big)
1219{
1220 Icon *icon = BKE_icon_get(icon_id);
1221
1222 if (icon == nullptr) {
1223 return;
1224 }
1225
1226 DrawInfo *di = icon_ensure_drawinfo(icon);
1227
1228 if (di == nullptr) {
1229 return;
1230 }
1231
1232 switch (di->type) {
1233 case ICON_TYPE_PREVIEW: {
1234 ID *id = (icon->id_type != 0) ? static_cast<ID *>(icon->obj) : nullptr;
1235 PreviewImage *prv = id ? BKE_previewimg_id_ensure(id) :
1236 static_cast<PreviewImage *>(icon->obj);
1237 /* Using jobs for screen previews crashes due to off-screen rendering.
1238 * XXX: would be nicer if #PreviewImage could store if it supports jobs. */
1239 const bool use_jobs = !id || (GS(id->name) != ID_SCR);
1240
1241 if (prv) {
1242 const int size = big ? ICON_SIZE_PREVIEW : ICON_SIZE_ICON;
1243
1244 if (id || prv->runtime->deferred_loading_data) {
1245 id_preview_image_render_size(C, nullptr, id, prv, size, use_jobs);
1246 }
1247 }
1248 break;
1249 }
1250 case ICON_TYPE_BUFFER: {
1251 if (icon->obj_type == ICON_DATA_STUDIOLIGHT) {
1252 if (di->data.buffer.image == nullptr) {
1254 StudioLight *sl = static_cast<StudioLight *>(icon->obj);
1256 IconImage *img = MEM_new_zeroed<IconImage>(__func__);
1257
1258 img->w = STUDIOLIGHT_ICON_SIZE;
1259 img->h = STUDIOLIGHT_ICON_SIZE;
1260 const size_t size = STUDIOLIGHT_ICON_SIZE * STUDIOLIGHT_ICON_SIZE * sizeof(uint);
1261 img->rect = MEM_new_array_uninitialized<uint8_t>(size, __func__);
1262 memset(img->rect, 0, size);
1263 di->data.buffer.image = img;
1264
1265 wmJob *wm_job = WM_jobs_get(wm,
1267 icon,
1268 "Generating StudioLight icon...",
1271 Icon **tmp = MEM_new_zeroed<Icon *>(__func__);
1272 *tmp = icon;
1274 WM_jobs_timer(wm_job, 0.01, 0, NC_WINDOW);
1276 wm_job, studiolight_icon_job_exec, nullptr, nullptr, studiolight_icon_job_end);
1277 WM_jobs_start(CTX_wm_manager(C), wm_job);
1278 }
1279 }
1280 break;
1281 }
1282 }
1283}
1284
1285bool icon_is_preview_deferred_loading(const int icon_id, const bool big)
1286{
1287 const Icon *icon = BKE_icon_get(icon_id);
1288 if (icon == nullptr) {
1289 return false;
1290 }
1291
1292 const DrawInfo *di = static_cast<DrawInfo *>(icon->drawinfo);
1293 if (icon->drawinfo == nullptr) {
1294 return false;
1295 }
1296
1297 if (di->type == ICON_TYPE_PREVIEW) {
1298 const ID *id = (icon->id_type != 0) ? static_cast<ID *>(icon->obj) : nullptr;
1299 const PreviewImage *prv = id ? BKE_previewimg_id_get(id) :
1300 static_cast<PreviewImage *>(icon->obj);
1301
1302 if (prv) {
1303 const int size = big ? ICON_SIZE_PREVIEW : ICON_SIZE_ICON;
1304 return !BKE_previewimg_is_finished(prv, size);
1305 }
1306 }
1307
1308 return false;
1309}
1310
1317static void icon_set_image(const bContext *C,
1318 Scene *scene,
1319 ID *id,
1320 PreviewImage *prv_img,
1321 enum eIconSizes size,
1322 const bool use_job)
1323{
1324 if (!prv_img) {
1325 if (G.debug & G_DEBUG) {
1326 CLOG_WARN(&LOG, "%s: no preview image for this ID: %s", __func__, id->name);
1327 }
1328 return;
1329 }
1330
1331 if (prv_img->flag[size] & PRV_USER_EDITED) {
1332 /* user-edited preview, do not auto-update! */
1333 return;
1334 }
1335
1336 /* Check if the ID supports preview loading or rendering. */
1338 return;
1339 }
1340
1341 const bool delay = prv_img->rect[size] != nullptr;
1342 icon_create_rect(prv_img, size);
1343
1344 if (use_job && (!id || BKE_previewimg_id_supports_jobs(id))) {
1345 /* Job (background) version */
1346 ED_preview_icon_job(C, prv_img, id, size, delay);
1347 }
1348 else {
1349 if (!scene) {
1350 scene = CTX_data_scene(C);
1351 }
1352 /* Immediate version */
1353 ED_preview_icon_render(C, scene, prv_img, id, size);
1354 }
1355}
1356
1358{
1359 Icon *icon = BKE_icon_get(icon_id);
1360
1361 if (icon == nullptr) {
1362 return nullptr;
1363 }
1364
1365 DrawInfo *di = static_cast<DrawInfo *>(icon->drawinfo);
1366
1367 if (di == nullptr) {
1368 return nullptr;
1369 }
1370
1371 if (di->type == ICON_TYPE_PREVIEW) {
1372 const PreviewImage *prv = (icon->id_type != 0) ?
1373 BKE_previewimg_id_ensure(static_cast<ID *>(icon->obj)) :
1374 static_cast<const PreviewImage *>(icon->obj);
1375
1376 if (prv) {
1377 return BKE_previewimg_copy(prv);
1378 }
1379 }
1380 else if (di->data.buffer.image) {
1381 ImBuf *bbuf;
1382
1383 bbuf = IMB_load_image_from_memory(di->data.buffer.image->datatoc_rect,
1384 di->data.buffer.image->datatoc_size,
1386 __func__);
1387 if (bbuf) {
1389
1390 const size_t size = size_t(bbuf->x) * size_t(bbuf->y);
1391 prv->rect[0] = MEM_new_array_uninitialized<uint>(size, __func__);
1392 memcpy(prv->rect[0], reinterpret_cast<const uint *>(bbuf->byte_data()), size * sizeof(uint));
1393
1394 prv->w[0] = bbuf->x;
1395 prv->h[0] = bbuf->y;
1396
1397 IMB_freeImBuf(bbuf);
1398
1399 return prv;
1400 }
1401 }
1402
1403 return nullptr;
1404}
1405
1406static void icon_draw_rect(float x,
1407 float y,
1408 int w,
1409 int h,
1410 int rw,
1411 int rh,
1412 const uint8_t *rect,
1413 float alpha,
1414 const float desaturate)
1415{
1416 int draw_w = w;
1417 int draw_h = h;
1418 int draw_x = x;
1419 /* We need to round y, to avoid the icon jittering in some cases. */
1420 int draw_y = round_fl_to_int(y);
1421
1422 /* sanity check */
1423 if (w <= 0 || h <= 0 || w > 2000 || h > 2000) {
1424 printf("%s: icons are %i x %i pixels?\n", __func__, w, h);
1425 BLI_assert_msg(0, "invalid icon size");
1426 return;
1427 }
1428 /* modulate color */
1429 const float col[4] = {alpha, alpha, alpha, alpha};
1430
1431 float scale_x = 1.0f;
1432 float scale_y = 1.0f;
1433 /* `rect` contains image in render-size, we only scale if needed. */
1434 if (rw != w || rh != h) {
1435 /* preserve aspect ratio and center */
1436 if (rw > rh) {
1437 draw_w = w;
1438 draw_h = int((float(rh) / float(rw)) * float(w));
1439 draw_y += (h - draw_h) / 2;
1440 }
1441 else if (rw < rh) {
1442 draw_w = int((float(rw) / float(rh)) * float(h));
1443 draw_h = h;
1444 draw_x += (w - draw_w) / 2;
1445 }
1446 scale_x = draw_w / float(rw);
1447 scale_y = draw_h / float(rh);
1448 /* If the image is squared, the `draw_*` initialization values are good. */
1449 }
1450
1451 /* draw */
1453 if (desaturate != 0.0f) {
1455 }
1456 else {
1458 }
1459 PixelBitmapDrawer drawer(shader);
1460
1462 immUniform1f("factor", desaturate);
1463 }
1464
1465 drawer.draw(draw_x,
1466 draw_y,
1467 rw,
1468 rh,
1469 gpu::TextureFormat::UNORM_8_8_8_8,
1470 true,
1471 rect,
1472 scale_x,
1473 scale_y,
1474 col);
1475}
1476
1477/* Drawing size for preview images */
1478static int get_draw_size(enum eIconSizes size)
1479{
1480 switch (size) {
1481 case ICON_SIZE_ICON:
1482 return ICON_DEFAULT_HEIGHT;
1483 case ICON_SIZE_PREVIEW:
1485 default:
1486 return 0;
1487 }
1488}
1489
1490static void svg_replace_color_attributes(std::string &svg,
1491 const std::string &name,
1492 const size_t start,
1493 const size_t end)
1494{
1495 const bTheme *btheme = theme::theme_get();
1496
1497 uchar white[] = {255, 255, 255, 255};
1498 uchar black[] = {0, 0, 0, 255};
1499 uchar logo_orange[] = {232, 125, 13, 255};
1500 uchar logo_blue[] = {38, 87, 135, 255};
1501
1502 /* Tool colors hardcoded for now. */
1503 uchar tool_add[] = {117, 255, 175, 255};
1504 uchar tool_remove[] = {245, 107, 91, 255};
1505 uchar tool_select[] = {255, 176, 43, 255};
1506 uchar tool_transform[] = {217, 175, 245, 255};
1507 uchar tool_white[] = {255, 255, 255, 255};
1508 uchar tool_red[] = {214, 45, 48, 255};
1509
1510 const struct ColorItem {
1511 const char *name;
1512 const uchar *col = nullptr;
1513 int colorid = TH_UNDEFINED;
1514 int spacetype = SPACE_TYPE_ANY;
1515 } items[] = {
1516 {"blender_white", white},
1517 {"blender_black", black},
1518 {"blender_logo_orange", logo_orange},
1519 {"blender_logo_blue", logo_blue},
1520 {"blender_selected", btheme->tui.wcol_regular.inner},
1521 {"blender_mesh_selected", btheme->space_view3d.vertex_select},
1522 {"blender_back", nullptr, TH_BACK},
1523 {"blender_text", nullptr, TH_TEXT},
1524 {"blender_text_hi", nullptr, TH_TEXT_HI},
1525 {"blender_red_alert", nullptr, TH_ERROR},
1526 {"blender_error", nullptr, TH_ERROR},
1527 {"blender_warning", nullptr, TH_WARNING},
1528 {"blender_info", nullptr, TH_INFO},
1529 {"blender_scene", nullptr, TH_ICON_SCENE},
1530 {"blender_collection", nullptr, TH_ICON_COLLECTION},
1531 {"blender_collection_color_01", btheme->collection_color[0].color},
1532 {"blender_collection_color_02", btheme->collection_color[1].color},
1533 {"blender_collection_color_03", btheme->collection_color[2].color},
1534 {"blender_collection_color_04", btheme->collection_color[3].color},
1535 {"blender_collection_color_05", btheme->collection_color[4].color},
1536 {"blender_collection_color_06", btheme->collection_color[5].color},
1537 {"blender_collection_color_07", btheme->collection_color[6].color},
1538 {"blender_collection_color_08", btheme->collection_color[7].color},
1539 {"blender_object", nullptr, TH_ICON_OBJECT},
1540 {"blender_object_data", nullptr, TH_ICON_OBJECT_DATA},
1541 {"blender_modifier", nullptr, TH_ICON_MODIFIER},
1542 {"blender_shading", nullptr, TH_ICON_SHADING},
1543 {"blender_folder", nullptr, TH_ICON_FOLDER},
1544 {"blender_fund", nullptr, TH_ICON_FUND},
1545 {"blender_autokey", nullptr, TH_ICON_AUTOKEY},
1546 {"blender_tool_add", tool_add},
1547 {"blender_tool_remove", tool_remove},
1548 {"blender_tool_select", tool_select},
1549 {"blender_tool_transform", tool_transform},
1550 {"blender_tool_white", tool_white},
1551 {"blender_tool_red", tool_red},
1552 {"blender_bevel", nullptr, TH_BEVEL},
1553 {"blender_crease", nullptr, TH_CREASE},
1554 {"blender_seam", nullptr, TH_SEAM},
1555 {"blender_sharp", nullptr, TH_SHARP},
1556 {"blender_ipo_linear", btheme->space_action.anim_interpolation_linear},
1557 {"blender_ipo_constant", btheme->space_action.anim_interpolation_constant},
1558 {"blender_ipo_other", btheme->space_action.anim_interpolation_other},
1559 };
1560
1561 for (const ColorItem &item : items) {
1562 if (name != item.name) {
1563 continue;
1564 }
1565
1566 uchar color[4];
1567 if (item.col) {
1568 memcpy(color, item.col, sizeof(color));
1569 }
1570 else if (item.colorid != TH_UNDEFINED) {
1571 if (item.spacetype != SPACE_TYPE_ANY) {
1572 theme::get_color_type_4ubv(item.colorid, item.spacetype, color);
1573 }
1574 else {
1575 theme::get_color_4ubv(item.colorid, color);
1576 }
1577 }
1578 else {
1579 continue;
1580 }
1581
1582 std::string hexcolor = fmt::format(
1583 "{:02x}{:02x}{:02x}{:02x}", color[0], color[1], color[2], color[3]);
1584
1585 size_t att_start = start;
1586 while (true) {
1587 constexpr static StringRef key = "fill=\"";
1588 att_start = svg.find(key, att_start);
1589 if (att_start == std::string::npos || att_start > end) {
1590 break;
1591 }
1592 const size_t att_end = svg.find("\"", att_start + key.size());
1593 if (att_end != std::string::npos && att_end < end) {
1594 svg.replace(att_start, att_end - att_start, key + "#" + hexcolor);
1595 }
1596 att_start += StringRef(key + "#rrggbbaa\"").size();
1597 }
1598
1599 att_start = start;
1600 while (true) {
1601 constexpr static StringRef key = "fill:";
1602 att_start = svg.find(key, att_start);
1603 if (att_start == std::string::npos || att_start > end) {
1604 break;
1605 }
1606 const size_t att_end = svg.find(";", att_start + key.size());
1607 if (att_end != std::string::npos && att_end - att_start < end) {
1608 svg.replace(att_start, att_end - att_start, key + "#" + hexcolor);
1609 }
1610 att_start += StringRef(key + "#rrggbbaa").size();
1611 }
1612 }
1613}
1614
1615static void icon_source_edit_cb(std::string &svg)
1616{
1617 size_t g_start = 0;
1618
1619 /* Scan string, processing only groups with our keyword ids. */
1620
1621 while (true) {
1622 /* Look for a blender id, quick exit if not found. */
1623 constexpr static StringRef key = "id=\"";
1624 const size_t id_start = svg.find(key + "blender_", g_start);
1625 if (id_start == std::string::npos) {
1626 return;
1627 }
1628
1629 /* Scan back to beginning of this group element. */
1630 g_start = svg.rfind("<g", id_start);
1631 if (g_start == std::string::npos) {
1632 /* Malformed. */
1633 return;
1634 }
1635
1636 /* Scan forward to end of the group. */
1637 const size_t g_end = svg.find("</g>", id_start);
1638 if (g_end == std::string::npos) {
1639 /* Malformed. */
1640 return;
1641 }
1642
1643 /* Get group id name. */
1644 const size_t id_end = svg.find("\"", id_start + key.size());
1645 if (id_end != std::string::npos) {
1646 std::string id_name = svg.substr(id_start + key.size(), id_end - id_start - key.size());
1647 /* Replace this group's colors. */
1648 svg_replace_color_attributes(svg, id_name, g_start, g_end);
1649 }
1650
1651 g_start = g_end;
1652 }
1653}
1654
1655static void icon_draw_size(float x,
1656 float y,
1657 int icon_id,
1658 float aspect,
1659 float alpha,
1660 enum eIconSizes size,
1661 int draw_size,
1662 const float desaturate,
1663 const uchar mono_rgba[4],
1664 const bool mono_border,
1665 const IconTextOverlay *text_overlay,
1666 const bool inverted = false)
1667{
1668 if (icon_id == ICON_NONE) {
1669 return;
1670 }
1671
1672 const bTheme *btheme = theme::theme_get();
1673 const float fdraw_size = float(draw_size);
1674
1675 Icon *icon = BKE_icon_get(icon_id);
1676
1677 if (icon == nullptr) {
1678 if (G.debug & G_DEBUG) {
1679 CLOG_WARN(&LOG, "%s: Internal error, no icon for icon ID: %d", __func__, icon_id);
1680 }
1681 icon_id = ICON_NOT_FOUND;
1682 icon = BKE_icon_get(icon_id);
1683 }
1684
1685 if (icon->obj_type != ICON_DATA_STUDIOLIGHT) {
1686 /* Icon alpha should not apply to MatCap/Studio lighting. #80356. */
1687 alpha *= btheme->tui.icon_alpha;
1688 }
1689
1690 /* scale width and height according to aspect */
1691 int w = int(fdraw_size / aspect + 0.5f);
1692 int h = int(fdraw_size / aspect + 0.5f);
1693
1694 DrawInfo *di = icon_ensure_drawinfo(icon);
1695
1696 /* We need to flush widget base first to ensure correct ordering. */
1698
1699 if (di->type == ICON_TYPE_IMBUF) {
1700 const ImBuf *ibuf = static_cast<const ImBuf *>(icon->obj);
1701
1703 icon_draw_rect(x, y, w, h, ibuf->x, ibuf->y, ibuf->byte_data(), alpha, desaturate);
1705 }
1706 else if (di->type == ICON_TYPE_VECTOR) {
1707 /* vector icons use the Block transformation, they are not drawn
1708 * with untransformed coordinates like the other icons */
1709 di->data.vector.func(
1710 x, y, float(draw_size) / aspect, float(draw_size) / aspect, alpha, mono_rgba);
1711 }
1712 else if (di->type == ICON_TYPE_GEOM) {
1713#ifdef USE_UI_TOOLBAR_HACK
1714 /* TODO(@ideasman42): scale icons up for toolbar,
1715 * we need a way to detect larger buttons and do this automatic. */
1716 {
1718 y = (y + (h / 2)) - ((h * scale) / 2);
1719 w *= scale;
1720 h *= scale;
1721 }
1722#endif
1723
1724 /* If the theme is light, we will adjust the icon colors. */
1725 const bool invert = (srgb_to_grayscale_byte(btheme->tui.wcol_toolbar_item.inner) > 128);
1726 const bool geom_inverted = di->data.geom.inverted;
1727
1728 /* This could re-generate often if rendered at different sizes in the one interface.
1729 * TODO(@ideasman42): support caching multiple sizes. */
1730 ImBuf *ibuf = di->data.geom.image_cache;
1731 if ((ibuf == nullptr) || (ibuf->x != w) || (ibuf->y != h) || (invert != geom_inverted)) {
1732 if (ibuf) {
1733 IMB_freeImBuf(ibuf);
1734 }
1735 if (invert != geom_inverted) {
1736 BKE_icon_geom_invert_lightness(static_cast<Icon_Geom *>(icon->obj));
1737 }
1738 ibuf = BKE_icon_geom_rasterize(static_cast<Icon_Geom *>(icon->obj), w, h);
1739 di->data.geom.image_cache = ibuf;
1740 di->data.geom.inverted = invert;
1741 }
1742
1744 icon_draw_rect(x, y, w, h, w, h, ibuf->byte_data(), alpha, desaturate);
1746 }
1747 else if (di->type == ICON_TYPE_EVENT) {
1748 icon_draw_rect_input(x, y, w, h, icon_id, aspect, alpha, inverted);
1749 }
1751 /* The alpha may be over 1.0, however `outline_intensity` must be in the [0..1] range. */
1752 const float outline_intensity = mono_border ?
1753 std::min(1.0f,
1754 (btheme->tui.icon_border_intensity > 0.0f ?
1755 btheme->tui.icon_border_intensity :
1756 0.3f) *
1757 alpha) :
1758 0.0f;
1759
1760 float color[4];
1761 if (icon_id == ICON_NOT_FOUND) {
1763 }
1764 else if (mono_rgba) {
1765 rgba_uchar_to_float(color, mono_rgba);
1766 }
1767 else {
1769 }
1770
1771 color[3] *= alpha;
1772
1773 if (di->type == ICON_TYPE_SVG_COLOR) {
1774 BLF_draw_svg_icon(uint(icon_id),
1775 x,
1776 y,
1777 float(draw_size) / aspect,
1778 color,
1779 outline_intensity,
1780 true,
1782 }
1783 else {
1784 BLF_draw_svg_icon(uint(icon_id),
1785 x,
1786 y,
1787 float(draw_size) / aspect,
1788 color,
1789 outline_intensity,
1790 false,
1791 nullptr);
1792 }
1793
1794 if (text_overlay && text_overlay->text[0] != '\0') {
1795 /* Handle the little numbers on top of the icon. */
1796 uchar text_color[4];
1797 if (text_overlay->color[3]) {
1798 copy_v4_v4_uchar(text_color, text_overlay->color);
1799 }
1800 else {
1801 theme::get_color_4ubv(TH_TEXT, text_color);
1802 }
1803 const bool is_light = srgb_to_grayscale_byte(text_color) > 96;
1804 const float zoom_factor = w / UI_ICON_SIZE;
1805 uiFontStyle fstyle_small = *UI_FSTYLE_WIDGET;
1806 fstyle_small.points *= zoom_factor * 0.8f;
1808 fstyle_small.shadx = 0;
1809 fstyle_small.shady = 0;
1810 rcti text_rect = {int(x), int(x + UI_UNIT_X * zoom_factor), int(y), int(y)};
1812 fontstyle_draw(&fstyle_small,
1813 &text_rect,
1814 text_overlay->text,
1815 sizeof(text_overlay->text),
1816 text_color,
1817 &params);
1818 }
1819 }
1820
1821 else if (di->type == ICON_TYPE_BUFFER) {
1822 /* it is a builtin icon */
1823 IconImage *iimg = di->data.buffer.image;
1824#ifndef WITH_HEADLESS
1825 icon_verify_datatoc(iimg);
1826#endif
1827 if (!iimg->rect) {
1828 /* something has gone wrong! */
1829 return;
1830 }
1831
1832 icon_draw_rect(x, y, w, h, iimg->w, iimg->h, iimg->rect, alpha, desaturate);
1833 }
1834 else if (di->type == ICON_TYPE_PREVIEW) {
1835 PreviewImage *pi = (icon->id_type != 0) ?
1836 BKE_previewimg_id_ensure(static_cast<ID *>(icon->obj)) :
1837 static_cast<PreviewImage *>(icon->obj);
1838
1839 if (pi) {
1840 /* If a preview icon isn't available but a bigger version of it is, use that and let drawing
1841 * downscale it on the GPU (with mipmaps and filtering, for decent results). Useful for
1842 * data-block previews where the big preview was rendered/loaded before, but we attempt to
1843 * display the small icon version of it. */
1844 if (!pi->rect[size]) {
1845 for (int bigger_size = size + 1; bigger_size < NUM_ICON_SIZES; bigger_size++) {
1846 if (pi->rect[bigger_size] && !BKE_previewimg_is_rendering(pi, bigger_size)) {
1847 size = eIconSizes(bigger_size);
1848 break;
1849 }
1850 }
1851 }
1852
1853 /* no create icon on this level in code */
1854 if (!pi->rect[size]) {
1855 /* Something has gone wrong! */
1856 return;
1857 }
1858
1859 /* Preview images use premultiplied alpha. */
1862 y,
1863 w,
1864 h,
1865 pi->w[size],
1866 pi->h[size],
1867 reinterpret_cast<const uint8_t *>(pi->rect[size]),
1868 alpha,
1869 desaturate);
1871 }
1872 }
1873 else if (di->type == ICON_TYPE_GPLAYER) {
1874 BLI_assert(icon->obj != nullptr);
1875
1876 /* Just draw a colored rect - Like for vicon_colorset_draw() */
1877#ifndef WITH_HEADLESS
1878 vicon_gplayer_color_draw(icon, int(x), int(y), w, h);
1879#endif
1880 }
1881}
1882
1888 const bContext *C, Scene *scene, ID *id, PreviewImage *pi, int size, const bool use_job)
1889{
1890 BLI_assert((id == nullptr) || (BKE_previewimg_id_get(id) == pi));
1891
1892 /* changed only ever set by dynamic icons */
1893 if ((pi->flag[size] & PRV_CHANGED) || (!pi->rect[size] && !BKE_previewimg_is_invalid(pi, size)))
1894 {
1895 /* create the rect if necessary */
1896 icon_set_image(C, scene, id, pi, eIconSizes(size), use_job);
1897
1898 if ((id == nullptr) || BKE_previewimg_id_get(id)) {
1899 /* Only change the preview image flag if it hasn't been freed yet. */
1900 pi->flag[size] &= ~PRV_CHANGED;
1901 }
1902 }
1903}
1904
1906 Scene *scene,
1907 ID *id_to_render,
1908 const enum eIconSizes size,
1909 const bool use_job,
1910 PreviewImage *r_preview_image)
1911{
1912 id_preview_image_render_size(C, scene, id_to_render, r_preview_image, size, use_job);
1913}
1914
1916 const bContext *C, Scene *scene, ID *id, const enum eIconSizes size, const bool use_job)
1917{
1919 if (pi == nullptr) {
1920 return;
1921 }
1922
1923 ID *id_to_render = id;
1924
1925 /* For objects, first try if a preview can created via the object data. */
1926 if (GS(id->name) == ID_OB) {
1927 Object *ob = id_cast<Object *>(id);
1928 if (ED_preview_id_render_is_supported(static_cast<const ID *>(ob->data))) {
1929 id_to_render = ob->data;
1930 }
1931 }
1932
1933 if (!ED_preview_id_render_is_supported(id_to_render)) {
1934 return;
1935 }
1936
1937 icon_render_id_ex(C, scene, id_to_render, size, use_job, pi);
1938}
1939
1940static void id_icon_render(const bContext *C, ID *id, bool use_jobs)
1941{
1943
1944 if (!pi) {
1945 return;
1946 }
1947
1948 for (int i = 0; i < NUM_ICON_SIZES; i++) {
1949 id_preview_image_render_size(C, nullptr, id, pi, i, use_jobs);
1950 }
1951}
1952
1953static int id_screen_get_icon(const bContext *C, ID *id)
1954{
1956 /* Don't use jobs here, off-screen rendering doesn't like this and crashes. */
1957 id_icon_render(C, id, false);
1958
1959 return id->icon_id;
1960}
1961
1962int id_icon_get(const bContext *C, ID *id, const bool big)
1963{
1964 int iconid = 0;
1965
1966 /* icon */
1967 switch (GS(id->name)) {
1968 case ID_MA: /* fall through */
1969 case ID_TE: /* fall through */
1970 case ID_IM: /* fall through */
1971 case ID_WO: /* fall through */
1972 case ID_LA: /* fall through */
1973 iconid = BKE_icon_id_ensure(id);
1974 /* checks if not exists, or changed */
1975 icon_render_id(C, nullptr, id, big ? ICON_SIZE_PREVIEW : ICON_SIZE_ICON, true);
1976 break;
1977 case ID_SCR:
1978 iconid = id_screen_get_icon(C, id);
1979 break;
1980 case ID_OB:
1981 iconid = icon_from_object_type(id_cast<Object *>(id));
1982 break;
1983 case ID_GR:
1984 iconid = icon_color_from_collection(id_cast<Collection *>(id));
1985 break;
1986 default:
1987 break;
1988 }
1989
1990 return iconid;
1991}
1992
1993int icon_from_library(const ID *id)
1994{
1995 if (ID_IS_LINKED(id)) {
1996 if (ID_IS_PACKED(id)) {
1997 if (id->tag & ID_TAG_INDIRECT) {
1998 return ICON_PACKAGE_INDIRECT;
1999 }
2000 return ICON_PACKAGE;
2001 }
2002 if (id->tag & ID_TAG_MISSING) {
2003 return ICON_LIBRARY_DATA_BROKEN;
2004 }
2005 if (id->tag & ID_TAG_INDIRECT) {
2006 return ICON_LIBRARY_DATA_INDIRECT;
2007 }
2008 return ICON_LIBRARY_DATA_DIRECT;
2009 }
2010 if (ID_IS_OVERRIDE_LIBRARY(id)) {
2011 if (!ID_IS_OVERRIDE_LIBRARY_REAL(id) ||
2012 (id->override_library->flag & LIBOVERRIDE_FLAG_SYSTEM_DEFINED) != 0)
2013 {
2014 return ICON_LIBRARY_DATA_OVERRIDE_NONEDITABLE;
2015 }
2016 return ICON_LIBRARY_DATA_OVERRIDE;
2017 }
2018 if (ID_IS_ASSET(id)) {
2019 return ICON_ASSET_MANAGER;
2020 }
2021
2022 return ICON_NONE;
2023}
2024
2025int icon_from_rnaptr(const bContext *C, PointerRNA *ptr, int rnaicon, const bool big)
2026{
2027 ID *id = nullptr;
2028
2029 if (!*ptr) {
2030 return rnaicon;
2031 }
2032
2033 /* Try ID, material, texture or dynamic-paint slot. */
2034 if (RNA_struct_is_ID(ptr->type)) {
2035 id = ptr->owner_id;
2036 }
2037 else if (RNA_struct_is_a(ptr->type, RNA_MaterialSlot)) {
2038 id = static_cast<ID *>(RNA_pointer_get(ptr, "material").data);
2039 }
2040 else if (RNA_struct_is_a(ptr->type, RNA_TextureSlot)) {
2041 id = static_cast<ID *>(RNA_pointer_get(ptr, "texture").data);
2042 }
2043 else if (RNA_struct_is_a(ptr->type, RNA_FileBrowserFSMenuEntry)) {
2044 return RNA_int_get(ptr, "icon");
2045 }
2046 else if (RNA_struct_is_a(ptr->type, RNA_DynamicPaintSurface)) {
2047 const DynamicPaintSurface *surface = static_cast<const DynamicPaintSurface *>(ptr->data);
2048
2049 if (surface->format == MOD_DPAINT_SURFACE_F_PTEX) {
2050 return ICON_SHADING_TEXTURE;
2051 }
2052 if (surface->format == MOD_DPAINT_SURFACE_F_VERTEX) {
2053 return ICON_OUTLINER_DATA_MESH;
2054 }
2055 if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
2056 return ICON_FILE_IMAGE;
2057 }
2058 }
2059 else if (RNA_struct_is_a(ptr->type, RNA_StudioLight)) {
2060 StudioLight *sl = static_cast<StudioLight *>(ptr->data);
2061 switch (sl->flag & STUDIOLIGHT_FLAG_ORIENTATIONS) {
2063 return sl->icon_id_irradiance;
2065 default:
2066 return sl->icon_id_radiance;
2068 return sl->icon_id_matcap;
2069 }
2070 }
2071
2072 /* get icon from ID */
2073 if (id) {
2074 const int icon = id_icon_get(C, id, big);
2075
2076 return icon ? icon : rnaicon;
2077 }
2078
2079 return rnaicon;
2080}
2081
2082int icon_from_idcode(const int idcode)
2083{
2084 switch (ID_Type(idcode)) {
2085 case ID_AC:
2086 return ICON_ACTION;
2087 case ID_AR:
2088 return ICON_ARMATURE_DATA;
2089 case ID_BR:
2090 return ICON_BRUSH_DATA;
2091 case ID_CA:
2092 return ICON_CAMERA_DATA;
2093 case ID_CF:
2094 return ICON_FILE;
2095 case ID_CU_LEGACY:
2096 return ICON_CURVE_DATA;
2097 case ID_GD_LEGACY:
2098 return ICON_OUTLINER_DATA_GREASEPENCIL;
2099 case ID_GR:
2100 return ICON_GROUP;
2101 case ID_IM:
2102 return ICON_IMAGE_DATA;
2103 case ID_LA:
2104 return ICON_LIGHT_DATA;
2105 case ID_LS:
2106 return ICON_LINE_DATA;
2107 case ID_LT:
2108 return ICON_LATTICE_DATA;
2109 case ID_MA:
2110 return ICON_MATERIAL_DATA;
2111 case ID_MB:
2112 return ICON_META_DATA;
2113 case ID_MC:
2114 return ICON_TRACKER;
2115 case ID_ME:
2116 return ICON_MESH_DATA;
2117 case ID_MSK:
2118 return ICON_MOD_MASK; /* TODO: this would need its own icon! */
2119 case ID_NT:
2120 return ICON_NODETREE;
2121 case ID_OB:
2122 return ICON_OBJECT_DATA;
2123 case ID_PA:
2124 return ICON_PARTICLE_DATA;
2125 case ID_PAL:
2126 return ICON_COLOR; /* TODO: this would need its own icon! */
2127 case ID_PC:
2128 return ICON_CURVE_BEZCURVE; /* TODO: this would need its own icon! */
2129 case ID_LP:
2130 return ICON_OUTLINER_DATA_LIGHTPROBE;
2131 case ID_SCE:
2132 return ICON_SCENE_DATA;
2133 case ID_SPK:
2134 return ICON_SPEAKER;
2135 case ID_SO:
2136 return ICON_SOUND;
2137 case ID_TE:
2138 return ICON_TEXTURE_DATA;
2139 case ID_TXT:
2140 return ICON_TEXT;
2141 case ID_VF:
2142 return ICON_FONT_DATA;
2143 case ID_CV:
2144 return ICON_CURVES_DATA;
2145 case ID_PT:
2146 return ICON_POINTCLOUD_DATA;
2147 case ID_VO:
2148 return ICON_VOLUME_DATA;
2149 case ID_WO:
2150 return ICON_WORLD_DATA;
2151 case ID_WS:
2152 return ICON_WORKSPACE;
2153 case ID_GP:
2154 return ICON_OUTLINER_DATA_GREASEPENCIL;
2155 case ID_KE:
2156 return ICON_SHAPEKEY_DATA;
2157
2158 /* No icons for these ID-types. */
2159 case ID_LI:
2160 case ID_SCR:
2161 case ID_WM:
2162 break;
2163 }
2164 return ICON_NONE;
2165}
2166
2167int icon_from_object_mode(const int mode)
2168{
2169 switch (eObjectMode(mode)) {
2170 case OB_MODE_OBJECT:
2171 return ICON_OBJECT_DATAMODE;
2172 case OB_MODE_EDIT:
2174 return ICON_EDITMODE_HLT;
2175 case OB_MODE_SCULPT:
2178 return ICON_SCULPTMODE_HLT;
2181 return ICON_VPAINT_HLT;
2184 return ICON_WPAINT_HLT;
2186 return ICON_TPAINT_HLT;
2188 return ICON_PARTICLEMODE;
2189 case OB_MODE_POSE:
2190 return ICON_POSE_HLT;
2192 return ICON_GREASEPENCIL;
2193 }
2194 return ICON_NONE;
2195}
2196
2198{
2199 switch (object->type) {
2200 case OB_LAMP:
2201 return ICON_OUTLINER_OB_LIGHT;
2202 case OB_MESH:
2203 return ICON_OUTLINER_OB_MESH;
2204 case OB_CAMERA:
2205 return ICON_OUTLINER_OB_CAMERA;
2206 case OB_CURVES_LEGACY:
2207 return ICON_OUTLINER_OB_CURVE;
2208 case OB_MBALL:
2209 return ICON_OUTLINER_OB_META;
2210 case OB_LATTICE:
2211 return ICON_OUTLINER_OB_LATTICE;
2212 case OB_ARMATURE:
2213 return ICON_OUTLINER_OB_ARMATURE;
2214 case OB_FONT:
2215 return ICON_OUTLINER_OB_FONT;
2216 case OB_SURF:
2217 return ICON_OUTLINER_OB_SURFACE;
2218 case OB_SPEAKER:
2219 return ICON_OUTLINER_OB_SPEAKER;
2220 case OB_LIGHTPROBE:
2221 return ICON_OUTLINER_OB_LIGHTPROBE;
2222 case OB_CURVES:
2223 return ICON_OUTLINER_OB_CURVES;
2224 case OB_POINTCLOUD:
2225 return ICON_OUTLINER_OB_POINTCLOUD;
2226 case OB_VOLUME:
2227 return ICON_OUTLINER_OB_VOLUME;
2228 case OB_EMPTY:
2229 if (object->instance_collection && (object->transflag & OB_DUPLICOLLECTION)) {
2230 return ICON_OUTLINER_OB_GROUP_INSTANCE;
2231 }
2232 else if (object->empty_drawtype == OB_EMPTY_IMAGE) {
2233 return ICON_OUTLINER_OB_IMAGE;
2234 }
2235 else if (object->pd && object->pd->forcefield) {
2236 return ICON_OUTLINER_OB_FORCE_FIELD;
2237 }
2238 else {
2239 return ICON_OUTLINER_OB_EMPTY;
2240 }
2241 case OB_GREASE_PENCIL:
2242 return ICON_OUTLINER_OB_GREASEPENCIL;
2243 case OB_GPENCIL_LEGACY:
2244 case OB_TYPE_MAX:
2245 break;
2246 }
2247 return ICON_NONE;
2248}
2249
2251{
2252 int icon = ICON_OUTLINER_COLLECTION;
2253
2254 if (collection->color_tag != COLLECTION_COLOR_NONE) {
2255 icon = ICON_COLLECTION_COLOR_01 + int(collection->color_tag);
2256 }
2257
2258 return icon;
2259}
2260
2261void icon_draw(float x, float y, int icon_id)
2262{
2264 x, y, icon_id, UI_INV_SCALE_FAC, 1.0f, 0.0f, nullptr, false, UI_NO_ICON_OVERLAY_TEXT);
2265}
2266
2267void icon_draw_alpha(float x, float y, int icon_id, float alpha)
2268{
2270 x, y, icon_id, UI_INV_SCALE_FAC, alpha, 0.0f, nullptr, false, UI_NO_ICON_OVERLAY_TEXT);
2271}
2272
2273void icon_draw_preview(float x, float y, int icon_id, float aspect, float alpha, int size)
2274{
2276 y,
2277 icon_id,
2278 aspect,
2279 alpha,
2281 size,
2282 false,
2283 nullptr,
2284 false,
2286}
2287
2288void icon_draw_ex(float x,
2289 float y,
2290 int icon_id,
2291 float aspect,
2292 float alpha,
2293 float desaturate,
2294 const uchar mono_color[4],
2295 const bool mono_border,
2296 const IconTextOverlay *text_overlay,
2297 const bool inverted,
2298 const float scale)
2299{
2300 const int draw_size = get_draw_size(ICON_SIZE_ICON) * scale;
2302 y,
2303 icon_id,
2304 aspect,
2305 alpha,
2307 draw_size,
2308 desaturate,
2309 mono_color,
2310 mono_border,
2311 text_overlay,
2312 inverted);
2313}
2314
2315ImBuf *svg_icon_bitmap(uint icon_id, float size, bool multicolor)
2316{
2317 if (icon_id >= ICON_BLANK_LAST_SVG_ITEM) {
2318 return nullptr;
2319 }
2320
2321 ImBuf *ibuf = nullptr;
2322 int width;
2323 int height;
2324 Array<uchar> bitmap;
2325
2326 if (multicolor) {
2327 bitmap = BLF_svg_icon_bitmap(icon_id, size, &width, &height, true, icon_source_edit_cb);
2328 }
2329 else {
2330 bitmap = BLF_svg_icon_bitmap(icon_id, size, &width, &height, false, nullptr);
2331 }
2332
2333 if (!bitmap.is_empty()) {
2334 ibuf = IMB_allocFromBuffer(bitmap.data(), nullptr, width, height, 4);
2335 }
2336
2337 if (ibuf) {
2338 IMB_flipy(ibuf);
2339 if (multicolor) {
2341 }
2342 }
2343
2344 return ibuf;
2345}
2346
2348 const int icon_indicator_number)
2349{
2350 /* The icon indicator is used as an aggregator, no need to show if it is 1. */
2351 if (icon_indicator_number < 2) {
2352 text_overlay->text[0] = '\0';
2353 return;
2354 }
2355 BLI_str_format_integer_unit(text_overlay->text, icon_indicator_number);
2356}
2357
2358/* ********** Alert Icons ********** */
2359
2361{
2362#ifdef WITH_HEADLESS
2363 UNUSED_VARS(icon, size);
2364 return nullptr;
2365#else
2366
2367 int icon_id = ICON_NONE;
2368 switch (icon) {
2369 case AlertIcon::Warning:
2370 icon_id = ICON_WARNING_LARGE;
2371 break;
2373 icon_id = ICON_QUESTION_LARGE;
2374 break;
2375 case AlertIcon::Error:
2376 icon_id = ICON_CANCEL_LARGE;
2377 break;
2378 case AlertIcon::Info:
2379 icon_id = ICON_INFO_LARGE;
2380 break;
2381 default:
2382 icon_id = ICON_NONE;
2383 }
2384
2385 if (icon_id == ICON_NONE) {
2386 return nullptr;
2387 }
2388
2389 return svg_icon_bitmap(icon_id, size, false);
2390#endif
2391}
2392
2393} // namespace blender::ui
#define ICON_RENDER_DEFAULT_HEIGHT
Definition BKE_icons.hh:185
#define STUDIOLIGHT_ICON_SIZE
#define STUDIOLIGHT_FLAG_ORIENTATIONS
#define CTX_IFACE_(context, msgid)
#define BLT_I18NCONTEXT_COLOR
#define CLOG_WARN(clg_ref,...)
Definition CLG_log.h:189
#define ID_IS_PACKED(_id)
Definition DNA_ID.h:703
#define ID_IS_OVERRIDE_LIBRARY_REAL(_id)
Definition DNA_ID.h:729
#define ID_IS_LINKED(_id)
Definition DNA_ID.h:697
#define ID_IS_ASSET(_id)
Definition DNA_ID.h:743
#define ID_IS_OVERRIDE_LIBRARY(_id)
Definition DNA_ID.h:736
Enumerations for DNA_ID.h.
Object groups, one object can be in many groups at once.
#define SPACE_TYPE_ANY
#define UI_SCALE_FAC
#define UI_INV_SCALE_FAC
#define UI_ICON_SIZE
#define PREVIEW_RENDER_DEFAULT_HEIGHT
Definition IMB_thumbs.hh:76
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define UI_FSTYLE_WIDGET
#define UI_UNIT_X
#define ICON_DEFAULT_HEIGHT
#define ICON_DEFAULT_HEIGHT_TOOLBAR
#define PREVIEW_DEFAULT_HEIGHT
#define UI_NO_ICON_OVERLAY_TEXT
#define ICON_DEFAULT_WIDTH
#define TH_UNDEFINED
#define NC_WINDOW
Definition WM_types.hh:388
#define KM_MOD_NUM
Definition WM_types.hh:310
#define KM_MOD_HELD
Definition WM_types.hh:339
#define UNUSED_VARS(...)
#define ELEM(...)
#define BLI_assert_msg(a, msg)
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
const T * data() const
Definition BLI_array.hh:323
bool is_empty() const
Definition BLI_array.hh:275
void draw(float x, float y, int img_w, int img_h, gpu::TextureFormat gpu_format, bool use_filter, const void *rect, float scale_x, float scale_y, const float color[4])
Definition glutil.cc:45
constexpr StringRef()
constexpr int64_t size() const
constexpr int64_t find(char c, int64_t pos=0) const
#define str(s)
#define image(slot, qualifiers, format)
TEX_TEMPLATE DataVec texture(T, FltCoord, float=0.0f) RET
float2x2 invert(float2x2 mat)
float3x3 scale(float3x3 mat, float2 scale)
#define DEF_ICON_VECTOR_COLORSET_DRAW_NTH(prefix, index)
#define ICON_INDIRECT_DATA_ALPHA
#define ICON_TYPE_SVG_MONO
#define DEF_ICON_NODE_SOCKET_DRAW(name, socket_type)
#define ICON_TYPE_GEOM
#define ICON_TYPE_EVENT
#define ICON_TYPE_BUFFER
#define ICON_TYPE_SVG_COLOR
#define ICON_TYPE_GPLAYER
#define ICON_TYPE_PREVIEW
#define ICON_TYPE_IMBUF
#define ICON_TYPE_VECTOR
#define INIT_EVENT_ICON(icon_id, type, value)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
ccl_device_inline float2 mask(const MaskType mask, const float2 a)
ccl_device_inline float3x3 inverted(const float3x3 m)
void std_node_socket_colors_get(int socket_type, float *r_color)
Definition drawnode.cc:1056
void node_draw_nodesocket(const rctf *rect, const float color_inner[4], const float color_outline[4], float outline_thickness, int shape, float aspect)
Definition drawnode.cc:1988
void get_color_4ubv(int colorid, unsigned char col[4])
void theme_store(bThemeState *theme_state)
void theme_set(int spacetype, int regionid)
void get_color_type_4ubv(int colorid, int spacetype, unsigned char col[4])
void get_color_4fv(int colorid, float col[4])
const bTheme * theme_get()
void theme_restore(const bThemeState *theme_state)
bool get_icon_color_4ubv(int colorid, unsigned char col[4])
void get_color_type_4fv(int colorid, int spacetype, float col[4])
void icon_text_overlay_init_from_count(IconTextOverlay *text_overlay, const int icon_indicator_number)
int icon_from_event_type(short event_type, short event_value)
int icon_from_object_type(const Object *object)
static void vicon_rgb_blue_draw(float x, float y, float w, float h, float alpha, const uchar mono_rgba[4])
static void icon_verify_datatoc(IconImage *iimg)
static void vicon_keytype_extreme_draw(float x, float y, float w, float h, float alpha, const uchar *)
ImBuf * icon_alert_imbuf_get(AlertIcon icon, float size)
static void vicon_handletype_vector_draw(float x, float y, float w, float h, float alpha, const uchar *)
bool icon_is_preview_deferred_loading(const int icon_id, const bool big)
static DrawInfo * def_internal_icon(ImBuf *bbuf, int icon_id, int xofs, int yofs, int size, int type, int theme_color)
static void init_internal_icons()
static void vicon_strip_color_draw(short color_tag, float x, float y, float w, float, float)
static void vicon_strip_color_draw_library_data_override_noneditable(float x, float y, float w, float, float alpha, const uchar *)
static const IconType icontypes[]
static void vicon_keytype_breakdown_draw(float x, float y, float w, float h, float alpha, const uchar *)
static void vicon_handletype_auto_clamp_draw(float x, float y, float w, float h, float alpha, const uchar *)
static void vicon_colorset_draw(int index, int x, int y, int w, int h, float)
int icon_from_keymap_item(const wmKeyMapItem *kmi, int r_icon_mod[KM_MOD_NUM])
static void init_event_icons()
static void vicon_keytype_generated_draw(float x, float y, float w, float h, float alpha, const uchar *)
static DrawInfo * icon_ensure_drawinfo(Icon *icon)
bool icon_get_theme_color(int icon_id, unsigned char color[4])
static void vicon_rgb_green_draw(float x, float y, float w, float h, float alpha, const uchar mono_rgba[4])
void icons_free_drawinfo(void *drawinfo)
static CLG_LogRef LOG
Definition interface.cc:82
static void vicon_handletype_aligned_draw(float x, float y, float w, float h, float alpha, const uchar *)
static int id_screen_get_icon(const bContext *C, ID *id)
DEF_ICON_LAYERGROUP_COLOR_DRAW(01, LAYERGROUP_COLOR_01)
static void vicon_handletype_free_draw(float x, float y, float w, float h, float alpha, const uchar *)
static void vicon_handletype_auto_draw(float x, float y, float w, float h, float alpha, const uchar *)
int icon_from_idcode(int idcode)
static void vicon_keytype_moving_hold_draw(float x, float y, float w, float h, float alpha, const uchar *)
void icon_draw_ex(float x, float y, int icon_id, float aspect, float alpha, float desaturate, const uchar mono_color[4], bool mono_border, const IconTextOverlay *text_overlay, const bool inverted=false, float scale=1.0f)
static void id_icon_render(const bContext *C, ID *id, bool use_jobs)
static void vicon_rgb_text_draw(float x, float y, float w, float h, const char *str, const uchar mono_rgba[4])
static void vicon_gplayer_color_draw(Icon *icon, int x, int y, int w, int h)
static void studiolight_icon_job_exec(void *customdata, wmJobWorkerStatus *)
int id_icon_get(const bContext *C, ID *id, const bool big)
int icon_from_object_mode(int mode)
DEF_ICON_STRIP_COLOR_DRAW(01, STRIP_COLOR_01)
void fontstyle_draw(const uiFontStyle *fs, const rcti *rect, const char *str, size_t str_len, const uchar col[4], const FontStyleDrawParams *fs_params)
static void icon_node_socket_draw(int socket_type, float x, float y, float w, float h, float)
static void svg_replace_color_attributes(std::string &svg, const std::string &name, const size_t start, const size_t end)
static DrawInfo * icon_create_drawinfo(Icon *icon)
void widgetbase_draw_cache_flush()
void(*)(float x, float y, float w, float h, float alpha, const uchar mono_rgba[4]) VectorDrawFunc
void draw_roundbox_corner_set(int type)
void icon_draw_preview(float x, float y, int icon_id, float aspect, float alpha, int size)
static void studiolight_kill_icon_preview_job(wmWindowManager *wm, int icon_id)
void icon_render_id_ex(const bContext *C, Scene *scene, ID *id_to_render, const enum eIconSizes size, const bool use_job, PreviewImage *r_preview_image)
static void icon_create_rect(PreviewImage *prv_img, enum eIconSizes size)
static void icon_set_image(const bContext *C, Scene *scene, ID *id, PreviewImage *prv_img, enum eIconSizes size, const bool use_job)
static void vicon_keytype_keyframe_draw(float x, float y, float w, float h, float alpha, const uchar *)
static void def_internal_vicon(int icon_id, VectorDrawFunc drawFunc)
int icon_from_rnaptr(const bContext *C, PointerRNA *ptr, int rnaicon, bool big)
static void icon_draw_rect(float x, float y, int w, int h, int rw, int rh, const uint8_t *rect, float alpha, const float desaturate)
void draw_roundbox_4fv_ex(const rctf *rect, const float inner1[4], const float inner2[4], float shade_dir, const float outline[4], float outline_width, float rad)
static int get_draw_size(enum eIconSizes size)
static void vicon_strip_color_draw_package_indirect(float x, float y, float w, float, float alpha, const uchar *)
static void id_preview_image_render_size(const bContext *C, Scene *scene, ID *id, PreviewImage *pi, int size, const bool use_job)
static void studiolight_free_function(StudioLight *sl, void *data)
static void vicon_strip_color_draw_library_data_indirect(float x, float y, float w, float, float alpha, const uchar *)
void icon_draw(float x, float y, int icon_id)
void icon_render_id(const bContext *C, Scene *scene, ID *id, enum eIconSizes size, bool use_job)
int icon_color_from_collection(const Collection *collection)
void icon_draw_alpha(float x, float y, int icon_id, float alpha)
static void studiolight_icon_job_end(void *customdata)
static void icon_source_edit_cb(std::string &svg)
int icon_from_library(const ID *id)
void icon_draw_rect_input(const float x, const float y, const int w, const int h, const int icon_id, const float aspect, const float alpha, const bool inverted)
static void vicon_layergroup_color_draw(short color_tag, float x, float y, float w, float, float)
static void vicon_keytype_draw_wrapper(const float x, const float y, const float w, const float h, const float alpha, const eBezTriple_KeyframeType key_type, const short handle_type)
static void icon_draw_size(float x, float y, int icon_id, float aspect, float alpha, enum eIconSizes size, int draw_size, const float desaturate, const uchar mono_rgba[4], const bool mono_border, const IconTextOverlay *text_overlay, const bool inverted=false)
static DrawInfo * g_di_event_list
void icon_ensure_deferred(const bContext *C, int icon_id, bool big)
int icon_preview_to_render_size(enum eIconSizes size)
ImBuf * svg_icon_bitmap(uint icon_id, float size, bool multicolor=false)
static void vicon_rgb_red_draw(float x, float y, float w, float h, float alpha, const uchar mono_rgba[4])
PreviewImage * icon_to_preview(int icon_id)
static void vicon_keytype_jitter_draw(float x, float y, float w, float h, float alpha, const uchar *)
static void vicon_rgb_color_draw(float x, float y, float w, float h, const float color[4], float bg_alpha)
ImBuf * BKE_icon_geom_rasterize(const Icon_Geom *geom, unsigned int size_x, unsigned int size_y)
bool ED_preview_id_render_is_supported(const ID *id, const char **r_disabled_hint=nullptr)
void BKE_studiolight_preview(uint *icon_buffer, StudioLight *sl, int icon_id_type)
UserDef U
Definition blender.cc:58
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ BEZT_KEYTYPE_MOVEHOLD
@ BEZT_KEYTYPE_GENERATED
@ BEZT_KEYTYPE_KEYFRAME
@ BEZT_KEYTYPE_BREAKDOWN
MINLINE void rgba_uchar_to_float(float r_col[4], const unsigned char col_ub[4])
@ STUDIOLIGHT_TYPE_MATCAP
@ STUDIOLIGHT_TYPE_STUDIO
@ STUDIOLIGHT_TYPE_WORLD
@ NUM_ICON_SIZES
@ ICON_SIZE_ICON
@ ICON_SIZE_PREVIEW
void BLF_position(int fontid, float x, float y, float z)
Definition blf.cc:390
void immEnd()
void WM_jobs_callbacks(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *))
Definition wm_jobs.cc:407
bool RNA_struct_is_a(const StructRNA *type, const StructRNA *srna)
unsigned int uint
Definition BKE_text.h:55
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
MINLINE int round_fl_to_int(float a)
MINLINE unsigned char srgb_to_grayscale_byte(const unsigned char rgb[3])
int BKE_icon_id_ensure(ID *id)
Definition icons.cc:279
void BLF_draw_svg_icon(uint icon_id, float x, float y, float size, const float color[4]=nullptr, float outline_alpha=1.0f, bool multicolor=false, FunctionRef< void(std::string &)> edit_source_cb=nullptr)
Definition blf.cc:628
void draw_keyframe_shape(const float x, const float y, float size, const bool sel, const eBezTriple_KeyframeType key_type, const eKeyframeShapeDrawOpts mode, const float alpha, const KeyframeShaderBindings *sh_bindings, const short handle_type, const short extreme_type)
void immUniform2f(const char *name, float x, float y)
@ SOCK_DISPLAY_SHAPE_CIRCLE
bool ED_preview_use_image_size(const PreviewImage *preview, eIconSizes size)
GPUVertFormat * immVertexFormat()
@ WM_JOB_TYPE_STUDIOLIGHT
Definition WM_api.hh:2041
bool BKE_previewimg_is_invalid(const PreviewImage *prv, int size)
void immBegin(GPUPrimType, uint vertex_len)
void BKE_icon_set(int icon_id, Icon *icon)
Definition icons.cc:507
void BKE_icons_free()
Definition icons.cc:185
@ ICON_DATA_GPLAYER
Definition BKE_icons.hh:42
@ ICON_DATA_GEOM
Definition BKE_icons.hh:38
@ ICON_DATA_STUDIOLIGHT
Definition BKE_icons.hh:40
@ ICON_DATA_ID
Definition BKE_icons.hh:32
@ ICON_DATA_IMBUF
Definition BKE_icons.hh:34
@ ICON_DATA_PREVIEW
Definition BKE_icons.hh:36
int RNA_int_get(PointerRNA *ptr, const char *name)
Icon * BKE_icon_get(int icon_id)
Definition icons.cc:491
wmWindow * CTX_wm_window(const bContext *C)
@ TH_ICON_OBJECT_DATA
@ TH_ICON_COLLECTION
void BKE_icon_geom_invert_lightness(Icon_Geom *geom)
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *customdata))
Definition wm_jobs.cc:377
void BKE_preview_images_free()
@ WM_JOB_BACKGROUND
Definition WM_api.hh:1999
void BKE_studiolight_set_free_function(StudioLight *sl, StudioLightFreeFunction *free_function, void *data)
void MEM_delete_void(void *vmemh)
@ LIBOVERRIDE_FLAG_SYSTEM_DEFINED
Definition DNA_ID.h:308
void immUnbindProgram()
bool BKE_previewimg_id_supports_jobs(const ID *id)
void immUniformColor3ubv(const unsigned char rgb[3])
@ GPU_BLEND_ALPHA
Definition GPU_state.hh:90
@ GPU_BLEND_ALPHA_PREMULT
Definition GPU_state.hh:91
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:498
Global G
Definition blender.cc:57
void immBindBuiltinProgram(GPUBuiltinShader shader_id)
void BLF_size(int fontid, float size)
Definition blf.cc:445
void IMB_freeImBuf(ImBuf *ibuf)
VecBase< float, 2 > float2
void immUniform1f(const char *name, float x)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
unsigned char uchar
Definition BKE_text.h:58
@ OB_MODE_VERTEX_GREASE_PENCIL
@ OB_MODE_TEXTURE_PAINT
@ OB_MODE_SCULPT_GREASE_PENCIL
@ OB_MODE_SCULPT_CURVES
@ OB_MODE_EDIT_GPENCIL_LEGACY
@ OB_MODE_PARTICLE_EDIT
@ OB_MODE_WEIGHT_GREASE_PENCIL
@ OB_MODE_PAINT_GREASE_PENCIL
BMesh const char void * data
int BLF_default()
@ GPU_SHADER_2D_IMAGE_DESATURATE_COLOR
wmWindowManager * CTX_wm_manager(const bContext *C)
unsigned char uint8_t
Definition BKE_text.h:79
void IMB_flipy(ImBuf *ibuf)
PreviewImage * BKE_previewimg_id_ensure(ID *id)
void GPU_program_point_size(bool enable)
Definition gpu_state.cc:165
MINLINE void copy_v4_v4_uchar(unsigned char r[4], const unsigned char a[4])
void BLF_draw(int fontid, const char *str, size_t str_len, ResultBLF *r_info=nullptr) ATTR_NONNULL(2)
Definition blf.cc:587
uint GPU_vertformat_attr_add(GPUVertFormat *format, StringRef name, gpu::VertAttrType type)
PreviewImage * BKE_previewimg_id_get(const ID *id)
void BLF_color4ubv(int fontid, const unsigned char rgba[4])
Definition blf.cc:454
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
bool RNA_struct_is_ID(const StructRNA *type)
bool BKE_previewimg_is_finished(const PreviewImage *prv, int size)
PreviewImage * BKE_previewimg_create()
ImBuf * IMB_load_image_from_memory(const unsigned char *mem, size_t size, ImBufFlags flags, const char *descr, const char *filepath=nullptr, ColorManagedColorspaceSettings *colorspace_settings=nullptr)
Definition readimage.cc:132
void WM_jobs_kill_type(wmWindowManager *wm, const void *owner, int job_type)
Definition wm_jobs.cc:642
bool BKE_previewimg_is_rendering(const PreviewImage *prv, int size)
wmJob * WM_jobs_get(wmWindowManager *wm, wmWindow *win, const void *owner, const char *name, const eWM_JobFlag flag, const eWM_JobType job_type)
Definition wm_jobs.cc:228
void BLI_str_format_integer_unit(char dst[BLI_STR_FORMAT_INT32_INTEGER_UNIT_SIZE], int number_to_format) ATTR_NONNULL(1)
ImBuf * IMB_allocFromBuffer(const uint8_t *byte_buffer, const float *float_buffer, unsigned int w, unsigned int h, unsigned int channels)
ID_Type GS(const char *name)
Definition DNA_ID.h:410
PreviewImage * BKE_previewimg_copy(const PreviewImage *prv)
@ ID_TAG_MISSING
Definition DNA_ID.h:870
@ ID_TAG_INDIRECT
Definition DNA_ID.h:851
Array< uchar > BLF_svg_icon_bitmap(uint icon_id, float size, int *r_width, int *r_height, bool multicolor=false, FunctionRef< void(std::string &)> edit_source_cb=nullptr)
Definition blf.cc:667
@ KM_NOTHING
Definition WM_types.hh:323
@ KM_PRESS_DRAG
Definition WM_types.hh:332
@ KM_DBL_CLICK
Definition WM_types.hh:327
Scene * CTX_data_scene(const bContext *C)
void immUniformColor3fv(const float rgb[3])
void GPU_blend(GPUBlend blend)
Definition gpu_state.cc:44
@ PRV_USER_EDITED
Definition DNA_ID.h:620
@ PRV_CHANGED
Definition DNA_ID.h:618
bool IMB_scale(ImBuf *ibuf, int2 new_size, IMBScaleFilter filter, bool threaded=true)
Definition scaling.cc:467
void BLF_width_and_height(int fontid, const char *str, size_t str_len, float *r_width, float *r_height) ATTR_NONNULL()
Definition blf.cc:822
void immRectf(uint pos, float x1, float y1, float x2, float y2)
void WM_jobs_timer(wmJob *wm_job, double time_step, uint note, uint endnote, void(*timer_step)(void *))
Definition wm_jobs.cc:393
void ED_preview_icon_render(const bContext *C, Scene *scene, PreviewImage *prv_img, ID *id, enum eIconSizes icon_size)
void ED_preview_icon_job(const bContext *C, PreviewImage *prv_img, ID *id, enum eIconSizes icon_size, bool delay)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void IMB_premultiply_alpha(ImBuf *ibuf)
Definition filter.cc:382
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
unsigned char color[4]
unsigned char anim_interpolation_constant[4]
unsigned char vertex_select[4]
unsigned char anim_interpolation_other[4]
unsigned char anim_interpolation_linear[4]
unsigned char color[4]
float icon_border_intensity
float icon_alpha
uiWidgetColors wcol_regular
uiWidgetColors wcol_toolbar_item
unsigned char select[4]
unsigned char solid[4]
unsigned char active[4]
ThemeStripColor strip_color[9]
ThemeSpace space_action
ThemeSpace space_view3d
ThemeUI tui
ThemeWireColor tarm[20]
ThemeCollectionColor collection_color[8]
CollectionColorTag color_tag
eDynamicPaint_SurfaceFormat format
DrawInfoFreeFP drawinfo_free
Definition BKE_icons.hh:61
void * drawinfo
Definition BKE_icons.hh:49
const uint8_t * byte_data() const
StructRNA * type
Definition RNA_types.hh:63
unsigned int w[2]
Definition DNA_ID.h:645
bke::PreviewImageRuntime * runtime
Definition DNA_ID.h:651
unsigned int * rect[2]
Definition DNA_ID.h:649
unsigned int h[2]
Definition DNA_ID.h:646
short changed_timestamp[2]
Definition DNA_ID.h:648
std::unique_ptr< PreviewDeferredLoadingData > deferred_loading_data
union blender::ui::DrawInfo::@334326232056141106073126217337134224203025371246 data
unsigned char inner[4]
ccl_device_inline bool is_light(const ccl_global KernelLightTreeEmitter *kemitter)
Definition tree.h:69
struct blender::ui::DrawInfo::@334326232056141106073126217337134224203025371246::@374125343222203213217151275235361232147360213240 texture
struct blender::ui::DrawInfo::@334326232056141106073126217337134224203025371246::@313320217317367277317032242220231366344326253252 geom
struct blender::ui::DrawInfo::@334326232056141106073126217337134224203025371246::@364322345027076070207110134263063104142142125314 input
struct blender::ui::DrawInfo::@334326232056141106073126217337134224203025371246::@364063327322304267276054045235213143071233365241 buffer
struct blender::ui::DrawInfo::@334326232056141106073126217337134224203025371246::@051330342100043267354310071366107060070076372114 vector