Blender V5.3
image_edit.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2008 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "DNA_brush_types.h"
10#include "DNA_mask_types.h"
11#include "DNA_mesh_types.h"
12#include "DNA_object_types.h"
13#include "DNA_scene_types.h"
14
15#include "BLI_listbase.hh"
16#include "BLI_rect.hh"
17
18#include "BKE_colortools.hh"
19#include "BKE_context.hh"
20#include "BKE_editmesh.hh"
21#include "BKE_global.hh"
22#include "BKE_image.hh"
23#include "BKE_layer.hh"
24#include "BKE_lib_id.hh"
25#include "BKE_main.hh"
26#include "BKE_paint.hh"
27#include "BKE_scene.hh"
28
29#include "IMB_imbuf_types.hh"
30
31#include "ED_image.hh" /* own include */
32#include "ED_mesh.hh"
33#include "ED_screen.hh"
34#include "ED_uvedit.hh"
35
36#include "UI_view2d.hh"
37
38#include "WM_api.hh"
39#include "WM_types.hh"
40
41namespace blender {
42
44{
45 /* NOTE: image_panel_properties() uses pointer to `sima->image` directly. */
46 return sima->image;
47}
48
49void ED_space_image_set(Main *bmain, SpaceImage *sima, Image *ima, bool automatic)
50{
51 /* Automatically pin image when manually assigned, otherwise it follows object. */
52 if (!automatic && sima->image != ima && sima->mode == SI_MODE_UV) {
53 sima->pin = true;
54 }
55
56 sima->image = ima;
57
58 if (ima == nullptr || ima->type == IMA_TYPE_R_RESULT || ima->type == IMA_TYPE_COMPOSITE) {
59 if (sima->mode == SI_MODE_PAINT) {
60 sima->mode = SI_MODE_VIEW;
61 }
62 }
63
64 if (sima->image) {
66 }
67
68 id_us_ensure_real(id_cast<ID *>(sima->image));
69
70 if (ima) {
71 sima->xof = ima->runtime->view_offset[0];
72 sima->yof = ima->runtime->view_offset[1];
73 sima->zoom = ima->runtime->view_zoom;
74 }
75
77}
78
79void ED_space_image_sync(Main *bmain, Image *image, bool ignore_render_viewer)
80{
81 wmWindowManager *wm = bmain->wm.first();
82 for (wmWindow &win : wm->windows) {
83 const bScreen *screen = WM_window_get_active_screen(&win);
84 for (ScrArea &area : screen->areabase) {
85 for (SpaceLink &sl : area.spacedata) {
86 if (sl.spacetype != SPACE_IMAGE) {
87 continue;
88 }
89 SpaceImage *sima = reinterpret_cast<SpaceImage *>(&sl);
90 if (sima->pin) {
91 continue;
92 }
93 if (ignore_render_viewer && sima->image &&
95 {
96 continue;
97 }
98 ED_space_image_set(bmain, sima, image, true);
99 }
100 }
101 }
102}
103
105{
106 if (sima->mode != SI_MODE_UV || sima->pin) {
107 return;
108 }
109
110 /* Track image assigned to active face in edit mode. */
112 if (!(ob && (ob->mode & OB_MODE_EDIT) && ED_space_image_show_uvedit(sima, ob))) {
113 return;
114 }
115
117 BMFace *efa = BM_mesh_active_face_get(bm, true, false);
118 if (efa == nullptr) {
119 return;
120 }
121
122 Image *ima = nullptr;
123 ED_object_get_active_image(ob, efa->mat_nr + 1, &ima, nullptr, nullptr, nullptr);
124
125 if (ima != sima->image) {
126 sima->image = ima;
127
128 if (sima->image) {
129 Main *bmain = CTX_data_main(C);
132 }
133 }
134}
135
137{
138 return sima->mask_info.mask;
139}
140
142{
143 sima->mask_info.mask = mask;
144
145 /* weak, but same as image/space */
146 id_us_ensure_real(id_cast<ID *>(sima->mask_info.mask));
147
148 if (C) {
150 }
151}
152
154 void **r_lock,
155 int tile,
156 const bool ensure_host_buffer)
157{
158 ImBuf *ibuf;
159
160 if (sima && sima->image) {
161 const Image *image = sima->image;
162
163#if 0
164 if (image->type == IMA_TYPE_R_RESULT && BIF_show_render_spare()) {
165 return BIF_render_spare_imbuf();
166 }
167 else
168#endif
169 {
170 sima->iuser.tile = tile;
171 if (ensure_host_buffer) {
172 ibuf = BKE_image_acquire_ibuf(sima->image, &sima->iuser, r_lock);
173 }
174 else {
175 ibuf = BKE_image_acquire_ibuf_gpu(sima->image, &sima->iuser, r_lock);
176 }
177 sima->iuser.tile = 0;
178 }
179
180 if (ibuf) {
181 if (image->type == IMA_TYPE_R_RESULT && ibuf->x != 0 && ibuf->y != 0) {
182 /* Render result might be lazily allocated. Return ibuf without buffers to indicate that
183 * there is image buffer but it has no data yet. */
184 return ibuf;
185 }
186
187 if (ibuf->byte_data() || ibuf->float_data() || ibuf->gpu.texture) {
188 return ibuf;
189 }
190 BKE_image_release_ibuf(sima->image, ibuf, *r_lock);
191 *r_lock = nullptr;
192 }
193 }
194 else {
195 *r_lock = nullptr;
196 }
197
198 return nullptr;
199}
200
202{
203 if (sima && sima->image) {
204 BKE_image_release_ibuf(sima->image, ibuf, lock);
205 }
206}
207
209{
211 if (!ibuf) {
212 return result;
213 }
214
215 const bool color = ibuf->channels >= 3;
216 const bool alpha = ibuf->channels == 4;
217 const bool zbuf = ibuf->channels == 1;
218
219 if (!alpha) {
221 }
222 if (!zbuf) {
224 }
225 if (!color) {
227 }
228 return result;
229}
230
232{
233 ImBuf *ibuf;
234 void *lock;
235 bool has_buffer;
236
237 ibuf = ED_space_image_acquire_buffer(sima, &lock, 0, false);
238 has_buffer = (ibuf != nullptr);
240
241 return has_buffer;
242}
243
244void ED_space_image_get_size(SpaceImage *sima, int *r_width, int *r_height)
245{
246 Scene *scene = sima->iuser.scene;
247 ImBuf *ibuf;
248 void *lock;
249
250 /* TODO(lukas): Support tiled images with different sizes */
251 ibuf = ED_space_image_acquire_buffer(sima, &lock, 0, false);
252
253 if (ibuf && ibuf->x > 0 && ibuf->y > 0) {
254 *r_width = ibuf->x;
255 *r_height = ibuf->y;
256 }
257 else if (sima->image && sima->image->type == IMA_TYPE_R_RESULT && scene) {
258 /* not very important, just nice */
259 BKE_render_resolution(&scene->r, true, r_width, r_height);
260 }
261 /* I know a bit weak... but preview uses not actual image size */
262 // XXX else if (image_preview_active(sima, r_width, r_height));
263 else {
264 *r_width = IMG_SIZE_FALLBACK;
265 *r_height = IMG_SIZE_FALLBACK;
266 }
267
269}
270
271void ED_space_image_get_size_fl(SpaceImage *sima, float r_size[2])
272{
273 int size_i[2];
274 ED_space_image_get_size(sima, &size_i[0], &size_i[1]);
275 r_size[0] = size_i[0];
276 r_size[1] = size_i[1];
277}
278
279void ED_space_image_get_aspect(SpaceImage *sima, float *r_aspx, float *r_aspy)
280{
281 Image *ima = sima->image;
282 if ((ima == nullptr) || (ima->aspx == 0.0f || ima->aspy == 0.0f)) {
283 *r_aspx = *r_aspy = 1.0;
284 }
285 else {
286 BKE_image_get_aspect(ima, r_aspx, r_aspy);
287 }
288}
289
291 const ARegion *region,
292 float *r_zoomx,
293 float *r_zoomy)
294{
295 int width, height;
296
297 ED_space_image_get_size(sima, &width, &height);
298
299 *r_zoomx = float(BLI_rcti_size_x(&region->winrct) + 1) /
300 float(BLI_rctf_size_x(&region->v2d.cur) * width);
301 *r_zoomy = float(BLI_rcti_size_y(&region->winrct) + 1) /
302 float(BLI_rctf_size_y(&region->v2d.cur) * height);
303}
304
305void ED_space_image_get_uv_aspect(SpaceImage *sima, float *r_aspx, float *r_aspy)
306{
307 int w, h;
308
309 ED_space_image_get_aspect(sima, r_aspx, r_aspy);
310 ED_space_image_get_size(sima, &w, &h);
311
312 *r_aspx *= float(w);
313 *r_aspy *= float(h);
314
315 if (*r_aspx < *r_aspy) {
316 *r_aspy = *r_aspy / *r_aspx;
317 *r_aspx = 1.0f;
318 }
319 else {
320 *r_aspx = *r_aspx / *r_aspy;
321 *r_aspy = 1.0f;
322 }
323}
324
325void ED_image_get_uv_aspect(Image *ima, ImageUser *iuser, float *r_aspx, float *r_aspy)
326{
327 if (ima) {
328 int w, h;
329
330 BKE_image_get_aspect(ima, r_aspx, r_aspy);
331 BKE_image_get_size(ima, iuser, &w, &h);
332
333 *r_aspx *= float(w);
334 *r_aspy *= float(h);
335 }
336 else {
337 *r_aspx = 1.0f;
338 *r_aspy = 1.0f;
339 }
340}
341
342void ED_image_mouse_pos(SpaceImage *sima, const ARegion *region, const int mval[2], float co[2])
343{
344 int sx, sy, width, height;
345 float zoomx, zoomy;
346
347 ED_space_image_get_zoom(sima, region, &zoomx, &zoomy);
348 ED_space_image_get_size(sima, &width, &height);
349
350 ui::view2d_view_to_region(&region->v2d, 0.0f, 0.0f, &sx, &sy);
351
352 co[0] = ((mval[0] - sx) / zoomx) / width;
353 co[1] = ((mval[1] - sy) / zoomy) / height;
354}
355
357{
358 int width, height;
359 float aspx, aspy;
360
361 ED_space_image_get_size(sima, &width, &height);
362 ED_space_image_get_aspect(sima, &aspx, &aspy);
363
364 sima->xof = (x - 0.5f) * width * aspx;
365 sima->yof = (y - 0.5f) * height * aspy;
366}
367
369 SpaceImage *sima, const ARegion *region, float x, float y, float *r_x, float *r_y)
370{
371 int sx, sy, width, height;
372 float zoomx, zoomy;
373
374 ED_space_image_get_zoom(sima, region, &zoomx, &zoomy);
375 ED_space_image_get_size(sima, &width, &height);
376
377 ui::view2d_view_to_region(&region->v2d, 0.0f, 0.0f, &sx, &sy);
378
379 *r_x = ((x - sx) / zoomx) / width;
380 *r_y = ((y - sy) / zoomy) / height;
381}
382
384 const ARegion *region,
385 const float co[2],
386 float r_co[2])
387{
388 float zoomx, zoomy;
389 int width, height;
390 int sx, sy;
391
392 ui::view2d_view_to_region(&region->v2d, 0.0f, 0.0f, &sx, &sy);
393 ED_space_image_get_size(sima, &width, &height);
394 ED_space_image_get_zoom(sima, region, &zoomx, &zoomy);
395
396 r_co[0] = (co[0] * width * zoomx) + float(sx);
397 r_co[1] = (co[1] * height * zoomy) + float(sy);
398}
399
400bool ED_image_slot_cycle(Image *image, int direction)
401{
402 const int cur = image->render_slot;
403 int i, slot;
404
405 BLI_assert(ELEM(direction, -1, 1));
406
407 int num_slots = image->renderslots.count();
408 for (i = 1; i < num_slots; i++) {
409 slot = (cur + ((direction == -1) ? -i : i)) % num_slots;
410 if (slot < 0) {
411 slot += num_slots;
412 }
413
414 RenderSlot *render_slot = BKE_image_get_renderslot(image, slot);
415 if ((render_slot && render_slot->render) || slot == image->last_render_slot) {
416 image->render_slot = slot;
417 break;
418 }
419 }
420
421 if (num_slots == 1) {
422 image->render_slot = 0;
423 }
424 else if (i == num_slots) {
425 image->render_slot = ((cur == 1) ? 0 : 1);
426 }
427
428 return (cur != image->render_slot);
429}
430
432 SpaceImage *sima,
433 ImBuf *ibuf,
434 bool use_view_settings)
435{
436 Scene *scene = CTX_data_scene(C);
438
439 /* scope update can be expensive, don't update during paint modes */
440 if (sima->mode == SI_MODE_PAINT) {
441 return;
442 }
443 if (ob && ((ob->mode & (OB_MODE_TEXTURE_PAINT | OB_MODE_EDIT)) != 0)) {
444 return;
445 }
446
447 /* We also don't update scopes of render result during render. */
448 if (G.is_rendering) {
449 const Image *image = sima->image;
450 if (image != nullptr && ELEM(image->type, IMA_TYPE_R_RESULT, IMA_TYPE_COMPOSITE)) {
451 return;
452 }
453 }
454
456 ibuf,
457 use_view_settings ? &scene->view_settings : nullptr,
458 &scene->display_settings);
459}
460
462{
463 return (sima->image && ELEM(sima->image->type, IMA_TYPE_R_RESULT, IMA_TYPE_COMPOSITE));
464}
465
467{
468 if (ED_space_image_show_render(sima)) {
469 return false;
470 }
471
472 return (sima->mode == SI_MODE_PAINT);
473}
474
476{
477 return (sima->mode == SI_MODE_MASK);
478}
479
481{
482 if (sima) {
483 if (ED_space_image_show_render(sima)) {
484 return false;
485 }
486 if (sima->mode != SI_MODE_UV) {
487 return false;
488 }
489 }
490
491 if (obedit && obedit->type == OB_MESH) {
492 return EDBM_uv_check(id_cast<const Mesh *>(obedit->data));
493 }
494
495 return false;
496}
497
499{
500 /* check editmode - this is reserved for UV editing */
501 if (obedit && ED_space_image_show_uvedit(sima, obedit)) {
502 return false;
503 }
504
505 return (sima->mode == SI_MODE_MASK);
506}
507
509{
511
512 if (sima) {
513 const Main *bmain = CTX_data_main(C);
514 Scene *scene = CTX_data_scene(C);
515 ViewLayer *view_layer = CTX_data_view_layer(C);
516 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
517 Object *obedit = BKE_view_layer_edit_object_get(view_layer);
518 return ED_space_image_check_show_maskedit(sima, obedit);
519 }
520
521 return false;
522}
523
525{
527 return false;
528 }
529
530 const SpaceImage *space_image = CTX_wm_space_image(C);
531 return space_image->mask_info.draw_flag & MASK_DRAWFLAG_SPLINE;
532}
533
535{
537
538 if (sima && sima->mode == SI_MODE_PAINT) {
539 Brush *br = BKE_paint_brush(&CTX_data_tool_settings(C)->imapaint.paint);
540
541 if (br && (br->stroke_method == BRUSH_STROKE_CURVE)) {
542 return true;
543 }
544 }
545
546 return false;
547}
548
550{
553 return sima->mask_info.mask != nullptr;
554 }
555
556 return false;
557}
558
560{
562 return false;
563 }
564
565 const SpaceImage *space_image = CTX_wm_space_image(C);
566 return space_image->mask_info.draw_flag & MASK_DRAWFLAG_SPLINE;
567}
568
574
576{
577 const ARegion *region = CTX_wm_region(C);
578 if (!(region && region->regiontype == RGN_TYPE_WINDOW)) {
579 return false;
580 }
582}
583
584} // namespace blender
#define IMA_SIGNAL_USER_NEW_IMAGE
Definition BKE_image.hh:183
Object is a sort of wrapper for general info.
#define IMG_SIZE_FALLBACK
#define C
Definition RandGen.cpp:29
#define ND_SPACE_IMAGE
Definition WM_types.hh:565
#define NC_MASK
Definition WM_types.hh:411
#define NC_SPACE
Definition WM_types.hh:405
#define NA_SELECTED
Definition WM_types.hh:639
volatile int lock
#define ELEM(...)
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
const ccl_global KernelWorkTile * tile
void view2d_view_to_region(const View2D *v2d, float x, float y, int *r_region_x, int *r_region_y) ATTR_NONNULL()
Definition view2d.cc:1705
BMesh Iterators.
void WM_main_add_notifier(uint type, void *reference)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
bool ED_space_image_maskedit_mask_poll(bContext *C)
bool ED_image_slot_cycle(Image *image, int direction)
void ED_space_image_auto_set(const bContext *C, SpaceImage *sima)
BMesh * BKE_editmesh_bmesh_get_for_write(Mesh *mesh)
Definition editmesh.cc:79
void ED_space_image_get_aspect(SpaceImage *sima, float *r_aspx, float *r_aspy)
bool ED_space_image_check_show_maskedit(SpaceImage *sima, Object *obedit)
void ED_space_image_sync(Main *bmain, Image *image, bool ignore_render_viewer)
Definition image_edit.cc:79
void BKE_image_signal(Main *bmain, Image *ima, ImageUser *iuser, int signal)
void BKE_image_get_size(Image *image, ImageUser *iuser, int *r_width, int *r_height)
bool ED_space_image_maskedit_mask_visible_splines_poll(bContext *C)
ImBuf * ED_space_image_acquire_buffer(SpaceImage *sima, void **r_lock, int tile, const bool ensure_host_buffer)
void ED_space_image_get_size(SpaceImage *sima, int *r_width, int *r_height)
bool ED_space_image_region_cursor_poll(bContext *C)
void BKE_image_get_aspect(Image *image, float *r_aspx, float *r_aspy)
void ED_space_image_release_buffer(SpaceImage *sima, ImBuf *ibuf, void *lock)
void ED_space_image_set(Main *bmain, SpaceImage *sima, Image *ima, bool automatic)
Definition image_edit.cc:49
bool EDBM_uv_check(const Mesh *mesh)
ViewLayer * CTX_data_view_layer(const bContext *C)
void BKE_render_resolution(const RenderData *r, const bool use_crop, int *r_width, int *r_height)
Definition scene.cc:3168
Global G
Definition blender.cc:57
void ED_image_point_pos(SpaceImage *sima, const ARegion *region, float x, float y, float *r_x, float *r_y)
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
Definition BLI_rect.hh:207
ImBuf * BKE_image_acquire_ibuf_gpu(Image *ima, ImageUser *iuser, void **r_lock, bool *r_load_failed=nullptr, bool cached_only=false)
bool ED_space_image_paint_curve(const bContext *C)
bool ED_space_image_show_paint(const SpaceImage *sima)
bool ED_space_image_show_render(const SpaceImage *sima)
void ED_space_image_get_size_fl(SpaceImage *sima, float r_size[2])
void ED_image_mouse_pos(SpaceImage *sima, const ARegion *region, const int mval[2], float co[2])
bool ED_space_image_maskedit_visible_splines_poll(bContext *C)
Object * BKE_view_layer_edit_object_get(const ViewLayer *view_layer)
@ OB_MODE_TEXTURE_PAINT
void ED_image_get_uv_aspect(Image *ima, ImageUser *iuser, float *r_aspx, float *r_aspy)
BLI_INLINE float BLI_rctf_size_y(const struct rctf *rct)
Definition BLI_rect.hh:215
RenderSlot * BKE_image_get_renderslot(Image *ima, int index)
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
bool ED_space_image_has_buffer(SpaceImage *sima)
ToolSettings * CTX_data_tool_settings(const bContext *C)
int ED_space_image_get_display_channel_mask(ImBuf *ibuf)
@ MASK_DRAWFLAG_SPLINE
bool ED_space_image_maskedit_poll(bContext *C)
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
Definition BLI_rect.hh:203
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
bool ED_operator_uvedit_space_image(bContext *C)
void ED_space_image_scopes_update(const bContext *C, SpaceImage *sima, ImBuf *ibuf, bool use_view_settings)
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
SpaceImage * CTX_wm_space_image(const bContext *C)
void id_us_ensure_real(ID *id)
Definition lib_id.cc:388
Main * CTX_data_main(const bContext *C)
BMFace * BM_mesh_active_face_get(BMesh *bm, const bool is_sloppy, const bool is_selected)
BLI_INLINE float BLI_rctf_size_x(const struct rctf *rct)
Definition BLI_rect.hh:211
void ED_space_image_get_uv_aspect(SpaceImage *sima, float *r_aspx, float *r_aspy)
void BKE_scopes_update(Scopes *scopes, ImBuf *ibuf, const ColorManagedViewSettings *view_settings, const ColorManagedDisplaySettings *display_settings)
void ED_space_image_set_mask(bContext *C, SpaceImage *sima, Mask *mask)
void ED_space_image_get_zoom(SpaceImage *sima, const ARegion *region, float *r_zoomx, float *r_zoomy)
Brush * BKE_paint_brush(Paint *paint)
Scene * CTX_data_scene(const bContext *C)
bool ED_space_image_cursor_poll(bContext *C)
void ED_image_view_center_to_point(SpaceImage *sima, float x, float y)
void ED_image_point_pos__reverse(SpaceImage *sima, const ARegion *region, const float co[2], float r_co[2])
bScreen * WM_window_get_active_screen(const wmWindow *win)
Object * CTX_data_active_object(const bContext *C)
ARegion * CTX_wm_region(const bContext *C)
Image * ED_space_image(const SpaceImage *sima)
Definition image_edit.cc:43
bool ED_space_image_show_uvedit(const SpaceImage *sima, Object *obedit)
Mask * ED_space_image_get_mask(const SpaceImage *sima)
bool ED_space_image_show_mask(const SpaceImage *sima)
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
bool ED_object_get_active_image(Object *ob, int mat_nr, Image **r_ima, ImageUser **r_iuser, const bNode **r_node, const bNodeTree **r_ntree)
Definition uvedit_ops.cc:98
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
eRegion_Type regiontype
eBrushStrokeType stroke_method
std::atomic< gpu::Texture * > texture
const uint8_t * byte_data() const
const float * float_data() const
struct Scene * scene
ListBaseT< wmWindowManager > wm
Definition BKE_main.hh:415
struct RenderResult * render
ColorManagedViewSettings view_settings
ColorManagedDisplaySettings display_settings
struct RenderData r
ListBaseT< SpaceLink > spacedata
MaskSpaceInfo mask_info
struct ImageUser iuser
eSpaceImage_Mode mode
ListBaseT< struct ScrArea > areabase