More tooltip tweaks
[blender.git] / source / blender / editors / gpencil / gpencil_utils.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) 2014, Blender Foundation
19  *
20  * Contributor(s): Joshua Leung
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/editors/gpencil/gpencil_utils.c
26  *  \ingroup edgpencil
27  */
28
29 #include <stdio.h>
30 #include <string.h>
31 #include <stdlib.h>
32 #include <stddef.h>
33 #include <math.h>
34
35 #include "BLI_math.h"
36 #include "BLI_blenlib.h"
37 #include "BLI_utildefines.h"
38
39 #include "DNA_gpencil_types.h"
40 #include "DNA_object_types.h"
41 #include "DNA_scene_types.h"
42 #include "DNA_screen_types.h"
43 #include "DNA_space_types.h"
44 #include "DNA_view3d_types.h"
45
46 #include "BKE_context.h"
47 #include "BKE_gpencil.h"
48 #include "BKE_tracking.h"
49
50 #include "WM_api.h"
51
52 #include "RNA_access.h"
53 #include "RNA_define.h"
54 #include "RNA_enum_types.h"
55
56 #include "UI_resources.h"
57 #include "UI_view2d.h"
58
59 #include "ED_gpencil.h"
60 #include "ED_clip.h"
61 #include "ED_view3d.h"
62
63 #include "gpencil_intern.h"
64
65 /* ******************************************************** */
66 /* Context Wrangling... */
67
68 /* Get pointer to active Grease Pencil datablock, and an RNA-pointer to trace back to whatever owns it,
69  * when context info is not available.
70  */
71 bGPdata **ED_gpencil_data_get_pointers_direct(ID *screen_id, Scene *scene, ScrArea *sa, Object *ob, PointerRNA *ptr)
72 {
73         /* if there's an active area, check if the particular editor may
74          * have defined any special Grease Pencil context for editing...
75          */
76         if (sa) {
77                 SpaceLink *sl = sa->spacedata.first;
78                 
79                 switch (sa->spacetype) {
80                         case SPACE_VIEW3D: /* 3D-View */
81                         {
82                                 BLI_assert(scene && ELEM(scene->toolsettings->gpencil_src,
83                                                          GP_TOOL_SOURCE_SCENE, GP_TOOL_SOURCE_OBJECT));
84                                 
85                                 if (scene->toolsettings->gpencil_src == GP_TOOL_SOURCE_OBJECT) {
86                                         /* legacy behaviour for usage with old addons requiring object-linked to objects */
87                                         
88                                         /* just in case no active/selected object... */
89                                         if (ob && (ob->flag & SELECT)) {
90                                                 /* for now, as long as there's an object, default to using that in 3D-View */
91                                                 if (ptr) RNA_id_pointer_create(&ob->id, ptr);
92                                                 return &ob->gpd;
93                                         }
94                                         /* else: defaults to scene... */
95                                 }
96                                 else {
97                                         if (ptr) RNA_id_pointer_create(&scene->id, ptr);
98                                         return &scene->gpd;
99                                 }
100                                 break;
101                         }
102                         case SPACE_NODE: /* Nodes Editor */
103                         {
104                                 SpaceNode *snode = (SpaceNode *)sl;
105                                 
106                                 /* return the GP data for the active node block/node */
107                                 if (snode && snode->nodetree) {
108                                         /* for now, as long as there's an active node tree, default to using that in the Nodes Editor */
109                                         if (ptr) RNA_id_pointer_create(&snode->nodetree->id, ptr);
110                                         return &snode->nodetree->gpd;
111                                 }
112                                 
113                                 /* even when there is no node-tree, don't allow this to flow to scene */
114                                 return NULL;
115                         }
116                         case SPACE_SEQ: /* Sequencer */
117                         {
118                                 SpaceSeq *sseq = (SpaceSeq *)sl;
119                         
120                                 /* for now, Grease Pencil data is associated with the space (actually preview region only) */
121                                 /* XXX our convention for everything else is to link to data though... */
122                                 if (ptr) RNA_pointer_create(screen_id, &RNA_SpaceSequenceEditor, sseq, ptr);
123                                 return &sseq->gpd;
124                         }
125                         case SPACE_IMAGE: /* Image/UV Editor */
126                         {
127                                 SpaceImage *sima = (SpaceImage *)sl;
128                                 
129                                 /* for now, Grease Pencil data is associated with the space... */
130                                 /* XXX our convention for everything else is to link to data though... */
131                                 if (ptr) RNA_pointer_create(screen_id, &RNA_SpaceImageEditor, sima, ptr);
132                                 return &sima->gpd;
133                         }
134                         case SPACE_CLIP: /* Nodes Editor */
135                         {
136                                 SpaceClip *sc = (SpaceClip *)sl;
137                                 MovieClip *clip = ED_space_clip_get_clip(sc);
138                                 
139                                 if (clip) {
140                                         if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) {
141                                                 MovieTrackingTrack *track = BKE_tracking_track_get_active(&clip->tracking);
142                                                 
143                                                 if (!track)
144                                                         return NULL;
145                                                 
146                                                 if (ptr)
147                                                         RNA_pointer_create(&clip->id, &RNA_MovieTrackingTrack, track, ptr);
148                                                 
149                                                 return &track->gpd;
150                                         }
151                                         else {
152                                                 if (ptr)
153                                                         RNA_id_pointer_create(&clip->id, ptr);
154                                                 
155                                                 return &clip->gpd;
156                                         }
157                                 }
158                                 break;
159                         }
160                         default: /* unsupported space */
161                                 return NULL;
162                 }
163         }
164         
165         /* just fall back on the scene's GP data */
166         if (ptr) RNA_id_pointer_create((ID *)scene, ptr);
167         return (scene) ? &scene->gpd : NULL;
168 }
169
170 /* Get pointer to active Grease Pencil datablock, and an RNA-pointer to trace back to whatever owns it */
171 bGPdata **ED_gpencil_data_get_pointers(const bContext *C, PointerRNA *ptr)
172 {
173         ID *screen_id = (ID *)CTX_wm_screen(C);
174         Scene *scene = CTX_data_scene(C);
175         ScrArea *sa = CTX_wm_area(C);
176         Object *ob = CTX_data_active_object(C);
177         
178         return ED_gpencil_data_get_pointers_direct(screen_id, scene, sa, ob, ptr);
179 }
180
181 /* -------------------------------------------------------- */
182
183 /* Get the active Grease Pencil datablock, when context is not available */
184 bGPdata *ED_gpencil_data_get_active_direct(ID *screen_id, Scene *scene, ScrArea *sa, Object *ob)
185 {
186         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers_direct(screen_id, scene, sa, ob, NULL);
187         return (gpd_ptr) ? *(gpd_ptr) : NULL;
188 }
189
190 /* Get the active Grease Pencil datablock */
191 bGPdata *ED_gpencil_data_get_active(const bContext *C)
192 {
193         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers(C, NULL);
194         return (gpd_ptr) ? *(gpd_ptr) : NULL;
195 }
196
197 /* -------------------------------------------------------- */
198
199 // XXX: this should be removed... We really shouldn't duplicate logic like this!
200 bGPdata *ED_gpencil_data_get_active_v3d(Scene *scene, View3D *v3d)
201 {
202         Base *base = scene->basact;
203         bGPdata *gpd = NULL;
204         /* We have to make sure active object is actually visible and selected, else we must use default scene gpd,
205          * to be consistent with ED_gpencil_data_get_active's behavior.
206          */
207         
208         if (base && TESTBASE(v3d, base)) {
209                 gpd = base->object->gpd;
210         }
211         return gpd ? gpd : scene->gpd;
212 }
213
214 /* ******************************************************** */
215 /* Keyframe Indicator Checks */
216
217 /* Check whether there's an active GP keyframe on the current frame */
218 bool ED_gpencil_has_keyframe_v3d(Scene *scene, Object *ob, int cfra)
219 {
220         /* just check both for now... */
221         // XXX: this could get confusing (e.g. if only on the object, but other places don't show this)
222         if (scene->gpd) {
223                 bGPDlayer *gpl = gpencil_layer_getactive(scene->gpd);
224                 if (gpl) {
225                         if (gpl->actframe) {
226                                 // XXX: assumes that frame has been fetched already
227                                 return (gpl->actframe->framenum == cfra);
228                         }
229                         else {
230                                 /* XXX: disabled as could be too much of a penalty */
231                                 /* return BKE_gpencil_layer_find_frame(gpl, cfra); */
232                         }
233                 }
234         }
235         
236         if (ob && ob->gpd) {
237                 bGPDlayer *gpl = gpencil_layer_getactive(ob->gpd);
238                 if (gpl) {
239                         if (gpl->actframe) {
240                                 // XXX: assumes that frame has been fetched already
241                                 return (gpl->actframe->framenum == cfra);
242                         }
243                         else {
244                                 /* XXX: disabled as could be too much of a penalty */
245                                 /* return BKE_gpencil_layer_find_frame(gpl, cfra); */
246                         }
247                 }
248         }
249         
250         return false;
251 }
252
253 /* ******************************************************** */
254 /* Poll Callbacks */
255
256 /* poll callback for adding data/layers - special */
257 int gp_add_poll(bContext *C)
258 {
259         /* the base line we have is that we have somewhere to add Grease Pencil data */
260         return ED_gpencil_data_get_pointers(C, NULL) != NULL;
261 }
262
263 /* poll callback for checking if there is an active layer */
264 int gp_active_layer_poll(bContext *C)
265 {
266         bGPdata *gpd = ED_gpencil_data_get_active(C);
267         bGPDlayer *gpl = gpencil_layer_getactive(gpd);
268         
269         return (gpl != NULL);
270 }
271
272 /* ******************************************************** */
273 /* Dynamic Enums of GP Layers */
274 /* NOTE: These include an option to create a new layer and use that... */
275
276 /* Just existing layers */
277 EnumPropertyItem *ED_gpencil_layers_enum_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
278 {
279         bGPdata *gpd = CTX_data_gpencil_data(C);
280         bGPDlayer *gpl;
281         EnumPropertyItem *item = NULL, item_tmp = {0};
282         int totitem = 0;
283         int i = 0;
284         
285         if (ELEM(NULL, C, gpd)) {
286                 return DummyRNA_DEFAULT_items;
287         }
288         
289         /* Existing layers */
290         for (gpl = gpd->layers.first; gpl; gpl = gpl->next, i++) {
291                 item_tmp.identifier = gpl->info;
292                 item_tmp.name = gpl->info;
293                 item_tmp.value = i;
294                 
295                 if (gpl->flag & GP_LAYER_ACTIVE)
296                         item_tmp.icon = ICON_GREASEPENCIL;
297                 else 
298                         item_tmp.icon = ICON_NONE;
299                 
300                 RNA_enum_item_add(&item, &totitem, &item_tmp);
301         }
302         
303         RNA_enum_item_end(&item, &totitem);
304         *r_free = true;
305
306         return item;
307 }
308
309 /* Existing + Option to add/use new layer */
310 EnumPropertyItem *ED_gpencil_layers_with_new_enum_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
311 {
312         bGPdata *gpd = CTX_data_gpencil_data(C);
313         bGPDlayer *gpl;
314         EnumPropertyItem *item = NULL, item_tmp = {0};
315         int totitem = 0;
316         int i = 0;
317         
318         if (ELEM(NULL, C, gpd)) {
319                 return DummyRNA_DEFAULT_items;
320         }
321         
322         /* Create new layer */
323         /* TODO: have some way of specifying that we don't want this? */
324         {
325                 /* active Keying Set */
326                 item_tmp.identifier = "__CREATE__";
327                 item_tmp.name = "New Layer";
328                 item_tmp.value = -1;
329                 item_tmp.icon = ICON_ZOOMIN;
330                 RNA_enum_item_add(&item, &totitem, &item_tmp);
331                 
332                 /* separator */
333                 RNA_enum_item_add_separator(&item, &totitem);
334         }
335         
336         /* Existing layers */
337         for (gpl = gpd->layers.first, i = 0; gpl; gpl = gpl->next, i++) {
338                 item_tmp.identifier = gpl->info;
339                 item_tmp.name = gpl->info;
340                 item_tmp.value = i;
341                 
342                 if (gpl->flag & GP_LAYER_ACTIVE)
343                         item_tmp.icon = ICON_GREASEPENCIL;
344                 else 
345                         item_tmp.icon = ICON_NONE;
346                 
347                 RNA_enum_item_add(&item, &totitem, &item_tmp);
348         }
349         
350         RNA_enum_item_end(&item, &totitem);
351         *r_free = true;
352
353         return item;
354 }
355
356
357
358 /* ******************************************************** */
359 /* Brush Tool Core */
360
361 /* Check if part of stroke occurs within last segment drawn by eraser */
362 bool gp_stroke_inside_circle(const int mval[2], const int UNUSED(mvalo[2]),
363                              int rad, int x0, int y0, int x1, int y1)
364 {
365         /* simple within-radius check for now */
366         const float mval_fl[2]     = {mval[0], mval[1]};
367         const float screen_co_a[2] = {x0, y0};
368         const float screen_co_b[2] = {x1, y1};
369         
370         if (edge_inside_circle(mval_fl, rad, screen_co_a, screen_co_b)) {
371                 return true;
372         }
373         
374         /* not inside */
375         return false;
376 }
377
378 /* ******************************************************** */
379 /* Stroke Validity Testing */
380
381 /* Check whether given stroke can be edited given the supplied context */
382 // XXX: do we need additional flags for screenspace vs dataspace?
383 bool ED_gpencil_stroke_can_use_direct(const ScrArea *sa, const bGPDstroke *gps)
384 {
385         /* sanity check */
386         if (ELEM(NULL, sa, gps))
387                 return false;
388
389         /* filter stroke types by flags + spacetype */
390         if (gps->flag & GP_STROKE_3DSPACE) {
391                 /* 3D strokes - only in 3D view */
392                 return (sa->spacetype == SPACE_VIEW3D);
393         }
394         else if (gps->flag & GP_STROKE_2DIMAGE) {
395                 /* Special "image" strokes - only in Image Editor */
396                 return (sa->spacetype == SPACE_IMAGE);
397         }
398         else if (gps->flag & GP_STROKE_2DSPACE) {
399                 /* 2D strokes (dataspace) - for any 2D view (i.e. everything other than 3D view) */
400                 return (sa->spacetype != SPACE_VIEW3D);
401         }
402         else {
403                 /* view aligned - anything goes */
404                 return true;
405         }
406 }
407
408 /* Check whether given stroke can be edited in the current context */
409 bool ED_gpencil_stroke_can_use(const bContext *C, const bGPDstroke *gps)
410 {
411         ScrArea *sa = CTX_wm_area(C);
412         return ED_gpencil_stroke_can_use_direct(sa, gps);
413 }
414
415 /* ******************************************************** */
416 /* Space Conversion */
417
418 /* Init handling for space-conversion function (from passed-in parameters) */
419 void gp_point_conversion_init(bContext *C, GP_SpaceConversion *r_gsc)
420 {
421         ScrArea *sa = CTX_wm_area(C);
422         ARegion *ar = CTX_wm_region(C);
423         
424         /* zero out the storage (just in case) */
425         memset(r_gsc, 0, sizeof(GP_SpaceConversion));
426         unit_m4(r_gsc->mat);
427         
428         /* store settings */
429         r_gsc->sa = sa;
430         r_gsc->ar = ar;
431         r_gsc->v2d = &ar->v2d;
432         
433         /* init region-specific stuff */
434         if (sa->spacetype == SPACE_VIEW3D) {
435                 wmWindow *win = CTX_wm_window(C);
436                 Scene *scene = CTX_data_scene(C);
437                 View3D *v3d = (View3D *)CTX_wm_space_data(C);
438                 RegionView3D *rv3d = ar->regiondata;
439                 
440                 /* init 3d depth buffers */
441                 view3d_operator_needs_opengl(C);
442                 
443                 view3d_region_operator_needs_opengl(win, ar);
444                 ED_view3d_autodist_init(scene, ar, v3d, 0);
445                 
446                 /* for camera view set the subrect */
447                 if (rv3d->persp == RV3D_CAMOB) {
448                         ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &r_gsc->subrect_data, true); /* no shift */
449                         r_gsc->subrect = &r_gsc->subrect_data;
450                 }
451         }
452 }
453
454
455 /* Convert Grease Pencil points to screen-space values
456  * WARNING: This assumes that the caller has already checked whether the stroke in question can be drawn
457  */
458 void gp_point_to_xy(GP_SpaceConversion *gsc, bGPDstroke *gps, bGPDspoint *pt,
459                     int *r_x, int *r_y)
460 {
461         ARegion *ar = gsc->ar;
462         View2D *v2d = gsc->v2d;
463         rctf *subrect = gsc->subrect;
464         int xyval[2];
465         
466         /* sanity checks */
467         BLI_assert(!(gps->flag & GP_STROKE_3DSPACE) || (gsc->sa->spacetype == SPACE_VIEW3D));
468         BLI_assert(!(gps->flag & GP_STROKE_2DSPACE) || (gsc->sa->spacetype != SPACE_VIEW3D));
469         
470         
471         if (gps->flag & GP_STROKE_3DSPACE) {
472                 if (ED_view3d_project_int_global(ar, &pt->x, xyval, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
473                         *r_x = xyval[0];
474                         *r_y = xyval[1];
475                 }
476                 else {
477                         *r_x = V2D_IS_CLIPPED;
478                         *r_y = V2D_IS_CLIPPED;
479                 }
480         }
481         else if (gps->flag & GP_STROKE_2DSPACE) {
482                 float vec[3] = {pt->x, pt->y, 0.0f};
483                 mul_m4_v3(gsc->mat, vec);
484                 UI_view2d_view_to_region_clip(v2d, vec[0], vec[1], r_x, r_y);
485         }
486         else {
487                 if (subrect == NULL) {
488                         /* normal 3D view (or view space) */
489                         *r_x = (int)(pt->x / 100 * ar->winx);
490                         *r_y = (int)(pt->y / 100 * ar->winy);
491                 }
492                 else {
493                         /* camera view, use subrect */
494                         *r_x = (int)((pt->x / 100) * BLI_rctf_size_x(subrect)) + subrect->xmin;
495                         *r_y = (int)((pt->y / 100) * BLI_rctf_size_y(subrect)) + subrect->ymin;
496                 }
497         }
498 }
499
500 /**
501  * Project screenspace coordinates to 3D-space
502  *
503  * \note We include this as a utility function, since the standard method
504  * involves quite a few steps, which are invariably always the same
505  * for all GPencil operations. So, it's nicer to just centralize these.
506  *
507  * \warning Assumes that it is getting called in a 3D view only.
508  */
509 bool gp_point_xy_to_3d(GP_SpaceConversion *gsc, Scene *scene, const float screen_co[2], float r_out[3])
510 {
511         View3D *v3d = gsc->sa->spacedata.first;
512         RegionView3D *rv3d = gsc->ar->regiondata;
513         float *rvec = ED_view3d_cursor3d_get(scene, v3d);
514         float ref[3] = {rvec[0], rvec[1], rvec[2]};
515         float zfac = ED_view3d_calc_zfac(rv3d, rvec, NULL);
516         
517         float mval_f[2], mval_prj[2];
518         float dvec[3];
519         
520         copy_v2_v2(mval_f, screen_co);
521         
522         if (ED_view3d_project_float_global(gsc->ar, ref, mval_prj, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
523                 sub_v2_v2v2(mval_f, mval_prj, mval_f);
524                 ED_view3d_win_to_delta(gsc->ar, mval_f, dvec, zfac);
525                 sub_v3_v3v3(r_out, rvec, dvec);
526                 
527                 return true;
528         }
529         else {
530                 zero_v3(r_out);
531                 
532                 return false;
533         }
534 }
535
536 /* ******************************************************** */