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