Fix T66694: depthdropper (camera focus distance) not working from View3D context...
[blender.git] / source / blender / editors / interface / interface_eyedropper_depth.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) 2009 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edinterface
22  *
23  * This file defines an eyedropper for picking 3D depth value (primary use is depth-of-field).
24  *
25  * Defines:
26  * - #UI_OT_eyedropper_depth
27  */
28
29 #include "MEM_guardedalloc.h"
30
31 #include "DNA_space_types.h"
32 #include "DNA_screen_types.h"
33 #include "DNA_object_types.h"
34 #include "DNA_camera_types.h"
35 #include "DNA_view3d_types.h"
36
37 #include "BLI_string.h"
38 #include "BLI_math_vector.h"
39
40 #include "BKE_context.h"
41 #include "BKE_screen.h"
42 #include "BKE_unit.h"
43
44 #include "DEG_depsgraph.h"
45
46 #include "RNA_access.h"
47
48 #include "UI_interface.h"
49
50 #include "WM_api.h"
51 #include "WM_types.h"
52
53 #include "ED_screen.h"
54 #include "ED_space_api.h"
55 #include "ED_view3d.h"
56
57 #include "interface_intern.h"
58 #include "interface_eyedropper_intern.h"
59
60 /**
61  * \note #DepthDropper is only internal name to avoid confusion with other kinds of eye-droppers.
62  */
63 typedef struct DepthDropper {
64   PointerRNA ptr;
65   PropertyRNA *prop;
66   bool is_undo;
67
68   bool is_set;
69   float init_depth; /* for resetting on cancel */
70
71   bool accum_start; /* has mouse been presed */
72   float accum_depth;
73   int accum_tot;
74
75   ARegionType *art;
76   void *draw_handle_pixel;
77   char name[200];
78 } DepthDropper;
79
80 static void depthdropper_draw_cb(const struct bContext *C, ARegion *ar, void *arg)
81 {
82   DepthDropper *ddr = arg;
83   eyedropper_draw_cursor_text(C, ar, ddr->name);
84 }
85
86 static int depthdropper_init(bContext *C, wmOperator *op)
87 {
88   int index_dummy;
89
90   SpaceType *st;
91   ARegionType *art;
92
93   st = BKE_spacetype_from_id(SPACE_VIEW3D);
94   art = BKE_regiontype_from_id(st, RGN_TYPE_WINDOW);
95
96   DepthDropper *ddr = MEM_callocN(sizeof(DepthDropper), __func__);
97
98   uiBut *but = UI_context_active_but_prop_get(C, &ddr->ptr, &ddr->prop, &index_dummy);
99
100   /* fallback to the active camera's dof */
101   if (ddr->prop == NULL) {
102     RegionView3D *rv3d = CTX_wm_region_view3d(C);
103     if (rv3d && rv3d->persp == RV3D_CAMOB) {
104       View3D *v3d = CTX_wm_view3d(C);
105       if (v3d->camera && v3d->camera->data && !ID_IS_LINKED(v3d->camera->data)) {
106         Camera *camera = (Camera *)v3d->camera->data;
107         RNA_pointer_create(&camera->id, &RNA_CameraDOFSettings, &camera->dof, &ddr->ptr);
108         ddr->prop = RNA_struct_find_property(&ddr->ptr, "focus_distance");
109         ddr->is_undo = true;
110       }
111     }
112   }
113   else {
114     ddr->is_undo = UI_but_flag_is_set(but, UI_BUT_UNDO);
115   }
116
117   if ((ddr->ptr.data == NULL) || (ddr->prop == NULL) ||
118       (RNA_property_editable(&ddr->ptr, ddr->prop) == false) ||
119       (RNA_property_type(ddr->prop) != PROP_FLOAT)) {
120     MEM_freeN(ddr);
121     return false;
122   }
123   op->customdata = ddr;
124
125   ddr->art = art;
126   ddr->draw_handle_pixel = ED_region_draw_cb_activate(
127       art, depthdropper_draw_cb, ddr, REGION_DRAW_POST_PIXEL);
128   ddr->init_depth = RNA_property_float_get(&ddr->ptr, ddr->prop);
129
130   return true;
131 }
132
133 static void depthdropper_exit(bContext *C, wmOperator *op)
134 {
135   WM_cursor_modal_restore(CTX_wm_window(C));
136
137   if (op->customdata) {
138     DepthDropper *ddr = (DepthDropper *)op->customdata;
139
140     if (ddr->art) {
141       ED_region_draw_cb_exit(ddr->art, ddr->draw_handle_pixel);
142     }
143
144     MEM_freeN(op->customdata);
145
146     op->customdata = NULL;
147   }
148 }
149
150 /* *** depthdropper id helper functions *** */
151 /**
152  * \brief get the ID from the screen.
153  */
154 static void depthdropper_depth_sample_pt(
155     bContext *C, DepthDropper *ddr, int mx, int my, float *r_depth)
156 {
157   /* we could use some clever */
158   bScreen *screen = CTX_wm_screen(C);
159   ScrArea *sa = BKE_screen_find_area_xy(screen, SPACE_TYPE_ANY, mx, my);
160   Scene *scene = CTX_data_scene(C);
161
162   ScrArea *area_prev = CTX_wm_area(C);
163   ARegion *ar_prev = CTX_wm_region(C);
164
165   ddr->name[0] = '\0';
166
167   if (sa) {
168     if (sa->spacetype == SPACE_VIEW3D) {
169       ARegion *ar = BKE_area_find_region_xy(sa, RGN_TYPE_WINDOW, mx, my);
170       if (ar) {
171         struct Depsgraph *depsgraph = CTX_data_depsgraph(C);
172         View3D *v3d = sa->spacedata.first;
173         RegionView3D *rv3d = ar->regiondata;
174         /* weak, we could pass in some reference point */
175         const float *view_co = v3d->camera ? v3d->camera->obmat[3] : rv3d->viewinv[3];
176         const int mval[2] = {mx - ar->winrct.xmin, my - ar->winrct.ymin};
177         float co[3];
178
179         CTX_wm_area_set(C, sa);
180         CTX_wm_region_set(C, ar);
181
182         /* grr, always draw else we leave stale text */
183         ED_region_tag_redraw(ar);
184
185         view3d_operator_needs_opengl(C);
186
187         if (ED_view3d_autodist(depsgraph, ar, v3d, mval, co, true, NULL)) {
188           const float mval_center_fl[2] = {(float)ar->winx / 2, (float)ar->winy / 2};
189           float co_align[3];
190
191           /* quick way to get view-center aligned point */
192           ED_view3d_win_to_3d(v3d, ar, co, mval_center_fl, co_align);
193
194           *r_depth = len_v3v3(view_co, co_align);
195
196           bUnit_AsString2(ddr->name,
197                           sizeof(ddr->name),
198                           (double)*r_depth,
199                           4,
200                           B_UNIT_LENGTH,
201                           &scene->unit,
202                           false);
203         }
204         else {
205           BLI_strncpy(ddr->name, "Nothing under cursor", sizeof(ddr->name));
206         }
207       }
208     }
209   }
210
211   CTX_wm_area_set(C, area_prev);
212   CTX_wm_region_set(C, ar_prev);
213 }
214
215 /* sets the sample depth RGB, maintaining A */
216 static void depthdropper_depth_set(bContext *C, DepthDropper *ddr, const float depth)
217 {
218   RNA_property_float_set(&ddr->ptr, ddr->prop, depth);
219   ddr->is_set = true;
220   RNA_property_update(C, &ddr->ptr, ddr->prop);
221 }
222
223 /* set sample from accumulated values */
224 static void depthdropper_depth_set_accum(bContext *C, DepthDropper *ddr)
225 {
226   float depth = ddr->accum_depth;
227   if (ddr->accum_tot) {
228     depth /= (float)ddr->accum_tot;
229   }
230   depthdropper_depth_set(C, ddr, depth);
231 }
232
233 /* single point sample & set */
234 static void depthdropper_depth_sample(bContext *C, DepthDropper *ddr, int mx, int my)
235 {
236   float depth = -1.0f;
237   if (depth != -1.0f) {
238     depthdropper_depth_sample_pt(C, ddr, mx, my, &depth);
239     depthdropper_depth_set(C, ddr, depth);
240   }
241 }
242
243 static void depthdropper_depth_sample_accum(bContext *C, DepthDropper *ddr, int mx, int my)
244 {
245   float depth = -1.0f;
246   depthdropper_depth_sample_pt(C, ddr, mx, my, &depth);
247   if (depth != -1.0f) {
248     ddr->accum_depth += depth;
249     ddr->accum_tot++;
250   }
251 }
252
253 static void depthdropper_cancel(bContext *C, wmOperator *op)
254 {
255   DepthDropper *ddr = op->customdata;
256   if (ddr->is_set) {
257     depthdropper_depth_set(C, ddr, ddr->init_depth);
258   }
259   depthdropper_exit(C, op);
260 }
261
262 /* main modal status check */
263 static int depthdropper_modal(bContext *C, wmOperator *op, const wmEvent *event)
264 {
265   DepthDropper *ddr = (DepthDropper *)op->customdata;
266
267   /* handle modal keymap */
268   if (event->type == EVT_MODAL_MAP) {
269     switch (event->val) {
270       case EYE_MODAL_CANCEL:
271         depthdropper_cancel(C, op);
272         return OPERATOR_CANCELLED;
273       case EYE_MODAL_SAMPLE_CONFIRM: {
274         const bool is_undo = ddr->is_undo;
275         if (ddr->accum_tot == 0) {
276           depthdropper_depth_sample(C, ddr, event->x, event->y);
277         }
278         else {
279           depthdropper_depth_set_accum(C, ddr);
280         }
281         depthdropper_exit(C, op);
282         /* Could support finished & undo-skip. */
283         return is_undo ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
284       }
285       case EYE_MODAL_SAMPLE_BEGIN:
286         /* enable accum and make first sample */
287         ddr->accum_start = true;
288         depthdropper_depth_sample_accum(C, ddr, event->x, event->y);
289         break;
290       case EYE_MODAL_SAMPLE_RESET:
291         ddr->accum_tot = 0;
292         ddr->accum_depth = 0.0f;
293         depthdropper_depth_sample_accum(C, ddr, event->x, event->y);
294         depthdropper_depth_set_accum(C, ddr);
295         break;
296     }
297   }
298   else if (event->type == MOUSEMOVE) {
299     if (ddr->accum_start) {
300       /* button is pressed so keep sampling */
301       depthdropper_depth_sample_accum(C, ddr, event->x, event->y);
302       depthdropper_depth_set_accum(C, ddr);
303     }
304   }
305
306   return OPERATOR_RUNNING_MODAL;
307 }
308
309 /* Modal Operator init */
310 static int depthdropper_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
311 {
312   /* init */
313   if (depthdropper_init(C, op)) {
314     WM_cursor_modal_set(CTX_wm_window(C), BC_EYEDROPPER_CURSOR);
315
316     /* add temp handler */
317     WM_event_add_modal_handler(C, op);
318
319     return OPERATOR_RUNNING_MODAL;
320   }
321   else {
322     return OPERATOR_CANCELLED;
323   }
324 }
325
326 /* Repeat operator */
327 static int depthdropper_exec(bContext *C, wmOperator *op)
328 {
329   /* init */
330   if (depthdropper_init(C, op)) {
331     /* cleanup */
332     depthdropper_exit(C, op);
333
334     return OPERATOR_FINISHED;
335   }
336   else {
337     return OPERATOR_CANCELLED;
338   }
339 }
340
341 static bool depthdropper_poll(bContext *C)
342 {
343   PointerRNA ptr;
344   PropertyRNA *prop;
345   int index_dummy;
346   uiBut *but;
347
348   /* check if there's an active button taking depth value */
349   if ((CTX_wm_window(C) != NULL) &&
350       (but = UI_context_active_but_prop_get(C, &ptr, &prop, &index_dummy)) &&
351       (but->type == UI_BTYPE_NUM) && (prop != NULL)) {
352     if ((RNA_property_type(prop) == PROP_FLOAT) &&
353         (RNA_property_subtype(prop) & PROP_UNIT_LENGTH) &&
354         (RNA_property_array_check(prop) == false)) {
355       return 1;
356     }
357   }
358   else {
359     RegionView3D *rv3d = CTX_wm_region_view3d(C);
360     if (rv3d && rv3d->persp == RV3D_CAMOB) {
361       View3D *v3d = CTX_wm_view3d(C);
362       if (v3d->camera && v3d->camera->data && !ID_IS_LINKED(v3d->camera->data)) {
363         return 1;
364       }
365     }
366   }
367
368   return 0;
369 }
370
371 void UI_OT_eyedropper_depth(wmOperatorType *ot)
372 {
373   /* identifiers */
374   ot->name = "Eyedropper Depth";
375   ot->idname = "UI_OT_eyedropper_depth";
376   ot->description = "Sample depth from the 3D view";
377
378   /* api callbacks */
379   ot->invoke = depthdropper_invoke;
380   ot->modal = depthdropper_modal;
381   ot->cancel = depthdropper_cancel;
382   ot->exec = depthdropper_exec;
383   ot->poll = depthdropper_poll;
384
385   /* flags */
386   ot->flag = OPTYPE_UNDO | OPTYPE_BLOCKING | OPTYPE_INTERNAL;
387
388   /* properties */
389 }