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, Antonio Vazquez
  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 "MEM_guardedalloc.h"
  36
  37 #include "BLI_math.h"
  38 #include "BLI_blenlib.h"
  39 #include "BLI_utildefines.h"
  40 #include "BLT_translation.h"
  41 #include "BLI_rand.h"
  42
  43 #include "DNA_gpencil_types.h"
  44 #include "DNA_object_types.h"
  45 #include "DNA_scene_types.h"
  46 #include "DNA_screen_types.h"
  47 #include "DNA_space_types.h"
  48 #include "DNA_view3d_types.h"
  49
  50 #include "BKE_context.h"
  51 #include "BKE_gpencil.h"
  52 #include "BKE_tracking.h"
  53 #include "BKE_action.h"
  54
  55 #include "WM_api.h"
  56
  57 #include "RNA_access.h"
  58 #include "RNA_define.h"
  59 #include "RNA_enum_types.h"
  60
  61 #include "UI_resources.h"
  62 #include "UI_view2d.h"
  63
  64 #include "ED_gpencil.h"
  65 #include "ED_clip.h"
  66 #include "ED_view3d.h"
  67
  68 #include "gpencil_intern.h"
  69
  70 /* ******************************************************** */
  71 /* Context Wrangling... */
  72
  73 /* Get pointer to active Grease Pencil datablock, and an RNA-pointer to trace back to whatever owns it,
  74  * when context info is not available.
  75  */
  76 bGPdata **ED_gpencil_data_get_pointers_direct(ID *screen_id, Scene *scene, ScrArea *sa, Object *ob, PointerRNA *ptr)
  77 {
  78         /* if there's an active area, check if the particular editor may
  79          * have defined any special Grease Pencil context for editing...
  80          */
  81         if (sa) {
  82                 SpaceLink *sl = sa->spacedata.first;
  83
  84                 switch (sa->spacetype) {
  85                         case SPACE_VIEW3D: /* 3D-View */
  86                         {
  87                                 BLI_assert(scene && ELEM(scene->toolsettings->gpencil_src,
  88                                                          GP_TOOL_SOURCE_SCENE, GP_TOOL_SOURCE_OBJECT));
  89
  90                                 if (scene->toolsettings->gpencil_src == GP_TOOL_SOURCE_OBJECT) {
  91                                         /* legacy behaviour for usage with old addons requiring object-linked to objects */
  92
  93                                         /* just in case no active/selected object... */
  94                                         if (ob && (ob->flag & SELECT)) {
  95                                                 /* for now, as long as there's an object, default to using that in 3D-View */
  96                                                 if (ptr) RNA_id_pointer_create(&ob->id, ptr);
  97                                                 return &ob->gpd;
  98                                         }
  99                                         /* else: defaults to scene... */
 100                                 }
 101                                 else {
 102                                         if (ptr) RNA_id_pointer_create(&scene->id, ptr);
 103                                         return &scene->gpd;
 104                                 }
 105                                 break;
 106                         }
 107                         case SPACE_NODE: /* Nodes Editor */
 108                         {
 109                                 SpaceNode *snode = (SpaceNode *)sl;
 110
 111                                 /* return the GP data for the active node block/node */
 112                                 if (snode && snode->nodetree) {
 113                                         /* for now, as long as there's an active node tree, default to using that in the Nodes Editor */
 114                                         if (ptr) RNA_id_pointer_create(&snode->nodetree->id, ptr);
 115                                         return &snode->nodetree->gpd;
 116                                 }
 117
 118                                 /* even when there is no node-tree, don't allow this to flow to scene */
 119                                 return NULL;
 120                         }
 121                         case SPACE_SEQ: /* Sequencer */
 122                         {
 123                                 SpaceSeq *sseq = (SpaceSeq *)sl;
 124
 125                                 /* for now, Grease Pencil data is associated with the space (actually preview region only) */
 126                                 /* XXX our convention for everything else is to link to data though... */
 127                                 if (ptr) RNA_pointer_create(screen_id, &RNA_SpaceSequenceEditor, sseq, ptr);
 128                                 return &sseq->gpd;
 129                         }
 130                         case SPACE_IMAGE: /* Image/UV Editor */
 131                         {
 132                                 SpaceImage *sima = (SpaceImage *)sl;
 133
 134                                 /* for now, Grease Pencil data is associated with the space... */
 135                                 /* XXX our convention for everything else is to link to data though... */
 136                                 if (ptr) RNA_pointer_create(screen_id, &RNA_SpaceImageEditor, sima, ptr);
 137                                 return &sima->gpd;
 138                         }
 139                         case SPACE_CLIP: /* Nodes Editor */
 140                         {
 141                                 SpaceClip *sc = (SpaceClip *)sl;
 142                                 MovieClip *clip = ED_space_clip_get_clip(sc);
 143
 144                                 if (clip) {
 145                                         if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) {
 146                                                 MovieTrackingTrack *track = BKE_tracking_track_get_active(&clip->tracking);
 147
 148                                                 if (!track)
 149                                                         return NULL;
 150
 151                                                 if (ptr)
 152                                                         RNA_pointer_create(&clip->id, &RNA_MovieTrackingTrack, track, ptr);
 153
 154                                                 return &track->gpd;
 155                                         }
 156                                         else {
 157                                                 if (ptr)
 158                                                         RNA_id_pointer_create(&clip->id, ptr);
 159
 160                                                 return &clip->gpd;
 161                                         }
 162                                 }
 163                                 break;
 164                         }
 165                         default: /* unsupported space */
 166                                 return NULL;
 167                 }
 168         }
 169
 170         /* just fall back on the scene's GP data */
 171         if (ptr) RNA_id_pointer_create((ID *)scene, ptr);
 172         return (scene) ? &scene->gpd : NULL;
 173 }
 174
 175 /* Get pointer to active Grease Pencil datablock, and an RNA-pointer to trace back to whatever owns it */
 176 bGPdata **ED_gpencil_data_get_pointers(const bContext *C, PointerRNA *ptr)
 177 {
 178         ID *screen_id = (ID *)CTX_wm_screen(C);
 179         Scene *scene = CTX_data_scene(C);
 180         ScrArea *sa = CTX_wm_area(C);
 181         Object *ob = CTX_data_active_object(C);
 182
 183         return ED_gpencil_data_get_pointers_direct(screen_id, scene, sa, ob, ptr);
 184 }
 185
 186 /* -------------------------------------------------------- */
 187
 188 /* Get the active Grease Pencil datablock, when context is not available */
 189 bGPdata *ED_gpencil_data_get_active_direct(ID *screen_id, Scene *scene, ScrArea *sa, Object *ob)
 190 {
 191         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers_direct(screen_id, scene, sa, ob, NULL);
 192         return (gpd_ptr) ? *(gpd_ptr) : NULL;
 193 }
 194
 195 /* Get the active Grease Pencil datablock */
 196 bGPdata *ED_gpencil_data_get_active(const bContext *C)
 197 {
 198         bGPdata **gpd_ptr = ED_gpencil_data_get_pointers(C, NULL);
 199         return (gpd_ptr) ? *(gpd_ptr) : NULL;
 200 }
 201
 202 /* -------------------------------------------------------- */
 203
 204 // XXX: this should be removed... We really shouldn't duplicate logic like this!
 205 bGPdata *ED_gpencil_data_get_active_v3d(Scene *scene, View3D *v3d)
 206 {
 207         Base *base = scene->basact;
 208         bGPdata *gpd = NULL;
 209         /* We have to make sure active object is actually visible and selected, else we must use default scene gpd,
 210          * to be consistent with ED_gpencil_data_get_active's behavior.
 211          */
 212
 213         if (base && TESTBASE(v3d, base)) {
 214                 gpd = base->object->gpd;
 215         }
 216         return gpd ? gpd : scene->gpd;
 217 }
 218
 219 /* ******************************************************** */
 220 /* Keyframe Indicator Checks */
 221
 222 /* Check whether there's an active GP keyframe on the current frame */
 223 bool ED_gpencil_has_keyframe_v3d(Scene *scene, Object *ob, int cfra)
 224 {
 225         /* just check both for now... */
 226         // XXX: this could get confusing (e.g. if only on the object, but other places don't show this)
 227         if (scene->gpd) {
 228                 bGPDlayer *gpl = BKE_gpencil_layer_getactive(scene->gpd);
 229                 if (gpl) {
 230                         if (gpl->actframe) {
 231                                 // XXX: assumes that frame has been fetched already
 232                                 return (gpl->actframe->framenum == cfra);
 233                         }
 234                         else {
 235                                 /* XXX: disabled as could be too much of a penalty */
 236                                 /* return BKE_gpencil_layer_find_frame(gpl, cfra); */
 237                         }
 238                 }
 239         }
 240
 241         if (ob && ob->gpd) {
 242                 bGPDlayer *gpl = BKE_gpencil_layer_getactive(ob->gpd);
 243                 if (gpl) {
 244                         if (gpl->actframe) {
 245                                 // XXX: assumes that frame has been fetched already
 246                                 return (gpl->actframe->framenum == cfra);
 247                         }
 248                         else {
 249                                 /* XXX: disabled as could be too much of a penalty */
 250                                 /* return BKE_gpencil_layer_find_frame(gpl, cfra); */
 251                         }
 252                 }
 253         }
 254
 255         return false;
 256 }
 257
 258 /* ******************************************************** */
 259 /* Poll Callbacks */
 260
 261 /* poll callback for adding data/layers - special */
 262 int gp_add_poll(bContext *C)
 263 {
 264         /* the base line we have is that we have somewhere to add Grease Pencil data */
 265         return ED_gpencil_data_get_pointers(C, NULL) != NULL;
 266 }
 267
 268 /* poll callback for checking if there is an active layer */
 269 int gp_active_layer_poll(bContext *C)
 270 {
 271         bGPdata *gpd = ED_gpencil_data_get_active(C);
 272         bGPDlayer *gpl = BKE_gpencil_layer_getactive(gpd);
 273
 274         return (gpl != NULL);
 275 }
 276
 277 /* poll callback for checking if there is an active brush */
 278 int gp_active_brush_poll(bContext *C)
 279 {
 280         ToolSettings *ts = CTX_data_tool_settings(C);
 281         bGPDbrush *brush = BKE_gpencil_brush_getactive(ts);
 282
 283         return (brush != NULL);
 284 }
 285
 286 /* poll callback for checking if there is an active palette */
 287 int gp_active_palette_poll(bContext *C)
 288 {
 289         bGPdata *gpd = ED_gpencil_data_get_active(C);
 290         bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
 291
 292         return (palette != NULL);
 293 }
 294
 295 /* poll callback for checking if there is an active palette color */
 296 int gp_active_palettecolor_poll(bContext *C)
 297 {
 298         bGPdata *gpd = ED_gpencil_data_get_active(C);
 299         bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
 300         bGPDpalettecolor *palcolor = BKE_gpencil_palettecolor_getactive(palette);
 301
 302         return (palcolor != NULL);
 303 }
 304
 305 /* ******************************************************** */
 306 /* Dynamic Enums of GP Layers */
 307 /* NOTE: These include an option to create a new layer and use that... */
 308
 309 /* Just existing layers */
 310 EnumPropertyItem *ED_gpencil_layers_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         /* Existing layers */
 323         for (gpl = gpd->layers.first; gpl; gpl = gpl->next, i++) {
 324                 item_tmp.identifier = gpl->info;
 325                 item_tmp.name = gpl->info;
 326                 item_tmp.value = i;
 327
 328                 if (gpl->flag & GP_LAYER_ACTIVE)
 329                         item_tmp.icon = ICON_GREASEPENCIL;
 330                 else
 331                         item_tmp.icon = ICON_NONE;
 332
 333                 RNA_enum_item_add(&item, &totitem, &item_tmp);
 334         }
 335
 336         RNA_enum_item_end(&item, &totitem);
 337         *r_free = true;
 338
 339         return item;
 340 }
 341
 342 /* Existing + Option to add/use new layer */
 343 EnumPropertyItem *ED_gpencil_layers_with_new_enum_itemf(bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
 344 {
 345         bGPdata *gpd = CTX_data_gpencil_data(C);
 346         bGPDlayer *gpl;
 347         EnumPropertyItem *item = NULL, item_tmp = {0};
 348         int totitem = 0;
 349         int i = 0;
 350
 351         if (ELEM(NULL, C, gpd)) {
 352                 return DummyRNA_DEFAULT_items;
 353         }
 354
 355         /* Create new layer */
 356         /* TODO: have some way of specifying that we don't want this? */
 357         {
 358                 /* active Keying Set */
 359                 item_tmp.identifier = "__CREATE__";
 360                 item_tmp.name = "New Layer";
 361                 item_tmp.value = -1;
 362                 item_tmp.icon = ICON_ZOOMIN;
 363                 RNA_enum_item_add(&item, &totitem, &item_tmp);
 364
 365                 /* separator */
 366                 RNA_enum_item_add_separator(&item, &totitem);
 367         }
 368
 369         /* Existing layers */
 370         for (gpl = gpd->layers.first, i = 0; gpl; gpl = gpl->next, i++) {
 371                 item_tmp.identifier = gpl->info;
 372                 item_tmp.name = gpl->info;
 373                 item_tmp.value = i;
 374
 375                 if (gpl->flag & GP_LAYER_ACTIVE)
 376                         item_tmp.icon = ICON_GREASEPENCIL;
 377                 else
 378                         item_tmp.icon = ICON_NONE;
 379
 380                 RNA_enum_item_add(&item, &totitem, &item_tmp);
 381         }
 382
 383         RNA_enum_item_end(&item, &totitem);
 384         *r_free = true;
 385
 386         return item;
 387 }
 388
 389
 390
 391 /* ******************************************************** */
 392 /* Brush Tool Core */
 393
 394 /**
 395  * Check whether a given stroke segment is inside a circular brush
 396  *
 397  * \param mval     The current screen-space coordinates (midpoint) of the brush
 398  * \param mvalo    The previous screen-space coordinates (midpoint) of the brush (NOT CURRENTLY USED)
 399  * \param rad      The radius of the brush
 400  *
 401  * \param x0, y0   The screen-space x and y coordinates of the start of the stroke segment
 402  * \param x1, y1   The screen-space x and y coordinates of the end of the stroke segment
 403  */
 404 bool gp_stroke_inside_circle(const int mval[2], const int UNUSED(mvalo[2]),
 405                              int rad, int x0, int y0, int x1, int y1)
 406 {
 407         /* simple within-radius check for now */
 408         const float mval_fl[2]     = {mval[0], mval[1]};
 409         const float screen_co_a[2] = {x0, y0};
 410         const float screen_co_b[2] = {x1, y1};
 411
 412         if (edge_inside_circle(mval_fl, rad, screen_co_a, screen_co_b)) {
 413                 return true;
 414         }
 415
 416         /* not inside */
 417         return false;
 418 }
 419
 420 /* ******************************************************** */
 421 /* Stroke Validity Testing */
 422
 423 /* Check whether given stroke can be edited given the supplied context */
 424 // XXX: do we need additional flags for screenspace vs dataspace?
 425 bool ED_gpencil_stroke_can_use_direct(const ScrArea *sa, const bGPDstroke *gps)
 426 {
 427         /* sanity check */
 428         if (ELEM(NULL, sa, gps))
 429                 return false;
 430
 431         /* filter stroke types by flags + spacetype */
 432         if (gps->flag & GP_STROKE_3DSPACE) {
 433                 /* 3D strokes - only in 3D view */
 434                 return (sa->spacetype == SPACE_VIEW3D);
 435         }
 436         else if (gps->flag & GP_STROKE_2DIMAGE) {
 437                 /* Special "image" strokes - only in Image Editor */
 438                 return (sa->spacetype == SPACE_IMAGE);
 439         }
 440         else if (gps->flag & GP_STROKE_2DSPACE) {
 441                 /* 2D strokes (dataspace) - for any 2D view (i.e. everything other than 3D view) */
 442                 return (sa->spacetype != SPACE_VIEW3D);
 443         }
 444         else {
 445                 /* view aligned - anything goes */
 446                 return true;
 447         }
 448 }
 449
 450 /* Check whether given stroke can be edited in the current context */
 451 bool ED_gpencil_stroke_can_use(const bContext *C, const bGPDstroke *gps)
 452 {
 453         ScrArea *sa = CTX_wm_area(C);
 454         return ED_gpencil_stroke_can_use_direct(sa, gps);
 455 }
 456
 457 /* Check whether given stroke can be edited for the current color */
 458 bool ED_gpencil_stroke_color_use(const bGPDlayer *gpl, const bGPDstroke *gps)
 459 {
 460         /* check if the color is editable */
 461         bGPDpalettecolor *palcolor = gps->palcolor;
 462         if (palcolor != NULL) {
 463                 if (palcolor->flag & PC_COLOR_HIDE)
 464                         return false;
 465                 if (((gpl->flag & GP_LAYER_UNLOCK_COLOR) == 0) && (palcolor->flag & PC_COLOR_LOCKED))
 466                         return false;
 467         }
 468
 469         return true;
 470 }
 471
 472 /* Get palette color or create a new one */
 473 bGPDpalettecolor *ED_gpencil_stroke_getcolor(bGPdata *gpd, bGPDstroke *gps)
 474 {
 475         bGPDpalette *palette;
 476         bGPDpalettecolor *palcolor;
 477
 478         if ((gps->palcolor != NULL) && ((gps->flag & GP_STROKE_RECALC_COLOR) == 0))
 479                 return gps->palcolor;
 480
 481         /* get palette */
 482         palette = BKE_gpencil_palette_getactive(gpd);
 483         if (palette == NULL) {
 484                 palette = BKE_gpencil_palette_addnew(gpd, DATA_("GP_Palette"), true);
 485         }
 486         /* get color */
 487         palcolor = BKE_gpencil_palettecolor_getbyname(palette, gps->colorname);
 488         if (palcolor == NULL) {
 489                 if (gps->palcolor == NULL) {
 490                         palcolor = BKE_gpencil_palettecolor_addnew(palette, DATA_("Color"), true);
 491                         /* set to a different color */
 492                         ARRAY_SET_ITEMS(palcolor->color, 1.0f, 0.0f, 1.0f, 0.9f);
 493                 }
 494                 else {
 495                         palcolor = BKE_gpencil_palettecolor_addnew(palette, gps->colorname, true);
 496                         /* set old color and attributes */
 497                         bGPDpalettecolor *gpscolor = gps->palcolor;
 498                         copy_v4_v4(palcolor->color, gpscolor->color);
 499                         copy_v4_v4(palcolor->fill, gpscolor->fill);
 500                         palcolor->flag = gpscolor->flag;
 501                 }
 502         }
 503
 504         /* clear flag and set pointer */
 505         gps->flag &= ~GP_STROKE_RECALC_COLOR;
 506         gps->palcolor = palcolor;
 507
 508         return palcolor;
 509 }
 510
 511 /* ******************************************************** */
 512 /* Space Conversion */
 513
 514 /**
 515  * Init settings for stroke point space conversions
 516  *
 517  * \param r_gsc: [out] The space conversion settings struct, populated with necessary params
 518  */
 519 void gp_point_conversion_init(bContext *C, GP_SpaceConversion *r_gsc)
 520 {
 521         ScrArea *sa = CTX_wm_area(C);
 522         ARegion *ar = CTX_wm_region(C);
 523
 524         /* zero out the storage (just in case) */
 525         memset(r_gsc, 0, sizeof(GP_SpaceConversion));
 526         unit_m4(r_gsc->mat);
 527
 528         /* store settings */
 529         r_gsc->sa = sa;
 530         r_gsc->ar = ar;
 531         r_gsc->v2d = &ar->v2d;
 532
 533         /* init region-specific stuff */
 534         if (sa->spacetype == SPACE_VIEW3D) {
 535                 wmWindow *win = CTX_wm_window(C);
 536                 Scene *scene = CTX_data_scene(C);
 537                 View3D *v3d = (View3D *)CTX_wm_space_data(C);
 538                 RegionView3D *rv3d = ar->regiondata;
 539
 540                 /* init 3d depth buffers */
 541                 view3d_operator_needs_opengl(C);
 542
 543                 view3d_region_operator_needs_opengl(win, ar);
 544                 ED_view3d_autodist_init(scene, ar, v3d, 0);
 545
 546                 /* for camera view set the subrect */
 547                 if (rv3d->persp == RV3D_CAMOB) {
 548                         ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &r_gsc->subrect_data, true); /* no shift */
 549                         r_gsc->subrect = &r_gsc->subrect_data;
 550                 }
 551         }
 552 }
 553
 554 /**
 555  * Convert point to parent space
 556  *
 557  * \param pt         Original point
 558  * \param diff_mat   Matrix with the difference between original parent matrix
 559  * \param[out] r_pt  Pointer to new point after apply matrix
 560  */
 561 void gp_point_to_parent_space(bGPDspoint *pt, float diff_mat[4][4], bGPDspoint *r_pt)
 562 {
 563         float fpt[3];
 564
 565         mul_v3_m4v3(fpt, diff_mat, &pt->x);
 566         copy_v3_v3(&r_pt->x, fpt);
 567 }
 568
 569 /**
 570  * Change points position relative to parent object
 571  */
 572 void gp_apply_parent(bGPDlayer *gpl, bGPDstroke *gps)
 573 {
 574         bGPDspoint *pt;
 575         int i;
 576
 577         /* undo matrix */
 578         float diff_mat[4][4];
 579         float inverse_diff_mat[4][4];
 580         float fpt[3];
 581
 582         ED_gpencil_parent_location(gpl, diff_mat);
 583         invert_m4_m4(inverse_diff_mat, diff_mat);
 584
 585         for (i = 0; i < gps->totpoints; i++) {
 586                 pt = &gps->points[i];
 587                 mul_v3_m4v3(fpt, inverse_diff_mat, &pt->x);
 588                 copy_v3_v3(&pt->x, fpt);
 589         }
 590 }
 591
 592 /**
 593  * Change point position relative to parent object
 594  */
 595 void gp_apply_parent_point(bGPDlayer *gpl, bGPDspoint *pt)
 596 {
 597         /* undo matrix */
 598         float diff_mat[4][4];
 599         float inverse_diff_mat[4][4];
 600         float fpt[3];
 601
 602         ED_gpencil_parent_location(gpl, diff_mat);
 603         invert_m4_m4(inverse_diff_mat, diff_mat);
 604
 605         mul_v3_m4v3(fpt, inverse_diff_mat, &pt->x);
 606         copy_v3_v3(&pt->x, fpt);
 607 }
 608
 609 /**
 610  * Convert a Grease Pencil coordinate (i.e. can be 2D or 3D) to screenspace (2D)
 611  *
 612  * \param[out] r_x  The screen-space x-coordinate of the point
 613  * \param[out] r_y  The screen-space y-coordinate of the point
 614  *
 615  * \warning This assumes that the caller has already checked whether the stroke in question can be drawn.
 616  */
 617 void gp_point_to_xy(GP_SpaceConversion *gsc, bGPDstroke *gps, bGPDspoint *pt,
 618                     int *r_x, int *r_y)
 619 {
 620         ARegion *ar = gsc->ar;
 621         View2D *v2d = gsc->v2d;
 622         rctf *subrect = gsc->subrect;
 623         int xyval[2];
 624
 625         /* sanity checks */
 626         BLI_assert(!(gps->flag & GP_STROKE_3DSPACE) || (gsc->sa->spacetype == SPACE_VIEW3D));
 627         BLI_assert(!(gps->flag & GP_STROKE_2DSPACE) || (gsc->sa->spacetype != SPACE_VIEW3D));
 628
 629
 630         if (gps->flag & GP_STROKE_3DSPACE) {
 631                 if (ED_view3d_project_int_global(ar, &pt->x, xyval, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
 632                         *r_x = xyval[0];
 633                         *r_y = xyval[1];
 634                 }
 635                 else {
 636                         *r_x = V2D_IS_CLIPPED;
 637                         *r_y = V2D_IS_CLIPPED;
 638                 }
 639         }
 640         else if (gps->flag & GP_STROKE_2DSPACE) {
 641                 float vec[3] = {pt->x, pt->y, 0.0f};
 642                 mul_m4_v3(gsc->mat, vec);
 643                 UI_view2d_view_to_region_clip(v2d, vec[0], vec[1], r_x, r_y);
 644         }
 645         else {
 646                 if (subrect == NULL) {
 647                         /* normal 3D view (or view space) */
 648                         *r_x = (int)(pt->x / 100 * ar->winx);
 649                         *r_y = (int)(pt->y / 100 * ar->winy);
 650                 }
 651                 else {
 652                         /* camera view, use subrect */
 653                         *r_x = (int)((pt->x / 100) * BLI_rctf_size_x(subrect)) + subrect->xmin;
 654                         *r_y = (int)((pt->y / 100) * BLI_rctf_size_y(subrect)) + subrect->ymin;
 655                 }
 656         }
 657 }
 658
 659 /**
 660  * Convert a Grease Pencil coordinate (i.e. can be 2D or 3D) to screenspace (2D)
 661  *
 662  * Just like gp_point_to_xy(), except the resulting coordinates are floats not ints.
 663  * Use this version to solve "stair-step" artifacts which may arise when roundtripping the calculations.
 664  *
 665  * \param r_x: [out] The screen-space x-coordinate of the point
 666  * \param r_y: [out] The screen-space y-coordinate of the point
 667  *
 668  * \warning This assumes that the caller has already checked whether the stroke in question can be drawn
 669  */
 670 void gp_point_to_xy_fl(GP_SpaceConversion *gsc, bGPDstroke *gps, bGPDspoint *pt,
 671                        float *r_x, float *r_y)
 672 {
 673         ARegion *ar = gsc->ar;
 674         View2D *v2d = gsc->v2d;
 675         rctf *subrect = gsc->subrect;
 676         float xyval[2];
 677
 678         /* sanity checks */
 679         BLI_assert(!(gps->flag & GP_STROKE_3DSPACE) || (gsc->sa->spacetype == SPACE_VIEW3D));
 680         BLI_assert(!(gps->flag & GP_STROKE_2DSPACE) || (gsc->sa->spacetype != SPACE_VIEW3D));
 681
 682
 683         if (gps->flag & GP_STROKE_3DSPACE) {
 684                 if (ED_view3d_project_float_global(ar, &pt->x, xyval, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
 685                         *r_x = xyval[0];
 686                         *r_y = xyval[1];
 687                 }
 688                 else {
 689                         *r_x = 0.0f;
 690                         *r_y = 0.0f;
 691                 }
 692         }
 693         else if (gps->flag & GP_STROKE_2DSPACE) {
 694                 float vec[3] = {pt->x, pt->y, 0.0f};
 695                 int t_x, t_y;
 696
 697                 mul_m4_v3(gsc->mat, vec);
 698                 UI_view2d_view_to_region_clip(v2d, vec[0], vec[1], &t_x, &t_y);
 699
 700                 if ((t_x == t_y) && (t_x == V2D_IS_CLIPPED)) {
 701                         /* XXX: Or should we just always use the values as-is? */
 702                         *r_x = 0.0f;
 703                         *r_y = 0.0f;
 704                 }
 705                 else {
 706                         *r_x = (float)t_x;
 707                         *r_y = (float)t_y;
 708                 }
 709         }
 710         else {
 711                 if (subrect == NULL) {
 712                         /* normal 3D view (or view space) */
 713                         *r_x = (pt->x / 100.0f * ar->winx);
 714                         *r_y = (pt->y / 100.0f * ar->winy);
 715                 }
 716                 else {
 717                         /* camera view, use subrect */
 718                         *r_x = ((pt->x / 100.0f) * BLI_rctf_size_x(subrect)) + subrect->xmin;
 719                         *r_y = ((pt->y / 100.0f) * BLI_rctf_size_y(subrect)) + subrect->ymin;
 720                 }
 721         }
 722 }
 723
 724 /**
 725  * Project screenspace coordinates to 3D-space
 726  *
 727  * For use with editing tools where it is easier to perform the operations in 2D,
 728  * and then later convert the transformed points back to 3D.
 729  *
 730  * \param screen_co: The screenspace 2D coordinates to convert to
 731  * \param r_out: The resulting 3D coordinates of the input point
 732  *
 733  * \note We include this as a utility function, since the standard method
 734  * involves quite a few steps, which are invariably always the same
 735  * for all GPencil operations. So, it's nicer to just centralize these.
 736  *
 737  * \warning Assumes that it is getting called in a 3D view only.
 738  */
 739 bool gp_point_xy_to_3d(GP_SpaceConversion *gsc, Scene *scene, const float screen_co[2], float r_out[3])
 740 {
 741         View3D *v3d = gsc->sa->spacedata.first;
 742         RegionView3D *rv3d = gsc->ar->regiondata;
 743         float *rvec = ED_view3d_cursor3d_get(scene, v3d);
 744         float ref[3] = {rvec[0], rvec[1], rvec[2]};
 745         float zfac = ED_view3d_calc_zfac(rv3d, rvec, NULL);
 746
 747         float mval_f[2], mval_prj[2];
 748         float dvec[3];
 749
 750         copy_v2_v2(mval_f, screen_co);
 751
 752         if (ED_view3d_project_float_global(gsc->ar, ref, mval_prj, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
 753                 sub_v2_v2v2(mval_f, mval_prj, mval_f);
 754                 ED_view3d_win_to_delta(gsc->ar, mval_f, dvec, zfac);
 755                 sub_v3_v3v3(r_out, rvec, dvec);
 756
 757                 return true;
 758         }
 759         else {
 760                 zero_v3(r_out);
 761
 762                 return false;
 763         }
 764 }
 765
 766 /**
 767  * Apply smooth to stroke point
 768  * \param gps              Stroke to smooth
 769  * \param i                Point index
 770  * \param inf              Amount of smoothing to apply
 771  * \param affect_pressure  Apply smoothing to pressure values too?
 772  */
 773 bool gp_smooth_stroke(bGPDstroke *gps, int i, float inf, bool affect_pressure)
 774 {
 775         bGPDspoint *pt = &gps->points[i];
 776         float pressure = 0.0f;
 777         float sco[3] = {0.0f};
 778
 779         /* Do nothing if not enough points to smooth out */
 780         if (gps->totpoints <= 2) {
 781                 return false;
 782         }
 783
 784         /* Only affect endpoints by a fraction of the normal strength,
 785          * to prevent the stroke from shrinking too much
 786          */
 787         if ((i == 0) || (i == gps->totpoints - 1)) {
 788                 inf *= 0.1f;
 789         }
 790
 791         /* Compute smoothed coordinate by taking the ones nearby */
 792         /* XXX: This is potentially slow, and suffers from accumulation error as earlier points are handled before later ones */
 793         {
 794                 // XXX: this is hardcoded to look at 2 points on either side of the current one (i.e. 5 items total)
 795                 const int   steps = 2;
 796                 const float average_fac = 1.0f / (float)(steps * 2 + 1);
 797                 int step;
 798
 799                 /* add the point itself */
 800                 madd_v3_v3fl(sco, &pt->x, average_fac);
 801
 802                 if (affect_pressure) {
 803                         pressure += pt->pressure * average_fac;
 804                 }
 805
 806                 /* n-steps before/after current point */
 807                 // XXX: review how the endpoints are treated by this algorithm
 808                 // XXX: falloff measures should also introduce some weighting variations, so that further-out points get less weight
 809                 for (step = 1; step <= steps; step++) {
 810                         bGPDspoint *pt1, *pt2;
 811                         int before = i - step;
 812                         int after = i + step;
 813
 814                         CLAMP_MIN(before, 0);
 815                         CLAMP_MAX(after, gps->totpoints - 1);
 816
 817                         pt1 = &gps->points[before];
 818                         pt2 = &gps->points[after];
 819
 820                         /* add both these points to the average-sum (s += p[i]/n) */
 821                         madd_v3_v3fl(sco, &pt1->x, average_fac);
 822                         madd_v3_v3fl(sco, &pt2->x, average_fac);
 823
 824 #if 0
 825                         /* XXX: Disabled because get weird result */
 826                         /* do pressure too? */
 827                         if (affect_pressure) {
 828                                 pressure += pt1->pressure * average_fac;
 829                                 pressure += pt2->pressure * average_fac;
 830                         }
 831 #endif
 832                 }
 833         }
 834
 835         /* Based on influence factor, blend between original and optimal smoothed coordinate */
 836         interp_v3_v3v3(&pt->x, &pt->x, sco, inf);
 837
 838 #if 0
 839         /* XXX: Disabled because get weird result */
 840         if (affect_pressure) {
 841                 pt->pressure = pressure;
 842         }
 843 #endif
 844
 845         return true;
 846 }
 847
 848 /**
 849 * Apply smooth for strength to stroke point
 850 * \param gps              Stroke to smooth
 851 * \param i                Point index
 852 * \param inf              Amount of smoothing to apply
 853 */
 854 bool gp_smooth_stroke_strength(bGPDstroke *gps, int i, float inf)
 855 {
 856         bGPDspoint *ptb = &gps->points[i];
 857
 858         /* Do nothing if not enough points */
 859         if (gps->totpoints <= 2) {
 860                 return false;
 861         }
 862
 863         /* Compute theoretical optimal value using distances */
 864         bGPDspoint *pta, *ptc;
 865         int before = i - 1;
 866         int after = i + 1;
 867
 868         CLAMP_MIN(before, 0);
 869         CLAMP_MAX(after, gps->totpoints - 1);
 870
 871         pta = &gps->points[before];
 872         ptc = &gps->points[after];
 873
 874         /* the optimal value is the corresponding to the interpolation of the strength
 875          *  at the distance of point b
 876          */
 877         const float fac = line_point_factor_v3(&ptb->x, &pta->x, &ptc->x);
 878         const float optimal = (1.0f - fac) * pta->strength + fac * ptc->strength;
 879
 880         /* Based on influence factor, blend between original and optimal */
 881         ptb->strength = (1.0f - inf) * ptb->strength + inf * optimal;
 882
 883         return true;
 884 }
 885
 886 /**
 887 * Apply smooth for thickness to stroke point (use pressure)
 888 * \param gps              Stroke to smooth
 889 * \param i                Point index
 890 * \param inf              Amount of smoothing to apply
 891 */
 892 bool gp_smooth_stroke_thickness(bGPDstroke *gps, int i, float inf)
 893 {
 894         bGPDspoint *ptb = &gps->points[i];
 895
 896         /* Do nothing if not enough points */
 897         if (gps->totpoints <= 2) {
 898                 return false;
 899         }
 900
 901         /* Compute theoretical optimal value using distances */
 902         bGPDspoint *pta, *ptc;
 903         int before = i - 1;
 904         int after = i + 1;
 905
 906         CLAMP_MIN(before, 0);
 907         CLAMP_MAX(after, gps->totpoints - 1);
 908
 909         pta = &gps->points[before];
 910         ptc = &gps->points[after];
 911
 912         /* the optimal value is the corresponding to the interpolation of the pressure
 913         *  at the distance of point b
 914         */
 915         float fac = line_point_factor_v3(&ptb->x, &pta->x, &ptc->x);
 916         float optimal = (1.0f - fac) * pta->pressure + fac * ptc->pressure;
 917
 918         /* Based on influence factor, blend between original and optimal */
 919         ptb->pressure = (1.0f - inf) * ptb->pressure + inf * optimal;
 920
 921         return true;
 922 }
 923
 924 /**
 925  * Subdivide a stroke once, by adding a point half way between each pair of existing points
 926  * \param gps           Stroke data
 927  * \param new_totpoints Total number of points (after subdividing)
 928  */
 929 void gp_subdivide_stroke(bGPDstroke *gps, const int new_totpoints)
 930 {
 931         /* Move points towards end of enlarged points array to leave space for new points */
 932         int y = 1;
 933         for (int i = gps->totpoints - 1; i > 0; i--) {
 934                 gps->points[new_totpoints - y] = gps->points[i];
 935                 y += 2;
 936         }
 937
 938         /* Create interpolated points */
 939         for (int i = 0; i < new_totpoints - 1; i += 2) {
 940                 bGPDspoint *prev  = &gps->points[i];
 941                 bGPDspoint *pt    = &gps->points[i + 1];
 942                 bGPDspoint *next  = &gps->points[i + 2];
 943
 944                 /* Interpolate all values */
 945                 interp_v3_v3v3(&pt->x, &prev->x, &next->x, 0.5f);
 946
 947                 pt->pressure = interpf(prev->pressure, next->pressure, 0.5f);
 948                 pt->strength = interpf(prev->strength, next->strength, 0.5f);
 949                 CLAMP(pt->strength, GPENCIL_STRENGTH_MIN, 1.0f);
 950                 pt->time = interpf(prev->time, next->time, 0.5f);
 951         }
 952
 953         /* Update to new total number of points */
 954         gps->totpoints = new_totpoints;
 955 }
 956
 957 /**
 958  * Add randomness to stroke
 959  * \param gps           Stroke data
 960  * \param brush         Brush data
 961  */
 962 void gp_randomize_stroke(bGPDstroke *gps, bGPDbrush *brush)
 963 {
 964         bGPDspoint *pt1, *pt2, *pt3;
 965         float v1[3];
 966         float v2[3];
 967         if (gps->totpoints < 3) {
 968                 return;
 969         }
 970
 971         /* get two vectors using 3 points */
 972         pt1 = &gps->points[0];
 973         pt2 = &gps->points[1];
 974         pt3 = &gps->points[(int)(gps->totpoints * 0.75)];
 975
 976         sub_v3_v3v3(v1, &pt2->x, &pt1->x);
 977         sub_v3_v3v3(v2, &pt3->x, &pt2->x);
 978         normalize_v3(v1);
 979         normalize_v3(v2);
 980
 981         /* get normal vector to plane created by two vectors */
 982         float normal[3];
 983         cross_v3_v3v3(normal, v1, v2);
 984         normalize_v3(normal);
 985
 986         /* get orthogonal vector to plane to rotate random effect */
 987         float ortho[3];
 988         cross_v3_v3v3(ortho, v1, normal);
 989         normalize_v3(ortho);
 990
 991         /* Read all points and apply shift vector (first and last point not modified) */
 992         for (int i = 1; i < gps->totpoints - 1; ++i) {
 993                 bGPDspoint *pt = &gps->points[i];
 994                 /* get vector with shift (apply a division because random is too sensitive */
 995                 const float fac = BLI_frand() * (brush->draw_random_sub / 10.0f);
 996                 float svec[3];
 997                 copy_v3_v3(svec, ortho);
 998                 if (BLI_frand() > 0.5f) {
 999                         mul_v3_fl(svec, -fac);
1000                 }
1001                 else {
1002                         mul_v3_fl(svec, fac);
1003                 }
1004
1005                 /* apply shift */
1006                 add_v3_v3(&pt->x, svec);
1007         }
1008
1009 }
1010 /* calculate difference matrix */
1011 void ED_gpencil_parent_location(bGPDlayer *gpl, float diff_mat[4][4])
1012 {
1013         Object *ob = gpl->parent;
1014
1015         if (ob == NULL) {
1016                 unit_m4(diff_mat);
1017                 return;
1018         }
1019         else {
1020                 if ((gpl->partype == PAROBJECT) || (gpl->partype == PARSKEL)) {
1021                         mul_m4_m4m4(diff_mat, ob->obmat, gpl->inverse);
1022                         return;
1023                 }
1024                 else if (gpl->partype == PARBONE) {
1025                         bPoseChannel *pchan = BKE_pose_channel_find_name(ob->pose, gpl->parsubstr);
1026                         if (pchan) {
1027                                 float tmp_mat[4][4];
1028                                 mul_m4_m4m4(tmp_mat, ob->obmat, pchan->pose_mat);
1029                                 mul_m4_m4m4(diff_mat, tmp_mat, gpl->inverse);
1030                         }
1031                         else {
1032                                 mul_m4_m4m4(diff_mat, ob->obmat, gpl->inverse); /* if bone not found use object (armature) */
1033                         }
1034                         return;
1035                 }
1036                 else {
1037                         unit_m4(diff_mat); /* not defined type */
1038                 }
1039         }
1040 }
1041
1042 /* reset parent matrix for all layers */
1043 void ED_gpencil_reset_layers_parent(bGPdata *gpd)
1044 {
1045         bGPDspoint *pt;
1046         int i;
1047         float diff_mat[4][4];
1048         float cur_mat[4][4];
1049
1050         for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
1051                 if (gpl->parent != NULL) {
1052                         /* calculate new matrix */
1053                         if ((gpl->partype == PAROBJECT) || (gpl->partype == PARSKEL)) {
1054                                 invert_m4_m4(cur_mat, gpl->parent->obmat);
1055                         }
1056                         else if (gpl->partype == PARBONE) {
1057                                 bPoseChannel *pchan = BKE_pose_channel_find_name(gpl->parent->pose, gpl->parsubstr);
1058                                 if (pchan) {
1059                                         float tmp_mat[4][4];
1060                                         mul_m4_m4m4(tmp_mat, gpl->parent->obmat, pchan->pose_mat);
1061                                         invert_m4_m4(cur_mat, tmp_mat);
1062                                 }
1063                         }
1064
1065                         /* only redo if any change */
1066                         if (!equals_m4m4(gpl->inverse, cur_mat)) {
1067                                 /* first apply current transformation to all strokes */
1068                                 ED_gpencil_parent_location(gpl, diff_mat);
1069                                 for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
1070                                         for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
1071                                                 for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
1072                                                         mul_m4_v3(diff_mat, &pt->x);
1073                                                 }
1074                                         }
1075                                 }
1076                                 /* set new parent matrix */
1077                                 copy_m4_m4(gpl->inverse, cur_mat);
1078                         }
1079                 }
1080         }
1081 }
1082 /* ******************************************************** */
1083 bool ED_gpencil_stroke_minmax(
1084         const bGPDstroke *gps, const bool use_select,
1085         float r_min[3], float r_max[3])
1086 {
1087         const bGPDspoint *pt;
1088         int i;
1089         bool changed = false;
1090
1091         for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
1092                 if ((use_select == false) || (pt->flag & GP_SPOINT_SELECT)) {;
1093                         minmax_v3v3_v3(r_min, r_max, &pt->x);
1094                         changed = true;
1095                 }
1096         }
1097         return changed;
1098 }
1099
1100 /* Dynamic Enums of GP Brushes */
1101 EnumPropertyItem *ED_gpencil_brushes_enum_itemf(
1102         bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop),
1103         bool *r_free)
1104 {
1105         ToolSettings *ts = CTX_data_tool_settings(C);
1106         bGPDbrush *brush;
1107         EnumPropertyItem *item = NULL, item_tmp = { 0 };
1108         int totitem = 0;
1109         int i = 0;
1110
1111         if (ELEM(NULL, C, ts)) {
1112                 return DummyRNA_DEFAULT_items;
1113         }
1114
1115         /* Existing brushes */
1116         for (brush = ts->gp_brushes.first; brush; brush = brush->next, i++) {
1117                 item_tmp.identifier = brush->info;
1118                 item_tmp.name = brush->info;
1119                 item_tmp.value = i;
1120
1121                 if (brush->flag & GP_BRUSH_ACTIVE)
1122                         item_tmp.icon = ICON_BRUSH_DATA;
1123                 else
1124                         item_tmp.icon = ICON_NONE;
1125
1126                 RNA_enum_item_add(&item, &totitem, &item_tmp);
1127         }
1128
1129         RNA_enum_item_end(&item, &totitem);
1130         *r_free = true;
1131
1132         return item;
1133 }
1134
1135 /* Dynamic Enums of GP Palettes */
1136 EnumPropertyItem *ED_gpencil_palettes_enum_itemf(
1137         bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop),
1138         bool *r_free)
1139 {
1140         bGPdata *gpd = CTX_data_gpencil_data(C);
1141         bGPDpalette *palette;
1142         EnumPropertyItem *item = NULL, item_tmp = { 0 };
1143         int totitem = 0;
1144         int i = 0;
1145
1146         if (ELEM(NULL, C, gpd)) {
1147                 return DummyRNA_DEFAULT_items;
1148         }
1149
1150         /* Existing palettes */
1151         for (palette = gpd->palettes.first; palette; palette = palette->next, i++) {
1152                 item_tmp.identifier = palette->info;
1153                 item_tmp.name = palette->info;
1154                 item_tmp.value = i;
1155
1156                 if (palette->flag & PL_PALETTE_ACTIVE)
1157                         item_tmp.icon = ICON_COLOR;
1158                 else
1159                         item_tmp.icon = ICON_NONE;
1160
1161                 RNA_enum_item_add(&item, &totitem, &item_tmp);
1162         }
1163
1164         RNA_enum_item_end(&item, &totitem);
1165         *r_free = true;
1166
1167         return item;
1168 }
1169 /* ******************************************************** */