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