Workbench: API Changes
[blender.git] / 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 #include "BKE_main.h"
45
46 #include "IMB_imbuf_types.h"
47
48 #include "DEG_depsgraph.h"
49
50 #include "ED_image.h"  /* own include */
51 #include "ED_mesh.h"
52 #include "ED_screen.h"
53 #include "ED_uvedit.h"
54
55 #include "UI_view2d.h"
56
57 #include "WM_api.h"
58 #include "WM_types.h"
59
60 /* note; image_panel_properties() uses pointer to sima->image directly */
61 Image *ED_space_image(SpaceImage *sima)
62 {
63         return sima->image;
64 }
65
66 /* called to assign images to UV faces */
67 void ED_space_image_set(SpaceImage *sima, Scene *UNUSED(scene), Object *obedit, Image *ima)
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                         BKE_image_release_ibuf(sima->image, ibuf, *r_lock);
123                         *r_lock = NULL;
124                 }
125         }
126         else
127                 *r_lock = NULL;
128
129         return NULL;
130 }
131
132 void ED_space_image_release_buffer(SpaceImage *sima, ImBuf *ibuf, void *lock)
133 {
134         if (sima && sima->image)
135                 BKE_image_release_ibuf(sima->image, ibuf, lock);
136 }
137
138 bool ED_space_image_has_buffer(SpaceImage *sima)
139 {
140         ImBuf *ibuf;
141         void *lock;
142         bool has_buffer;
143
144         ibuf = ED_space_image_acquire_buffer(sima, &lock);
145         has_buffer = (ibuf != NULL);
146         ED_space_image_release_buffer(sima, ibuf, lock);
147
148         return has_buffer;
149 }
150
151 void ED_space_image_get_size(SpaceImage *sima, int *width, int *height)
152 {
153         Scene *scene = sima->iuser.scene;
154         ImBuf *ibuf;
155         void *lock;
156
157         ibuf = ED_space_image_acquire_buffer(sima, &lock);
158
159         if (ibuf && ibuf->x > 0 && ibuf->y > 0) {
160                 *width = ibuf->x;
161                 *height = ibuf->y;
162         }
163         else if (sima->image && sima->image->type == IMA_TYPE_R_RESULT && scene) {
164                 /* not very important, just nice */
165                 *width = (scene->r.xsch * scene->r.size) / 100;
166                 *height = (scene->r.ysch * scene->r.size) / 100;
167
168                 if ((scene->r.mode & R_BORDER) && (scene->r.mode & R_CROP)) {
169                         *width  *= BLI_rctf_size_x(&scene->r.border);
170                         *height *= BLI_rctf_size_y(&scene->r.border);
171                 }
172
173         }
174         /* I know a bit weak... but preview uses not actual image size */
175         // XXX else if (image_preview_active(sima, width, height));
176         else {
177                 *width  = IMG_SIZE_FALLBACK;
178                 *height = IMG_SIZE_FALLBACK;
179         }
180
181         ED_space_image_release_buffer(sima, ibuf, lock);
182 }
183
184 void ED_space_image_get_size_fl(SpaceImage *sima, float size[2])
185 {
186         int size_i[2];
187         ED_space_image_get_size(sima, &size_i[0], &size_i[1]);
188         size[0] = size_i[0];
189         size[1] = size_i[1];
190 }
191
192
193 void ED_space_image_get_aspect(SpaceImage *sima, float *aspx, float *aspy)
194 {
195         Image *ima = sima->image;
196         if ((ima == NULL) || (ima->aspx == 0.0f || ima->aspy == 0.0f)) {
197                 *aspx = *aspy = 1.0;
198         }
199         else {
200                 BKE_image_get_aspect(ima, aspx, aspy);
201         }
202 }
203
204 void ED_space_image_get_zoom(SpaceImage *sima, ARegion *ar, float *zoomx, float *zoomy)
205 {
206         int width, height;
207
208         ED_space_image_get_size(sima, &width, &height);
209
210         *zoomx = (float)(BLI_rcti_size_x(&ar->winrct) + 1) / (float)(BLI_rctf_size_x(&ar->v2d.cur) * width);
211         *zoomy = (float)(BLI_rcti_size_y(&ar->winrct) + 1) / (float)(BLI_rctf_size_y(&ar->v2d.cur) * height);
212 }
213
214 void ED_space_image_get_uv_aspect(SpaceImage *sima, float *aspx, float *aspy)
215 {
216         int w, h;
217
218         ED_space_image_get_aspect(sima, aspx, aspy);
219         ED_space_image_get_size(sima, &w, &h);
220
221         *aspx *= (float)w;
222         *aspy *= (float)h;
223
224         if (*aspx < *aspy) {
225                 *aspy = *aspy / *aspx;
226                 *aspx = 1.0f;
227         }
228         else {
229                 *aspx = *aspx / *aspy;
230                 *aspy = 1.0f;
231         }
232 }
233
234 void ED_image_get_uv_aspect(Image *ima, ImageUser *iuser, float *aspx, float *aspy)
235 {
236         if (ima) {
237                 int w, h;
238
239                 BKE_image_get_aspect(ima, aspx, aspy);
240                 BKE_image_get_size(ima, iuser, &w, &h);
241
242                 *aspx *= (float)w;
243                 *aspy *= (float)h;
244         }
245         else {
246                 *aspx = 1.0f;
247                 *aspy = 1.0f;
248         }
249 }
250
251 /* takes event->mval */
252 void ED_image_mouse_pos(SpaceImage *sima, ARegion *ar, const int mval[2], float co[2])
253 {
254         int sx, sy, width, height;
255         float zoomx, zoomy;
256
257         ED_space_image_get_zoom(sima, ar, &zoomx, &zoomy);
258         ED_space_image_get_size(sima, &width, &height);
259
260         UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &sx, &sy);
261
262         co[0] = ((mval[0] - sx) / zoomx) / width;
263         co[1] = ((mval[1] - sy) / zoomy) / height;
264 }
265
266 void ED_image_point_pos(SpaceImage *sima, ARegion *ar, float x, float y, float *xr, float *yr)
267 {
268         int sx, sy, width, height;
269         float zoomx, zoomy;
270
271         ED_space_image_get_zoom(sima, ar, &zoomx, &zoomy);
272         ED_space_image_get_size(sima, &width, &height);
273
274         UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &sx, &sy);
275
276         *xr = ((x - sx) / zoomx) / width;
277         *yr = ((y - sy) / zoomy) / height;
278 }
279
280 void ED_image_point_pos__reverse(SpaceImage *sima, ARegion *ar, const float co[2], float r_co[2])
281 {
282         float zoomx, zoomy;
283         int width, height;
284         int sx, sy;
285
286         UI_view2d_view_to_region(&ar->v2d, 0.0f, 0.0f, &sx, &sy);
287         ED_space_image_get_size(sima, &width, &height);
288         ED_space_image_get_zoom(sima, ar, &zoomx, &zoomy);
289
290         r_co[0] = (co[0] * width  * zoomx) + (float)sx;
291         r_co[1] = (co[1] * height * zoomy) + (float)sy;
292 }
293
294 /**
295  * This is more a user-level functionality, for going to next/prev used slot,
296  * Stepping onto the last unused slot too.
297  */
298 bool ED_image_slot_cycle(struct Image *image, int direction)
299 {
300         const int cur = image->render_slot;
301         int i, slot;
302
303         BLI_assert(ELEM(direction, -1, 1));
304
305         for (i = 1; i < IMA_MAX_RENDER_SLOT; i++) {
306                 slot = (cur + ((direction == -1) ? -i : i)) % IMA_MAX_RENDER_SLOT;
307                 if (slot < 0) slot += IMA_MAX_RENDER_SLOT;
308
309                 if (image->renders[slot] || slot == image->last_render_slot) {
310                         image->render_slot = slot;
311                         break;
312                 }
313         }
314
315         if (i == IMA_MAX_RENDER_SLOT) {
316                 image->render_slot = ((cur == 1) ? 0 : 1);
317         }
318
319         return (cur != image->render_slot);
320 }
321
322 void ED_space_image_scopes_update(const struct bContext *C, struct SpaceImage *sima, struct ImBuf *ibuf, bool use_view_settings)
323 {
324         Scene *scene = CTX_data_scene(C);
325         Object *ob = CTX_data_active_object(C);
326
327         /* scope update can be expensive, don't update during paint modes */
328         if (sima->mode == SI_MODE_PAINT)
329                 return;
330         if (ob && ((ob->mode & (OB_MODE_TEXTURE_PAINT | OB_MODE_EDIT)) != 0))
331                 return;
332
333         /* We also don't update scopes of render result during render. */
334         if (G.is_rendering) {
335                 const Image *image = sima->image;
336                 if (image != NULL &&
337                     (image->type == IMA_TYPE_R_RESULT || image->type == IMA_TYPE_COMPOSITE))
338                 {
339                         return;
340                 }
341         }
342
343         scopes_update(&sima->scopes, ibuf, use_view_settings ? &scene->view_settings : NULL, &scene->display_settings);
344 }
345
346 bool ED_space_image_show_render(SpaceImage *sima)
347 {
348         return (sima->image && ELEM(sima->image->type, IMA_TYPE_R_RESULT, IMA_TYPE_COMPOSITE));
349 }
350
351 bool ED_space_image_show_paint(SpaceImage *sima)
352 {
353         if (ED_space_image_show_render(sima))
354                 return false;
355
356         return (sima->mode == SI_MODE_PAINT);
357 }
358
359 bool ED_space_image_show_uvedit(SpaceImage *sima, Object *obedit)
360 {
361         if (sima && (ED_space_image_show_render(sima) || ED_space_image_show_paint(sima)))
362                 return false;
363
364         if (obedit && obedit->type == OB_MESH) {
365                 struct BMEditMesh *em = BKE_editmesh_from_object(obedit);
366                 bool ret;
367
368                 ret = EDBM_uv_check(em);
369
370                 return ret;
371         }
372
373         return false;
374 }
375
376 /* matches clip function */
377 bool ED_space_image_check_show_maskedit(SpaceImage *sima, ViewLayer *view_layer)
378 {
379         /* check editmode - this is reserved for UV editing */
380         Object *ob = OBACT(view_layer);
381         if (ob && ob->mode & OB_MODE_EDIT && ED_space_image_show_uvedit(sima, ob)) {
382                 return false;
383         }
384
385         return (sima->mode == SI_MODE_MASK);
386 }
387
388 int ED_space_image_maskedit_poll(bContext *C)
389 {
390         SpaceImage *sima = CTX_wm_space_image(C);
391
392         if (sima) {
393                 ViewLayer *view_layer = CTX_data_view_layer(C);
394                 return ED_space_image_check_show_maskedit(sima, view_layer);
395         }
396
397         return false;
398 }
399
400 bool ED_space_image_paint_curve(const bContext *C)
401 {
402         SpaceImage *sima = CTX_wm_space_image(C);
403
404         if (sima && sima->mode == SI_MODE_PAINT) {
405                 Brush *br = CTX_data_tool_settings(C)->imapaint.paint.brush;
406
407                 if (br && (br->flag & BRUSH_CURVE))
408                         return true;
409         }
410
411         return false;
412 }
413
414
415 int ED_space_image_maskedit_mask_poll(bContext *C)
416 {
417         if (ED_space_image_maskedit_poll(C)) {
418                 SpaceImage *sima = CTX_wm_space_image(C);
419                 return sima->mask_info.mask != NULL;
420         }
421
422         return false;
423 }
424