source/blender/editors/space_image/image_edit.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2008 Blender Foundation.
  19  * All rights reserved.
  20  *
  21  *
  22  * Contributor(s): Blender Foundation
  23  *
  24  * ***** END GPL LICENSE BLOCK *****
  25  */
  26
  27 /** \file blender/editors/space_image/image_edit.c
  28  *  \ingroup spimage
  29  */
  30
  31 #include "DNA_brush_types.h"
  32 #include "DNA_mask_types.h"
  33 #include "DNA_object_types.h"
  34 #include "DNA_scene_types.h"
  35
  36 #include "BLI_rect.h"
  37
  38 #include "BKE_colortools.h"
  39 #include "BKE_context.h"
  40 #include "BKE_global.h"
  41 #include "BKE_image.h"
  42 #include "BKE_editmesh.h"
  43 #include "BKE_library.h"
  44
  45 #include "IMB_imbuf_types.h"
  46
  47 #include "ED_image.h"  /* own include */
  48 #include "ED_mesh.h"
  49 #include "ED_screen.h"
  50 #include "ED_uvedit.h"
  51
  52 #include "UI_view2d.h"
  53
  54 #include "WM_api.h"
  55 #include "WM_types.h"
  56
  57 /* note; image_panel_properties() uses pointer to sima->image directly */
  58 Image *ED_space_image(SpaceImage *sima)
  59 {
  60         return sima->image;
  61 }
  62
  63 /* called to assign images to UV faces */
  64 void ED_space_image_set(SpaceImage *sima, Scene *scene, Object *obedit, Image *ima)
  65 {
  66         /* context may be NULL, so use global */
  67         ED_uvedit_assign_image(G.main, scene, obedit, ima, sima->image);
  68
  69         /* change the space ima after because uvedit_face_visible_test uses the space ima
  70          * to check if the face is displayed in UV-localview */
  71         sima->image = ima;
  72
  73         if (ima == NULL || ima->type == IMA_TYPE_R_RESULT || ima->type == IMA_TYPE_COMPOSITE) {
  74                 if (sima->mode == SI_MODE_PAINT) {
  75                         sima->mode = SI_MODE_VIEW;
  76                 }
  77         }
  78
  79         if (sima->image)
  80                 BKE_image_signal(sima->image, &sima->iuser, IMA_SIGNAL_USER_NEW_IMAGE);
  81
  82         id_us_ensure_real((ID *)sima->image);
  83
  84         if (obedit)
  85                 WM_main_add_notifier(NC_GEOM | ND_DATA, obedit->data);
  86
  87         WM_main_add_notifier(NC_SPACE | ND_SPACE_IMAGE, NULL);
  88 }
  89
  90 Mask *ED_space_image_get_mask(SpaceImage *sima)
  91 {
  92         return sima->mask_info.mask;
  93 }
  94
  95 void ED_space_image_set_mask(bContext *C, SpaceImage *sima, Mask *mask)
  96 {
  97         sima->mask_info.mask = mask;
  98
  99         /* weak, but same as image/space */
 100         id_us_ensure_real((ID *)sima->mask_info.mask);
 101
 102         if (C) {
 103                 WM_event_add_notifier(C, NC_MASK | NA_SELECTED, mask);
 104         }
 105 }
 106
 107 ImBuf *ED_space_image_acquire_buffer(SpaceImage *sima, void **r_lock)
 108 {
 109         ImBuf *ibuf;
 110
 111         if (sima && sima->image) {
 112 #if 0
 113                 if (sima->image->type == IMA_TYPE_R_RESULT && BIF_show_render_spare())
 114                         return BIF_render_spare_imbuf();
 115                 else
 116 #endif
 117                 ibuf = BKE_image_acquire_ibuf(sima->image, &sima->iuser, r_lock);
 118
 119                 if (ibuf) {
 120                         if (ibuf->rect || ibuf->rect_float)
 121                                 return ibuf;
 122                 }
 123         }
 124         else
 125                 *r_lock = NULL;
 126
 127         return NULL;
 128 }
 129
 130 void ED_space_image_release_buffer(SpaceImage *sima, ImBuf *ibuf, void *lock)
 131 {
 132         if (sima && sima->image)
 133                 BKE_image_release_ibuf(sima->image, ibuf, lock);
 134 }
 135
 136 bool ED_space_image_has_buffer(SpaceImage *sima)
 137 {
 138         ImBuf *ibuf;
 139         void *lock;
 140         bool has_buffer;
 141
 142         ibuf = ED_space_image_acquire_buffer(sima, &lock);
 143         has_buffer = (ibuf != NULL);
 144         ED_space_image_release_buffer(sima, ibuf, lock);
 145
 146         return has_buffer;
 147 }
 148
 149 void ED_space_image_get_size(SpaceImage *sima, int *width, int *height)
 150 {
 151         Scene *scene = sima->iuser.scene;
 152         ImBuf *ibuf;
 153         void *lock;
 154
 155         ibuf = ED_space_image_acquire_buffer(sima, &lock);
 156
 157         if (ibuf && ibuf->x > 0 && ibuf->y > 0) {
 158                 *width = ibuf->x;
 159                 *height = ibuf->y;
 160         }
 161         else if (sima->image && sima->image->type == IMA_TYPE_R_RESULT && scene) {
 162                 /* not very important, just nice */
 163                 *width = (scene->r.xsch * scene->r.size) / 100;
 164                 *height = (scene->r.ysch * scene->r.size) / 100;
 165
 166                 if ((scene->r.mode & R_BORDER) && (scene->r.mode & R_CROP)) {
 167                         *width  *= BLI_rctf_size_x(&scene->r.border);
 168                         *height *= BLI_rctf_size_y(&scene->r.border);
 169                 }
 170
 171         }
 172         /* I know a bit weak... but preview uses not actual image size */
 173         // XXX else if (image_preview_active(sima, width, height));
 174         else {
 175                 *width  = IMG_SIZE_FALLBACK;
 176                 *height = IMG_SIZE_FALLBACK;
 177         }
 178
 179         ED_space_image_release_buffer(sima, ibuf, lock);
 180 }
 181
 182 void ED_space_image_get_size_fl(SpaceImage *sima, float size[2])
 183 {
 184         int size_i[2];
 185         ED_space_image_get_size(sima, &size_i[0], &size_i[1]);
 186         size[0] = size_i[0];
 187         size[1] = size_i[1];
 188 }
 189
 190
 191 void ED_space_image_get_aspect(SpaceImage *sima, float *aspx, float *aspy)
 192 {
 193         Image *ima = sima->image;
 194         if ((ima == NULL) || (ima->aspx == 0.0f || ima->aspy == 0.0f)) {
 195                 *aspx = *aspy = 1.0;
 196         }
 197         else {
 198                 BKE_image_get_aspect(ima, aspx, aspy);
 199         }
 200 }
 201
 202 void ED_space_image_get_zoom(SpaceImage *sima, ARegion *ar, float *zoomx, float *zoomy)
 203 {
 204         int width, height;
 205
 206         ED_space_image_get_size(sima, &width, &height);
 207
 208         *zoomx = (float)(BLI_rcti_size_x(&ar->winrct) + 1) / (float)(BLI_rctf_size_x(&ar->v2d.cur) * width);
 209         *zoomy = (float)(BLI_rcti_size_y(&ar->winrct) + 1) / (float)(BLI_rctf_size_y(&ar->v2d.cur) * height);
 210 }
 211
 212 void ED_space_image_get_uv_aspect(SpaceImage *sima, float *aspx, float *aspy)
 213 {
 214         int w, h;
 215
 216         ED_space_image_get_aspect(sima, aspx, aspy);
 217         ED_space_image_get_size(sima, &w, &h);
 218
 219         *aspx *= (float)w;
 220         *aspy *= (float)h;
 221
 222         if (*aspx < *aspy) {
 223                 *aspy = *aspy / *aspx;
 224                 *aspx = 1.0f;
 225         }
 226         else {
 227                 *aspx = *aspx / *aspy;
 228                 *aspy = 1.0f;
 229         }
 230 }
 231
 232 void ED_image_get_uv_aspect(Image *ima, ImageUser *iuser, float *aspx, float *aspy)
 233 {
 234         if (ima) {
 235                 int w, h;
 236
 237                 BKE_image_get_aspect(ima, aspx, aspy);
 238                 BKE_image_get_size(ima, iuser, &w, &h);
 239
 240                 *aspx *= (float)w;
 241                 *aspy *= (float)h;
 242         }
 243         else {
 244                 *aspx = 1.0f;
 245                 *aspy = 1.0f;
 246         }
 247 }
 248
 249 /* takes event->mval */
 250 void ED_image_mouse_pos(SpaceImage *sima, ARegion *ar, const int mval[2], float co[2])
 251 {
 252         int sx, sy, width, height;
 253         float zoomx, zoomy;
 254
 255         ED_space_image_get_zoom(sima, ar, &zoomx, &zoomy);
 256         ED_space_image_get_size(sima, &width, &height);
 257
 258         UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &sx, &sy);
 259
 260         co[0] = ((mval[0] - sx) / zoomx) / width;
 261         co[1] = ((mval[1] - sy) / zoomy) / height;
 262 }
 263
 264 void ED_image_point_pos(SpaceImage *sima, ARegion *ar, float x, float y, float *xr, float *yr)
 265 {
 266         int sx, sy, width, height;
 267         float zoomx, zoomy;
 268
 269         ED_space_image_get_zoom(sima, ar, &zoomx, &zoomy);
 270         ED_space_image_get_size(sima, &width, &height);
 271
 272         UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &sx, &sy);
 273
 274         *xr = ((x - sx) / zoomx) / width;
 275         *yr = ((y - sy) / zoomy) / height;
 276 }
 277
 278 void ED_image_point_pos__reverse(SpaceImage *sima, ARegion *ar, const float co[2], float r_co[2])
 279 {
 280         float zoomx, zoomy;
 281         int width, height;
 282         int sx, sy;
 283
 284         UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &sx, &sy);
 285         ED_space_image_get_size(sima, &width, &height);
 286         ED_space_image_get_zoom(sima, ar, &zoomx, &zoomy);
 287
 288         r_co[0] = (co[0] * width  * zoomx) + (float)sx;
 289         r_co[1] = (co[1] * height * zoomy) + (float)sy;
 290 }
 291
 292 /**
 293  * This is more a user-level functionality, for going to next/prev used slot,
 294  * Stepping onto the last unused slot too.
 295  */
 296 bool ED_image_slot_cycle(struct Image *image, int direction)
 297 {
 298         const int cur = image->render_slot;
 299         int i, slot;
 300
 301         BLI_assert(ELEM(direction, -1, 1));
 302
 303         for (i = 1; i < IMA_MAX_RENDER_SLOT; i++) {
 304                 slot = (cur + ((direction == -1) ? -i : i)) % IMA_MAX_RENDER_SLOT;
 305                 if (slot < 0) slot += IMA_MAX_RENDER_SLOT;
 306
 307                 if (image->renders[slot] || slot == image->last_render_slot) {
 308                         image->render_slot = slot;
 309                         break;
 310                 }
 311         }
 312
 313         if (i == IMA_MAX_RENDER_SLOT) {
 314                 image->render_slot = ((cur == 1) ? 0 : 1);
 315         }
 316
 317         return (cur != image->render_slot);
 318 }
 319
 320 void ED_space_image_scopes_update(const struct bContext *C, struct SpaceImage *sima, struct ImBuf *ibuf, bool use_view_settings)
 321 {
 322         Scene *scene = CTX_data_scene(C);
 323         Object *ob = CTX_data_active_object(C);
 324
 325         /* scope update can be expensive, don't update during paint modes */
 326         if (sima->mode == SI_MODE_PAINT)
 327                 return;
 328         if (ob && ((ob->mode & (OB_MODE_TEXTURE_PAINT | OB_MODE_EDIT)) != 0))
 329                 return;
 330
 331         scopes_update(&sima->scopes, ibuf, use_view_settings ? &scene->view_settings : NULL, &scene->display_settings);
 332 }
 333
 334 bool ED_space_image_show_render(SpaceImage *sima)
 335 {
 336         return (sima->image && ELEM(sima->image->type, IMA_TYPE_R_RESULT, IMA_TYPE_COMPOSITE));
 337 }
 338
 339 bool ED_space_image_show_paint(SpaceImage *sima)
 340 {
 341         if (ED_space_image_show_render(sima))
 342                 return false;
 343
 344         return (sima->mode == SI_MODE_PAINT);
 345 }
 346
 347 bool ED_space_image_show_uvedit(SpaceImage *sima, Object *obedit)
 348 {
 349         if (sima && (ED_space_image_show_render(sima) || ED_space_image_show_paint(sima)))
 350                 return false;
 351
 352         if (obedit && obedit->type == OB_MESH) {
 353                 struct BMEditMesh *em = BKE_editmesh_from_object(obedit);
 354                 bool ret;
 355
 356                 ret = EDBM_mtexpoly_check(em);
 357
 358                 return ret;
 359         }
 360
 361         return false;
 362 }
 363
 364 /* matches clip function */
 365 bool ED_space_image_check_show_maskedit(Scene *scene, SpaceImage *sima)
 366 {
 367         /* check editmode - this is reserved for UV editing */
 368         Object *ob = OBACT;
 369         if (ob && ob->mode & OB_MODE_EDIT && ED_space_image_show_uvedit(sima, ob)) {
 370                 return false;
 371         }
 372
 373         return (sima->mode == SI_MODE_MASK);
 374 }
 375
 376 int ED_space_image_maskedit_poll(bContext *C)
 377 {
 378         SpaceImage *sima = CTX_wm_space_image(C);
 379
 380         if (sima) {
 381                 Scene *scene = CTX_data_scene(C);
 382                 return ED_space_image_check_show_maskedit(scene, sima);
 383         }
 384
 385         return false;
 386 }
 387
 388 bool ED_space_image_paint_curve(const bContext *C)
 389 {
 390         SpaceImage *sima = CTX_wm_space_image(C);
 391
 392         if (sima && sima->mode == SI_MODE_PAINT) {
 393                 Brush *br = CTX_data_tool_settings(C)->imapaint.paint.brush;
 394
 395                 if (br && (br->flag & BRUSH_CURVE))
 396                         return true;
 397         }
 398
 399         return false;
 400 }
 401
 402
 403 int ED_space_image_maskedit_mask_poll(bContext *C)
 404 {
 405         if (ED_space_image_maskedit_poll(C)) {
 406                 SpaceImage *sima = CTX_wm_space_image(C);
 407                 return sima->mask_info.mask != NULL;
 408         }
 409
 410         return false;
 411 }
 412