void ui_icon_ensure_deferred(const bContext *C, const int icon_id, const bool big)
{
Icon *icon = BKE_icon_get(icon_id);
if (icon) {
DrawInfo *di = (DrawInfo *)icon->drawinfo;
if (!di) {
di = icon_create_drawinfo();
icon->drawinfo = di;
icon->drawinfo_free = UI_icons_free_drawinfo;
}
if (di) {
switch (di->type) {
case ICON_TYPE_PREVIEW:
{
ID *id = (icon->type != 0) ? icon->obj : NULL;
PreviewImage *prv = id ? BKE_previewimg_id_ensure(id) : icon->obj;
if (prv) {
const int size = big ? ICON_SIZE_PREVIEW : ICON_SIZE_ICON;
if (id || (prv->tag & PRV_TAG_DEFFERED) != 0) {
ui_id_preview_image_render_size(C, NULL, id, prv, size, true);
}
}
break;
}
}
}
}
}
static PointerRNA rna_IDPreview_get(PointerRNA *ptr)
{
ID *id = (ID *)ptr->data;
PreviewImage *prv_img = BKE_previewimg_id_ensure(id);
return rna_pointer_inherit_refine(ptr, &RNA_ImagePreview, prv_img);
}
void UI_id_icon_render(const bContext *C, Scene *scene, ID *id, const bool big, const bool use_job)
{
PreviewImage *pi = BKE_previewimg_id_ensure(id);
if (pi) {
if (big)
ui_id_preview_image_render_size(C, scene, id, pi, ICON_SIZE_PREVIEW, use_job); /* bigger preview size */
else
ui_id_preview_image_render_size(C, scene, id, pi, ICON_SIZE_ICON, use_job); /* icon size */
}
}
static void rna_ImagePreview_pixels_set(PointerRNA *ptr, const int *values, enum eIconSizes size)
{
ID *id = ptr->id.data;
PreviewImage *prv_img = (PreviewImage *)ptr->data;
if (id != NULL) {
BLI_assert(prv_img == BKE_previewimg_id_ensure(id));
}
memcpy(prv_img->rect[size], values, prv_img->w[size] * prv_img->h[size] * sizeof(unsigned int));
prv_img->flag[size] |= PRV_USER_EDITED;
}
static void rna_ImagePreview_pixels_get(PointerRNA *ptr, int *values, enum eIconSizes size)
{
ID *id = ptr->id.data;
PreviewImage *prv_img = (PreviewImage *)ptr->data;
if (id != NULL) {
BLI_assert(prv_img == BKE_previewimg_id_ensure(id));
}
BKE_previewimg_ensure(prv_img, size);
memcpy(values, prv_img->rect[size], prv_img->w[size] * prv_img->h[size] * sizeof(unsigned int));
}
static void rna_ImagePreview_size_get(PointerRNA *ptr, int *values, enum eIconSizes size)
{
ID *id = (ID *)ptr->id.data;
PreviewImage *prv_img = (PreviewImage *)ptr->data;
if (id != NULL) {
BLI_assert(prv_img == BKE_previewimg_id_ensure(id));
}
BKE_previewimg_ensure(prv_img, size);
values[0] = prv_img->w[size];
values[1] = prv_img->h[size];
}
static int rna_ImagePreview_pixels_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION], enum eIconSizes size)
{
ID *id = ptr->id.data;
PreviewImage *prv_img = (PreviewImage *)ptr->data;
if (id != NULL) {
BLI_assert(prv_img == BKE_previewimg_id_ensure(id));
}
BKE_previewimg_ensure(prv_img, size);
length[0] = prv_img->w[size] * prv_img->h[size];
return length[0];
}
/**
* Return icon id of given preview, or create new icon if not found.
*/
int BKE_icon_preview_ensure(ID *id, PreviewImage *preview)
{
Icon *new_icon = NULL;
if (!preview || G.background)
return 0;
if (id) {
BLI_assert(BKE_previewimg_id_ensure(id) == preview);
}
if (preview->icon_id) {
BLI_assert(!id || !id->icon_id || id->icon_id == preview->icon_id);
return preview->icon_id;
}
if (id && id->icon_id) {
preview->icon_id = id->icon_id;
return preview->icon_id;
}
preview->icon_id = get_next_free_id();
if (!preview->icon_id) {
printf("%s: Internal error - not enough IDs\n", __func__);
return 0;
}
/* Ensure we synchronize ID icon_id with its previewimage if available, and generate suitable 'ID' icon. */
if (id) {
id->icon_id = preview->icon_id;
return icon_id_ensure_create_icon(id);
}
new_icon = MEM_mallocN(sizeof(Icon), __func__);
new_icon->obj = preview;
new_icon->type = 0; /* Special, tags as non-ID icon/preview. */
/* next two lines make sure image gets created */
new_icon->drawinfo = NULL;
new_icon->drawinfo_free = NULL;
BLI_ghash_insert(gIcons, SET_INT_IN_POINTER(preview->icon_id), new_icon);
return preview->icon_id;
}
static void ui_id_brush_render(const bContext *C, ID *id)
{
PreviewImage *pi = BKE_previewimg_id_ensure(id);
enum eIconSizes i;
if (!pi)
return;
for (i = 0; i < NUM_ICON_SIZES; i++) {
/* check if rect needs to be created; changed
* only set by dynamic icons */
if (((pi->flag[i] & PRV_CHANGED) || !pi->rect[i])) {
icon_set_image(C, NULL, id, pi, i, true);
pi->flag[i] &= ~PRV_CHANGED;
}
}
}
static void rna_ImagePreview_pixels_float_set(PointerRNA *ptr, const float *values, enum eIconSizes size)
{
ID *id = ptr->id.data;
PreviewImage *prv_img = (PreviewImage *)ptr->data;
unsigned char *data = (unsigned char *)prv_img->rect[size];
const size_t len = prv_img->w[size] * prv_img->h[size] * 4;
size_t i;
BLI_assert(sizeof(unsigned int) == 4);
if (id != NULL) {
BLI_assert(prv_img == BKE_previewimg_id_ensure(id));
}
for (i = 0; i < len; i++) {
data[i] = FTOCHAR(values[i]);
}
prv_img->flag[size] |= PRV_USER_EDITED;
}
static void rna_ImagePreview_size_set(PointerRNA *ptr, const int *values, enum eIconSizes size)
{
ID *id = (ID *)ptr->id.data;
PreviewImage *prv_img = (PreviewImage *)ptr->data;
if (id != NULL) {
BLI_assert(prv_img == BKE_previewimg_id_ensure(id));
}
BKE_previewimg_clear_single(prv_img, size);
if (values[0] && values[1]) {
prv_img->rect[size] = MEM_callocN(values[0] * values[1] * sizeof(unsigned int), "prv_rect");
prv_img->w[size] = values[0];
prv_img->h[size] = values[1];
}
prv_img->flag[size] |= (PRV_CHANGED | PRV_USER_EDITED);
}
static void rna_ImagePreview_pixels_float_get(PointerRNA *ptr, float *values, enum eIconSizes size)
{
ID *id = ptr->id.data;
PreviewImage *prv_img = (PreviewImage *)ptr->data;
unsigned char *data = (unsigned char *)prv_img->rect[size];
const size_t len = prv_img->w[size] * prv_img->h[size] * 4;
size_t i;
BLI_assert(sizeof(unsigned int) == 4);
if (id != NULL) {
BLI_assert(prv_img == BKE_previewimg_id_ensure(id));
}
BKE_previewimg_ensure(prv_img, size);
for (i = 0; i < len; i++) {
values[i] = data[i] * (1.0f / 255.0f);
}
}
void BKE_icon_changed(int id)
{
Icon *icon = NULL;
if (!id || G.background) return;
icon = BLI_ghash_lookup(gIcons, SET_INT_IN_POINTER(id));
if (icon) {
PreviewImage *prv = BKE_previewimg_id_ensure((ID *)icon->obj);
/* all previews changed */
if (prv) {
int i;
for (i = 0; i < NUM_ICON_SIZES; ++i) {
prv->flag[i] |= PRV_CHANGED;
prv->changed_timestamp[i]++;
}
}
}
}
static void rna_ImagePreview_is_custom_set(PointerRNA *ptr, int value, enum eIconSizes size)
{
ID *id = ptr->id.data;
PreviewImage *prv_img = (PreviewImage *)ptr->data;
if (id != NULL) {
BLI_assert(prv_img == BKE_previewimg_id_ensure(id));
}
if ((value && (prv_img->flag[size] & PRV_USER_EDITED)) || (!value && !(prv_img->flag[size] & PRV_USER_EDITED))) {
return;
}
if (value)
prv_img->flag[size] |= PRV_USER_EDITED;
else
prv_img->flag[size] &= ~PRV_USER_EDITED;
prv_img->flag[size] |= PRV_CHANGED;
BKE_previewimg_clear_single(prv_img, size);
}
void ED_preview_icon_render(
Main *bmain, Scene *scene, ID *id, unsigned int *rect, int sizex, int sizey)
{
IconPreview ip = {NULL};
short stop = false, update = false;
float progress = 0.0f;
ED_preview_ensure_dbase();
ip.bmain = bmain;
ip.scene = scene;
ip.owner = BKE_previewimg_id_ensure(id);
ip.id = id;
ip.id_copy = duplicate_ids(id);
icon_preview_add_size(&ip, rect, sizex, sizey);
icon_preview_startjob_all_sizes(&ip, &stop, &update, &progress);
icon_preview_endjob(&ip);
BLI_freelistN(&ip.sizes);
}
PreviewImage *UI_icon_to_preview(int icon_id)
{
Icon *icon = BKE_icon_get(icon_id);
if (icon) {
DrawInfo *di = (DrawInfo *)icon->drawinfo;
if (di) {
if (di->type == ICON_TYPE_PREVIEW) {
PreviewImage *prv = (icon->type != 0) ? BKE_previewimg_id_ensure((ID *)icon->obj) : icon->obj;
if (prv) {
return BKE_previewimg_copy(prv);
}
}
else if (di->data.buffer.image) {
ImBuf *bbuf;
bbuf = IMB_ibImageFromMemory(di->data.buffer.image->datatoc_rect, di->data.buffer.image->datatoc_size,
IB_rect, NULL, __func__);
if (bbuf) {
PreviewImage *prv = BKE_previewimg_create();
prv->rect[0] = bbuf->rect;
prv->w[0] = bbuf->x;
prv->h[0] = bbuf->y;
bbuf->rect = NULL;
IMB_freeImBuf(bbuf);
return prv;
}
}
}
}
return NULL;
}
void ui_icon_ensure_deferred(const bContext *C, const int icon_id, const bool big)
{
Icon *icon = BKE_icon_get(icon_id);
if (icon) {
DrawInfo *di = (DrawInfo *)icon->drawinfo;
if (!di) {
di = icon_create_drawinfo();
icon->drawinfo = di;
icon->drawinfo_free = UI_icons_free_drawinfo;
}
if (di) {
if (di->type == ICON_TYPE_PREVIEW) {
PreviewImage *prv = (icon->type != 0) ? BKE_previewimg_id_ensure((ID *)icon->obj) : icon->obj;
if (prv) {
const int size = big ? ICON_SIZE_PREVIEW : ICON_SIZE_ICON;
if (!prv->use_deferred || prv->rect[size] || (prv->flag[size] & PRV_USER_EDITED)) {
return;
}
icon_create_rect(prv, size);
/* Always using job (background) version. */
ED_preview_icon_job(C, prv, NULL, prv->rect[size], prv->w[size], prv->h[size]);
prv->flag[size] &= ~PRV_CHANGED;
}
}
}
}
}
static void icon_draw_size(
float x, float y, int icon_id, float aspect, float alpha, const float rgb[3],
enum eIconSizes size, int draw_size, const bool UNUSED(nocreate), const bool is_preview)
{
bTheme *btheme = UI_GetTheme();
Icon *icon = NULL;
DrawInfo *di = NULL;
IconImage *iimg;
const float fdraw_size = (float)draw_size;
int w, h;
icon = BKE_icon_get(icon_id);
alpha *= btheme->tui.icon_alpha;
if (icon == NULL) {
if (G.debug & G_DEBUG)
printf("%s: Internal error, no icon for icon ID: %d\n", __func__, icon_id);
return;
}
di = (DrawInfo *)icon->drawinfo;
if (!di) {
di = icon_create_drawinfo();
icon->drawinfo = di;
icon->drawinfo_free = UI_icons_free_drawinfo;
}
/* scale width and height according to aspect */
w = (int)(fdraw_size / aspect + 0.5f);
h = (int)(fdraw_size / aspect + 0.5f);
if (di->type == ICON_TYPE_VECTOR) {
/* vector icons use the uiBlock transformation, they are not drawn
* with untransformed coordinates like the other icons */
di->data.vector.func((int)x, (int)y, w, h, 1.0f);
}
else if (di->type == ICON_TYPE_TEXTURE) {
/* texture image use premul alpha for correct scaling */
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
icon_draw_texture(x, y, (float)w, (float)h, di->data.texture.x, di->data.texture.y,
di->data.texture.w, di->data.texture.h, alpha, rgb);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
else if (di->type == ICON_TYPE_BUFFER) {
/* it is a builtin icon */
iimg = di->data.buffer.image;
#ifndef WITH_HEADLESS
icon_verify_datatoc(iimg);
#endif
if (!iimg->rect) return; /* something has gone wrong! */
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
icon_draw_rect(x, y, w, h, aspect, iimg->w, iimg->h, iimg->rect, alpha, rgb, is_preview);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
else if (di->type == ICON_TYPE_PREVIEW) {
PreviewImage *pi = (icon->type != 0) ? BKE_previewimg_id_ensure((ID *)icon->obj) : icon->obj;
if (pi) {
/* no create icon on this level in code */
if (!pi->rect[size]) return; /* something has gone wrong! */
/* preview images use premul alpha ... */
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
icon_draw_rect(x, y, w, h, aspect, pi->w[size], pi->h[size], pi->rect[size], alpha, rgb, is_preview);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
}
}
