Fix T70439: Local view always including new objects
[blender.git] / source / blender / editors / space_node / node_view.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2008 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup spnode
22  */
23
24 #include "DNA_node_types.h"
25
26 #include "BLI_rect.h"
27 #include "BLI_utildefines.h"
28 #include "BLI_math.h"
29
30 #include "BKE_context.h"
31 #include "BKE_image.h"
32 #include "BKE_main.h"
33 #include "BKE_node.h"
34 #include "BKE_screen.h"
35
36 #include "ED_node.h" /* own include */
37 #include "ED_screen.h"
38 #include "ED_space_api.h"
39 #include "ED_image.h"
40
41 #include "RNA_access.h"
42 #include "RNA_define.h"
43
44 #include "WM_api.h"
45 #include "WM_types.h"
46
47 #include "UI_view2d.h"
48
49 #include "MEM_guardedalloc.h"
50
51 #include "IMB_colormanagement.h"
52 #include "IMB_imbuf.h"
53 #include "IMB_imbuf_types.h"
54
55 #include "node_intern.h" /* own include */
56 #include "NOD_composite.h"
57
58 /* **************** View All Operator ************** */
59
60 int space_node_view_flag(
61     bContext *C, SpaceNode *snode, ARegion *ar, const int node_flag, const int smooth_viewtx)
62 {
63   bNode *node;
64   rctf cur_new;
65   float oldwidth, oldheight, width, height;
66   float oldasp, asp;
67   int tot = 0;
68   bool has_frame = false;
69
70   oldwidth = BLI_rctf_size_x(&ar->v2d.cur);
71   oldheight = BLI_rctf_size_y(&ar->v2d.cur);
72
73   oldasp = oldwidth / oldheight;
74
75   BLI_rctf_init_minmax(&cur_new);
76
77   if (snode->edittree) {
78     for (node = snode->edittree->nodes.first; node; node = node->next) {
79       if ((node->flag & node_flag) == node_flag) {
80         BLI_rctf_union(&cur_new, &node->totr);
81         tot++;
82
83         if (node->type == NODE_FRAME) {
84           has_frame = true;
85         }
86       }
87     }
88   }
89
90   if (tot) {
91     width = BLI_rctf_size_x(&cur_new);
92     height = BLI_rctf_size_y(&cur_new);
93     asp = width / height;
94
95     /* for single non-frame nodes, don't zoom in, just pan view,
96      * but do allow zooming out, this allows for big nodes to be zoomed out */
97     if ((tot == 1) && (has_frame == false) && ((oldwidth * oldheight) > (width * height))) {
98       /* center, don't zoom */
99       BLI_rctf_resize(&cur_new, oldwidth, oldheight);
100     }
101     else {
102       if (oldasp < asp) {
103         const float height_new = width / oldasp;
104         cur_new.ymin = cur_new.ymin - height_new / 2.0f;
105         cur_new.ymax = cur_new.ymax + height_new / 2.0f;
106       }
107       else {
108         const float width_new = height * oldasp;
109         cur_new.xmin = cur_new.xmin - width_new / 2.0f;
110         cur_new.xmax = cur_new.xmax + width_new / 2.0f;
111       }
112
113       /* add some padding */
114       BLI_rctf_scale(&cur_new, 1.1f);
115     }
116
117     UI_view2d_smooth_view(C, ar, &cur_new, smooth_viewtx);
118   }
119
120   return (tot != 0);
121 }
122
123 static int node_view_all_exec(bContext *C, wmOperator *op)
124 {
125   ARegion *ar = CTX_wm_region(C);
126   SpaceNode *snode = CTX_wm_space_node(C);
127   const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
128
129   /* is this really needed? */
130   snode->xof = 0;
131   snode->yof = 0;
132
133   if (space_node_view_flag(C, snode, ar, 0, smooth_viewtx)) {
134     return OPERATOR_FINISHED;
135   }
136   else {
137     return OPERATOR_CANCELLED;
138   }
139 }
140
141 void NODE_OT_view_all(wmOperatorType *ot)
142 {
143   /* identifiers */
144   ot->name = "View All";
145   ot->idname = "NODE_OT_view_all";
146   ot->description = "Resize view so you can see all nodes";
147
148   /* api callbacks */
149   ot->exec = node_view_all_exec;
150   ot->poll = ED_operator_node_active;
151
152   /* flags */
153   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
154 }
155
156 static int node_view_selected_exec(bContext *C, wmOperator *op)
157 {
158   ARegion *ar = CTX_wm_region(C);
159   SpaceNode *snode = CTX_wm_space_node(C);
160   const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
161
162   if (space_node_view_flag(C, snode, ar, NODE_SELECT, smooth_viewtx)) {
163     return OPERATOR_FINISHED;
164   }
165   else {
166     return OPERATOR_CANCELLED;
167   }
168 }
169
170 void NODE_OT_view_selected(wmOperatorType *ot)
171 {
172   /* identifiers */
173   ot->name = "View Selected";
174   ot->idname = "NODE_OT_view_selected";
175   ot->description = "Resize view so you can see selected nodes";
176
177   /* api callbacks */
178   ot->exec = node_view_selected_exec;
179   ot->poll = ED_operator_node_active;
180
181   /* flags */
182   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
183 }
184
185 /* **************** Background Image Operators ************** */
186
187 typedef struct NodeViewMove {
188   int mvalo[2];
189   int xmin, ymin, xmax, ymax;
190 } NodeViewMove;
191
192 static int snode_bg_viewmove_modal(bContext *C, wmOperator *op, const wmEvent *event)
193 {
194   SpaceNode *snode = CTX_wm_space_node(C);
195   ARegion *ar = CTX_wm_region(C);
196   NodeViewMove *nvm = op->customdata;
197
198   switch (event->type) {
199     case MOUSEMOVE:
200
201       snode->xof -= (nvm->mvalo[0] - event->mval[0]);
202       snode->yof -= (nvm->mvalo[1] - event->mval[1]);
203       nvm->mvalo[0] = event->mval[0];
204       nvm->mvalo[1] = event->mval[1];
205
206       /* prevent dragging image outside of the window and losing it! */
207       CLAMP(snode->xof, nvm->xmin, nvm->xmax);
208       CLAMP(snode->yof, nvm->ymin, nvm->ymax);
209
210       ED_region_tag_redraw(ar);
211       WM_main_add_notifier(NC_NODE | ND_DISPLAY, NULL);
212
213       break;
214
215     case LEFTMOUSE:
216     case MIDDLEMOUSE:
217     case RIGHTMOUSE:
218       if (event->val == KM_RELEASE) {
219         MEM_freeN(nvm);
220         op->customdata = NULL;
221         return OPERATOR_FINISHED;
222       }
223       break;
224   }
225
226   return OPERATOR_RUNNING_MODAL;
227 }
228
229 static int snode_bg_viewmove_invoke(bContext *C, wmOperator *op, const wmEvent *event)
230 {
231   Main *bmain = CTX_data_main(C);
232   SpaceNode *snode = CTX_wm_space_node(C);
233   ARegion *ar = CTX_wm_region(C);
234   NodeViewMove *nvm;
235   Image *ima;
236   ImBuf *ibuf;
237   const float pad = 32.0f; /* better be bigger then scrollbars */
238
239   void *lock;
240
241   ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
242   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
243
244   if (ibuf == NULL) {
245     BKE_image_release_ibuf(ima, ibuf, lock);
246     return OPERATOR_CANCELLED;
247   }
248
249   nvm = MEM_callocN(sizeof(NodeViewMove), "NodeViewMove struct");
250   op->customdata = nvm;
251   nvm->mvalo[0] = event->mval[0];
252   nvm->mvalo[1] = event->mval[1];
253
254   nvm->xmin = -(ar->winx / 2) - (ibuf->x * (0.5f * snode->zoom)) + pad;
255   nvm->xmax = (ar->winx / 2) + (ibuf->x * (0.5f * snode->zoom)) - pad;
256   nvm->ymin = -(ar->winy / 2) - (ibuf->y * (0.5f * snode->zoom)) + pad;
257   nvm->ymax = (ar->winy / 2) + (ibuf->y * (0.5f * snode->zoom)) - pad;
258
259   BKE_image_release_ibuf(ima, ibuf, lock);
260
261   /* add modal handler */
262   WM_event_add_modal_handler(C, op);
263
264   return OPERATOR_RUNNING_MODAL;
265 }
266
267 static void snode_bg_viewmove_cancel(bContext *UNUSED(C), wmOperator *op)
268 {
269   MEM_freeN(op->customdata);
270   op->customdata = NULL;
271 }
272
273 void NODE_OT_backimage_move(wmOperatorType *ot)
274 {
275   /* identifiers */
276   ot->name = "Background Image Move";
277   ot->description = "Move Node backdrop";
278   ot->idname = "NODE_OT_backimage_move";
279
280   /* api callbacks */
281   ot->invoke = snode_bg_viewmove_invoke;
282   ot->modal = snode_bg_viewmove_modal;
283   ot->poll = composite_node_active;
284   ot->cancel = snode_bg_viewmove_cancel;
285
286   /* flags */
287   ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_CURSOR_XY;
288 }
289
290 static int backimage_zoom_exec(bContext *C, wmOperator *op)
291 {
292   SpaceNode *snode = CTX_wm_space_node(C);
293   ARegion *ar = CTX_wm_region(C);
294   float fac = RNA_float_get(op->ptr, "factor");
295
296   snode->zoom *= fac;
297   ED_region_tag_redraw(ar);
298   WM_main_add_notifier(NC_NODE | ND_DISPLAY, NULL);
299
300   return OPERATOR_FINISHED;
301 }
302
303 void NODE_OT_backimage_zoom(wmOperatorType *ot)
304 {
305
306   /* identifiers */
307   ot->name = "Background Image Zoom";
308   ot->idname = "NODE_OT_backimage_zoom";
309   ot->description = "Zoom in/out the background image";
310
311   /* api callbacks */
312   ot->exec = backimage_zoom_exec;
313   ot->poll = composite_node_active;
314
315   /* flags */
316   ot->flag = OPTYPE_BLOCKING;
317
318   /* internal */
319   RNA_def_float(ot->srna, "factor", 1.2f, 0.0f, 10.0f, "Factor", "", 0.0f, 10.0f);
320 }
321
322 static int backimage_fit_exec(bContext *C, wmOperator *UNUSED(op))
323 {
324   Main *bmain = CTX_data_main(C);
325   SpaceNode *snode = CTX_wm_space_node(C);
326   ARegion *ar = CTX_wm_region(C);
327
328   Image *ima;
329   ImBuf *ibuf;
330
331   const float pad = 32.0f;
332
333   void *lock;
334
335   float facx, facy;
336
337   ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
338   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
339
340   if ((ibuf == NULL) || (ibuf->x == 0) || (ibuf->y == 0)) {
341     BKE_image_release_ibuf(ima, ibuf, lock);
342     return OPERATOR_CANCELLED;
343   }
344
345   facx = 1.0f * (ar->sizex - pad) / (ibuf->x * snode->zoom);
346   facy = 1.0f * (ar->sizey - pad) / (ibuf->y * snode->zoom);
347
348   BKE_image_release_ibuf(ima, ibuf, lock);
349
350   snode->zoom *= min_ff(facx, facy) * U.dpi_fac;
351
352   snode->xof = 0;
353   snode->yof = 0;
354
355   ED_region_tag_redraw(ar);
356   WM_main_add_notifier(NC_NODE | ND_DISPLAY, NULL);
357
358   return OPERATOR_FINISHED;
359 }
360
361 void NODE_OT_backimage_fit(wmOperatorType *ot)
362 {
363
364   /* identifiers */
365   ot->name = "Background Image Fit";
366   ot->idname = "NODE_OT_backimage_fit";
367   ot->description = "Fit the background image to the view";
368
369   /* api callbacks */
370   ot->exec = backimage_fit_exec;
371   ot->poll = composite_node_active;
372
373   /* flags */
374   ot->flag = OPTYPE_BLOCKING;
375 }
376
377 /******************** sample backdrop operator ********************/
378
379 typedef struct ImageSampleInfo {
380   ARegionType *art;
381   void *draw_handle;
382   int x, y;
383   int channels;
384
385   unsigned char col[4];
386   float colf[4];
387   float linearcol[4];
388
389   int z;
390   float zf;
391
392   int *zp;
393   float *zfp;
394
395   int draw;
396   int color_manage;
397 } ImageSampleInfo;
398
399 static void sample_draw(const bContext *C, ARegion *ar, void *arg_info)
400 {
401   Scene *scene = CTX_data_scene(C);
402   ImageSampleInfo *info = arg_info;
403
404   if (info->draw) {
405     ED_image_draw_info(scene,
406                        ar,
407                        info->color_manage,
408                        false,
409                        info->channels,
410                        info->x,
411                        info->y,
412                        info->col,
413                        info->colf,
414                        info->linearcol,
415                        info->zp,
416                        info->zfp);
417   }
418 }
419
420 /* Returns color in linear space, matching ED_space_image_color_sample().
421  * And here we've got recursion in the comments tips...
422  */
423 bool ED_space_node_color_sample(
424     Main *bmain, SpaceNode *snode, ARegion *ar, int mval[2], float r_col[3])
425 {
426   void *lock;
427   Image *ima;
428   ImBuf *ibuf;
429   float fx, fy, bufx, bufy;
430   bool ret = false;
431
432   if (!ED_node_is_compositor(snode) || (snode->flag & SNODE_BACKDRAW) == 0) {
433     /* use viewer image for color sampling only if we're in compositor tree
434      * with backdrop enabled
435      */
436     return false;
437   }
438
439   ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
440   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
441   if (!ibuf) {
442     return false;
443   }
444
445   /* map the mouse coords to the backdrop image space */
446   bufx = ibuf->x * snode->zoom;
447   bufy = ibuf->y * snode->zoom;
448   fx = (bufx > 0.0f ? ((float)mval[0] - 0.5f * ar->winx - snode->xof) / bufx + 0.5f : 0.0f);
449   fy = (bufy > 0.0f ? ((float)mval[1] - 0.5f * ar->winy - snode->yof) / bufy + 0.5f : 0.0f);
450
451   if (fx >= 0.0f && fy >= 0.0f && fx < 1.0f && fy < 1.0f) {
452     const float *fp;
453     unsigned char *cp;
454     int x = (int)(fx * ibuf->x), y = (int)(fy * ibuf->y);
455
456     CLAMP(x, 0, ibuf->x - 1);
457     CLAMP(y, 0, ibuf->y - 1);
458
459     if (ibuf->rect_float) {
460       fp = (ibuf->rect_float + (ibuf->channels) * (y * ibuf->x + x));
461       /* IB_PROFILE_NONE is default but infact its linear */
462       copy_v3_v3(r_col, fp);
463       ret = true;
464     }
465     else if (ibuf->rect) {
466       cp = (unsigned char *)(ibuf->rect + y * ibuf->x + x);
467       rgb_uchar_to_float(r_col, cp);
468       IMB_colormanagement_colorspace_to_scene_linear_v3(r_col, ibuf->rect_colorspace);
469       ret = true;
470     }
471   }
472
473   BKE_image_release_ibuf(ima, ibuf, lock);
474
475   return ret;
476 }
477
478 static void sample_apply(bContext *C, wmOperator *op, const wmEvent *event)
479 {
480   Main *bmain = CTX_data_main(C);
481   SpaceNode *snode = CTX_wm_space_node(C);
482   ARegion *ar = CTX_wm_region(C);
483   ImageSampleInfo *info = op->customdata;
484   void *lock;
485   Image *ima;
486   ImBuf *ibuf;
487   float fx, fy, bufx, bufy;
488
489   ima = BKE_image_verify_viewer(bmain, IMA_TYPE_COMPOSITE, "Viewer Node");
490   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
491   if (!ibuf) {
492     info->draw = 0;
493     return;
494   }
495
496   if (!ibuf->rect) {
497     IMB_rect_from_float(ibuf);
498   }
499
500   /* map the mouse coords to the backdrop image space */
501   bufx = ibuf->x * snode->zoom;
502   bufy = ibuf->y * snode->zoom;
503   fx = (bufx > 0.0f ? ((float)event->mval[0] - 0.5f * ar->winx - snode->xof) / bufx + 0.5f : 0.0f);
504   fy = (bufy > 0.0f ? ((float)event->mval[1] - 0.5f * ar->winy - snode->yof) / bufy + 0.5f : 0.0f);
505
506   if (fx >= 0.0f && fy >= 0.0f && fx < 1.0f && fy < 1.0f) {
507     const float *fp;
508     unsigned char *cp;
509     int x = (int)(fx * ibuf->x), y = (int)(fy * ibuf->y);
510
511     CLAMP(x, 0, ibuf->x - 1);
512     CLAMP(y, 0, ibuf->y - 1);
513
514     info->x = x;
515     info->y = y;
516     info->draw = 1;
517     info->channels = ibuf->channels;
518
519     info->zp = NULL;
520     info->zfp = NULL;
521
522     if (ibuf->rect) {
523       cp = (unsigned char *)(ibuf->rect + y * ibuf->x + x);
524
525       info->col[0] = cp[0];
526       info->col[1] = cp[1];
527       info->col[2] = cp[2];
528       info->col[3] = cp[3];
529
530       info->colf[0] = (float)cp[0] / 255.0f;
531       info->colf[1] = (float)cp[1] / 255.0f;
532       info->colf[2] = (float)cp[2] / 255.0f;
533       info->colf[3] = (float)cp[3] / 255.0f;
534
535       copy_v4_v4(info->linearcol, info->colf);
536       IMB_colormanagement_colorspace_to_scene_linear_v4(
537           info->linearcol, false, ibuf->rect_colorspace);
538
539       info->color_manage = true;
540     }
541     if (ibuf->rect_float) {
542       fp = (ibuf->rect_float + (ibuf->channels) * (y * ibuf->x + x));
543
544       info->colf[0] = fp[0];
545       info->colf[1] = fp[1];
546       info->colf[2] = fp[2];
547       info->colf[3] = fp[3];
548
549       info->color_manage = true;
550     }
551
552     if (ibuf->zbuf) {
553       info->z = ibuf->zbuf[y * ibuf->x + x];
554       info->zp = &info->z;
555     }
556     if (ibuf->zbuf_float) {
557       info->zf = ibuf->zbuf_float[y * ibuf->x + x];
558       info->zfp = &info->zf;
559     }
560
561     ED_node_sample_set(info->colf);
562   }
563   else {
564     info->draw = 0;
565     ED_node_sample_set(NULL);
566   }
567
568   BKE_image_release_ibuf(ima, ibuf, lock);
569
570   ED_area_tag_redraw(CTX_wm_area(C));
571 }
572
573 static void sample_exit(bContext *C, wmOperator *op)
574 {
575   ImageSampleInfo *info = op->customdata;
576
577   ED_node_sample_set(NULL);
578   ED_region_draw_cb_exit(info->art, info->draw_handle);
579   ED_area_tag_redraw(CTX_wm_area(C));
580   MEM_freeN(info);
581 }
582
583 static int sample_invoke(bContext *C, wmOperator *op, const wmEvent *event)
584 {
585   SpaceNode *snode = CTX_wm_space_node(C);
586   ARegion *ar = CTX_wm_region(C);
587   ImageSampleInfo *info;
588
589   if (!ED_node_is_compositor(snode) || !(snode->flag & SNODE_BACKDRAW)) {
590     return OPERATOR_CANCELLED;
591   }
592
593   info = MEM_callocN(sizeof(ImageSampleInfo), "ImageSampleInfo");
594   info->art = ar->type;
595   info->draw_handle = ED_region_draw_cb_activate(
596       ar->type, sample_draw, info, REGION_DRAW_POST_PIXEL);
597   op->customdata = info;
598
599   sample_apply(C, op, event);
600
601   WM_event_add_modal_handler(C, op);
602
603   return OPERATOR_RUNNING_MODAL;
604 }
605
606 static int sample_modal(bContext *C, wmOperator *op, const wmEvent *event)
607 {
608   switch (event->type) {
609     case LEFTMOUSE:
610     case RIGHTMOUSE:  // XXX hardcoded
611       if (event->val == KM_RELEASE) {
612         sample_exit(C, op);
613         return OPERATOR_CANCELLED;
614       }
615       break;
616     case MOUSEMOVE:
617       sample_apply(C, op, event);
618       break;
619   }
620
621   return OPERATOR_RUNNING_MODAL;
622 }
623
624 static void sample_cancel(bContext *C, wmOperator *op)
625 {
626   sample_exit(C, op);
627 }
628
629 void NODE_OT_backimage_sample(wmOperatorType *ot)
630 {
631   /* identifiers */
632   ot->name = "Backimage Sample";
633   ot->idname = "NODE_OT_backimage_sample";
634   ot->description = "Use mouse to sample background image";
635
636   /* api callbacks */
637   ot->invoke = sample_invoke;
638   ot->modal = sample_modal;
639   ot->cancel = sample_cancel;
640   ot->poll = ED_operator_node_active;
641
642   /* flags */
643   ot->flag = OPTYPE_BLOCKING;
644 }