diff options
Diffstat (limited to 'source/blender/editors/gpencil/annotate_paint.c')
| -rw-r--r-- | source/blender/editors/gpencil/annotate_paint.c | 480 |
1 files changed, 242 insertions, 238 deletions
diff --git a/source/blender/editors/gpencil/annotate_paint.c b/source/blender/editors/gpencil/annotate_paint.c index 5c5adb32a97..9d80a75b959 100644 --- a/source/blender/editors/gpencil/annotate_paint.c +++ b/source/blender/editors/gpencil/annotate_paint.c @@ -204,12 +204,12 @@ typedef struct tGPsdata { /* minimum length of new segment before new point can be added */ #define MIN_EUCLIDEAN_PX (U.gp_euclideandist) -static bool gp_stroke_added_check(tGPsdata *p) +static bool annotation_stroke_added_check(tGPsdata *p) { return (p->gpf && p->gpf->strokes.last && p->flags & GP_PAINTFLAG_STROKEADDED); } -static void gp_stroke_added_enable(tGPsdata *p) +static void annotation_stroke_added_enable(tGPsdata *p) { BLI_assert(p->gpf->strokes.last != NULL); p->flags |= GP_PAINTFLAG_STROKEADDED; @@ -218,13 +218,13 @@ static void gp_stroke_added_enable(tGPsdata *p) /* ------ */ /* Forward defines for some functions... */ -static void gp_session_validatebuffer(tGPsdata *p); +static void annotation_session_validatebuffer(tGPsdata *p); /* ******************************************* */ /* Context Wrangling... */ /* check if context is suitable for drawing */ -static bool gpencil_draw_poll(bContext *C) +static bool annotation_draw_poll(bContext *C) { if (ED_operator_regionactive(C)) { /* check if current context can support GPencil data */ @@ -249,7 +249,7 @@ static bool gpencil_draw_poll(bContext *C) } /* check if projecting strokes into 3d-geometry in the 3D-View */ -static bool gpencil_project_check(tGPsdata *p) +static bool annotation_project_check(tGPsdata *p) { bGPdata *gpd = p->gpd; return ((gpd->runtime.sbuffer_sflag & GP_STROKE_3DSPACE) && @@ -262,7 +262,7 @@ static bool gpencil_project_check(tGPsdata *p) /* Utilities --------------------------------- */ /* get the reference point for stroke-point conversions */ -static void gp_get_3d_reference(tGPsdata *p, float vec[3]) +static void annotation_get_3d_reference(tGPsdata *p, float vec[3]) { const float *fp = p->scene->cursor.location; @@ -273,7 +273,7 @@ static void gp_get_3d_reference(tGPsdata *p, float vec[3]) /* Stroke Editing ---------------------------- */ /* check if the current mouse position is suitable for adding a new point */ -static bool gp_stroke_filtermval(tGPsdata *p, const float mval[2], float pmval[2]) +static bool annotation_stroke_filtermval(tGPsdata *p, const float mval[2], float pmval[2]) { int dx = (int)fabsf(mval[0] - pmval[0]); int dy = (int)fabsf(mval[1] - pmval[1]); @@ -318,7 +318,10 @@ static bool gp_stroke_filtermval(tGPsdata *p, const float mval[2], float pmval[2 } /* convert screen-coordinates to buffer-coordinates */ -static void gp_stroke_convertcoords(tGPsdata *p, const float mval[2], float out[3], float *depth) +static void annotation_stroke_convertcoords(tGPsdata *p, + const float mval[2], + float out[3], + float *depth) { bGPdata *gpd = p->gpd; @@ -326,7 +329,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const float mval[2], float out[ if (gpd->runtime.sbuffer_sflag & GP_STROKE_3DSPACE) { int mval_i[2]; round_v2i_v2fl(mval_i, mval); - if (gpencil_project_check(p) && + if (annotation_project_check(p) && (ED_view3d_autodist_simple(p->region, mval_i, out, 0, depth))) { /* projecting onto 3D-Geometry * - nothing more needs to be done here, since view_autodist_simple() has already done it @@ -346,7 +349,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const float mval[2], float out[ * reference point instead or as offset, for easier stroke matching */ - gp_get_3d_reference(p, rvec); + annotation_get_3d_reference(p, rvec); zfac = ED_view3d_calc_zfac(p->region->regiondata, rvec, NULL); if (ED_view3d_project_float_global(p->region, rvec, mval_prj, V3D_PROJ_TEST_NOP) == @@ -381,16 +384,17 @@ static void gp_stroke_convertcoords(tGPsdata *p, const float mval[2], float out[ } } -/* Apply smooth to buffer while drawing +/** + * Apply smooth to buffer while drawing * to smooth point C, use 2 before (A, B) and current point (D): * - * A----B-----C------D + * `A----B-----C------D` * * \param p: Temp data * \param inf: Influence factor * \param idx: Index of the last point (need minimum 3 points in the array) */ -static void gp_smooth_buffer(tGPsdata *p, float inf, int idx) +static void annotation_smooth_buffer(tGPsdata *p, float inf, int idx) { bGPdata *gpd = p->gpd; short num_points = gpd->runtime.sbuffer_used; @@ -438,12 +442,12 @@ static void gp_smooth_buffer(tGPsdata *p, float inf, int idx) copy_v2_v2(&ptc->x, c); } -static void gp_stroke_arrow_calc_points_segment(float stroke_points[8], - const float ref_point[2], - const float dir_cw[2], - const float dir_ccw[2], - const float lenght, - const float sign) +static void annotation_stroke_arrow_calc_points_segment(float stroke_points[8], + const float ref_point[2], + const float dir_cw[2], + const float dir_ccw[2], + const float lenght, + const float sign) { stroke_points[0] = ref_point[0] + dir_cw[0] * lenght * sign; stroke_points[1] = ref_point[1] + dir_cw[1] * lenght * sign; @@ -451,11 +455,11 @@ static void gp_stroke_arrow_calc_points_segment(float stroke_points[8], stroke_points[3] = ref_point[1] + dir_ccw[1] * lenght * sign; } -static void gp_stroke_arrow_calc_points(tGPspoint *point, - const float stroke_dir[2], - float corner[2], - float stroke_points[8], - const int arrow_style) +static void annotation_stroke_arrow_calc_points(tGPspoint *point, + const float stroke_dir[2], + float corner[2], + float stroke_points[8], + const int arrow_style) { const int arrow_lenght = 8; float norm_dir[2]; @@ -473,12 +477,12 @@ static void gp_stroke_arrow_calc_points(tGPspoint *point, stroke_points[3] = corner[1] + inv_norm_dir_counterclockwise[1] * arrow_lenght + norm_dir[1]; break; case GP_STROKE_ARROWSTYLE_SEGMENT: - gp_stroke_arrow_calc_points_segment(stroke_points, - corner, - inv_norm_dir_clockwise, - inv_norm_dir_counterclockwise, - arrow_lenght, - 1.0f); + annotation_stroke_arrow_calc_points_segment(stroke_points, + corner, + inv_norm_dir_clockwise, + inv_norm_dir_counterclockwise, + arrow_lenght, + 1.0f); break; case GP_STROKE_ARROWSTYLE_CLOSED: mul_v2_fl(norm_dir, arrow_lenght); @@ -486,12 +490,12 @@ static void gp_stroke_arrow_calc_points(tGPspoint *point, add_v2_v2(&point->x, norm_dir); copy_v2_v2(corner, &point->x); } - gp_stroke_arrow_calc_points_segment(stroke_points, - corner, - inv_norm_dir_clockwise, - inv_norm_dir_counterclockwise, - arrow_lenght, - -1.0f); + annotation_stroke_arrow_calc_points_segment(stroke_points, + corner, + inv_norm_dir_clockwise, + inv_norm_dir_counterclockwise, + arrow_lenght, + -1.0f); stroke_points[4] = corner[0] - norm_dir[0]; stroke_points[5] = corner[1] - norm_dir[1]; break; @@ -501,12 +505,12 @@ static void gp_stroke_arrow_calc_points(tGPspoint *point, add_v2_v2(&point->x, norm_dir); copy_v2_v2(corner, &point->x); } - gp_stroke_arrow_calc_points_segment(stroke_points, - corner, - inv_norm_dir_clockwise, - inv_norm_dir_counterclockwise, - arrow_lenght * 0.75f, - -1.0f); + annotation_stroke_arrow_calc_points_segment(stroke_points, + corner, + inv_norm_dir_clockwise, + inv_norm_dir_counterclockwise, + arrow_lenght * 0.75f, + -1.0f); stroke_points[4] = stroke_points[0] - norm_dir[0]; stroke_points[5] = stroke_points[1] - norm_dir[1]; stroke_points[6] = stroke_points[2] - norm_dir[0]; @@ -518,7 +522,10 @@ static void gp_stroke_arrow_calc_points(tGPspoint *point, } /* add current stroke-point to buffer (returns whether point was successfully added) */ -static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure, double curtime) +static short annotation_stroke_addpoint(tGPsdata *p, + const float mval[2], + float pressure, + double curtime) { bGPdata *gpd = p->gpd; tGPspoint *pt; @@ -571,14 +578,14 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure pt++; float e_heading[2] = {start[0] - end[0], start[1] - end[1]}; /* Calculate points for ending arrow. */ - gp_stroke_arrow_calc_points( + annotation_stroke_arrow_calc_points( pt, e_heading, end, gpd->runtime.arrow_end, gpd->runtime.arrow_end_style); } /* Arrow start corner. */ if (gpd->runtime.sbuffer_sflag & GP_STROKE_USE_ARROW_START) { float s_heading[2] = {end[0] - start[0], end[1] - start[1]}; /* Calculate points for starting arrow. */ - gp_stroke_arrow_calc_points( + annotation_stroke_arrow_calc_points( NULL, s_heading, start, gpd->runtime.arrow_start, gpd->runtime.arrow_start_style); } } @@ -611,7 +618,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure if ((p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) == 0) { /* smooth while drawing previous points with a reduction factor for previous */ for (int s = 0; s < 3; s++) { - gp_smooth_buffer(p, 0.5f * ((3.0f - s) / 3.0f), gpd->runtime.sbuffer_used - s); + annotation_smooth_buffer(p, 0.5f * ((3.0f - s) / 3.0f), gpd->runtime.sbuffer_used - s); } } @@ -632,7 +639,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure * to stroke. This allows to draw lines more interactively (see new segment * during mouse slide, e.g.) */ - if (gp_stroke_added_check(p)) { + if (annotation_stroke_added_check(p)) { bGPDstroke *gps = p->gpf->strokes.last; bGPDspoint *pts; @@ -649,7 +656,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure * but poly lines are converting to stroke instantly, * so initialize depth buffer before converting coordinates */ - if (gpencil_project_check(p)) { + if (annotation_project_check(p)) { View3D *v3d = p->area->spacedata.first; view3d_region_operator_needs_opengl(p->win, p->region); @@ -660,7 +667,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure } /* convert screen-coordinates to appropriate coordinates (and store them) */ - gp_stroke_convertcoords(p, &pt->x, &pts->x, NULL); + annotation_stroke_convertcoords(p, &pt->x, &pts->x, NULL); /* copy pressure and time */ pts->pressure = pt->pressure; @@ -681,115 +688,115 @@ static short gp_stroke_addpoint(tGPsdata *p, const float mval[2], float pressure return GP_STROKEADD_INVALID; } -static void gp_stroke_arrow_init_point_default(bGPDspoint *pt) +static void annotation_stroke_arrow_init_point_default(bGPDspoint *pt) { pt->pressure = 1.0f; pt->strength = 1.0f; pt->time = 1.0f; } -static void gp_stroke_arrow_init_conv_point(bGPDspoint *pt, const float point[3]) +static void annotation_stroke_arrow_init_conv_point(bGPDspoint *pt, const float point[3]) { copy_v3_v3(&pt->x, point); - gp_stroke_arrow_init_point_default(pt); + annotation_stroke_arrow_init_point_default(pt); } -static void gp_stroke_arrow_init_point( +static void annotation_stroke_arrow_init_point( tGPsdata *p, tGPspoint *ptc, bGPDspoint *pt, const float co[8], const int co_idx) { /* Note: provided co_idx should be always pair number as it's [x1, y1, x2, y2, x3, y3]. */ float real_co[2] = {co[co_idx], co[co_idx + 1]}; copy_v2_v2(&ptc->x, real_co); - gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); - gp_stroke_arrow_init_point_default(pt); + annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); + annotation_stroke_arrow_init_point_default(pt); } -static void gp_stroke_arrow_allocate(bGPDstroke *gps, const int totpoints) +static void annotation_stroke_arrow_allocate(bGPDstroke *gps, const int totpoints) { /* Copy appropriate settings for stroke. */ gps->totpoints = totpoints; /* Allocate enough memory for a continuous array for storage points. */ - gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points"); + gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "annotation_stroke_points"); } -static void gp_arrow_create_open(tGPsdata *p, - tGPspoint *ptc, - bGPDspoint *pt, - const float corner_point[3], - const float arrow_points[8]) +static void annotation_arrow_create_open(tGPsdata *p, + tGPspoint *ptc, + bGPDspoint *pt, + const float corner_point[3], + const float arrow_points[8]) { - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0); pt++; - gp_stroke_arrow_init_conv_point(pt, corner_point); + annotation_stroke_arrow_init_conv_point(pt, corner_point); pt++; - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2); } -static void gp_arrow_create_segm(tGPsdata *p, - tGPspoint *ptc, - bGPDspoint *pt, - const float arrow_points[8]) +static void annotation_arrow_create_segm(tGPsdata *p, + tGPspoint *ptc, + bGPDspoint *pt, + const float arrow_points[8]) { - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0); pt++; - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2); } -static void gp_arrow_create_closed(tGPsdata *p, - tGPspoint *ptc, - bGPDspoint *pt, - const float arrow_points[8]) +static void annotation_arrow_create_closed(tGPsdata *p, + tGPspoint *ptc, + bGPDspoint *pt, + const float arrow_points[8]) { - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0); pt++; - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2); pt++; - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 4); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 4); pt++; - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0); } -static void gp_arrow_create_square(tGPsdata *p, - tGPspoint *ptc, - bGPDspoint *pt, - const float corner_point[3], - const float arrow_points[8]) +static void annotation_arrow_create_square(tGPsdata *p, + tGPspoint *ptc, + bGPDspoint *pt, + const float corner_point[3], + const float arrow_points[8]) { - gp_stroke_arrow_init_conv_point(pt, corner_point); + annotation_stroke_arrow_init_conv_point(pt, corner_point); pt++; - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 0); pt++; - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 4); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 4); pt++; - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 6); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 6); pt++; - gp_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2); + annotation_stroke_arrow_init_point(p, ptc, pt, arrow_points, 2); pt++; - gp_stroke_arrow_init_conv_point(pt, corner_point); + annotation_stroke_arrow_init_conv_point(pt, corner_point); } -static void gp_arrow_create(tGPsdata *p, - tGPspoint *ptc, - bGPDspoint *pt, - bGPDstroke *arrow_stroke, - const float arrow_points[8], - const int style) +static void annotation_arrow_create(tGPsdata *p, + tGPspoint *ptc, + bGPDspoint *pt, + bGPDstroke *arrow_stroke, + const float arrow_points[8], + const int style) { float corner_conv[3]; copy_v3_v3(corner_conv, &pt->x); switch (style) { case GP_STROKE_ARROWSTYLE_SEGMENT: - gp_arrow_create_segm(p, ptc, pt, arrow_points); + annotation_arrow_create_segm(p, ptc, pt, arrow_points); break; case GP_STROKE_ARROWSTYLE_CLOSED: - gp_arrow_create_closed(p, ptc, pt, arrow_points); + annotation_arrow_create_closed(p, ptc, pt, arrow_points); break; case GP_STROKE_ARROWSTYLE_OPEN: - gp_arrow_create_open(p, ptc, pt, corner_conv, arrow_points); + annotation_arrow_create_open(p, ptc, pt, corner_conv, arrow_points); break; case GP_STROKE_ARROWSTYLE_SQUARE: - gp_arrow_create_square(p, ptc, pt, corner_conv, arrow_points); + annotation_arrow_create_square(p, ptc, pt, corner_conv, arrow_points); break; default: break; @@ -799,7 +806,7 @@ static void gp_arrow_create(tGPsdata *p, } /* make a new stroke from the buffer data */ -static void gp_stroke_newfrombuffer(tGPsdata *p) +static void annotation_stroke_newfrombuffer(tGPsdata *p) { bGPdata *gpd = p->gpd; bGPDlayer *gpl = p->gpl; @@ -837,13 +844,13 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) * interactive behavior */ if (p->paintmode == GP_PAINTMODE_DRAW_POLY) { - if (gp_stroke_added_check(p)) { + if (annotation_stroke_added_check(p)) { return; } } /* allocate memory for a new stroke */ - gps = MEM_callocN(sizeof(bGPDstroke), "gp_stroke"); + gps = MEM_callocN(sizeof(bGPDstroke), "annotation_stroke"); /* copy appropriate settings for stroke */ gps->totpoints = totelem; @@ -857,7 +864,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) gps->tot_triangles = 0; /* allocate enough memory for a continuous array for storage points */ - gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points"); + gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "annotation_stroke_points"); gps->tot_triangles = 0; /* set pointer to first non-initialized point */ @@ -871,7 +878,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) ptc = gpd->runtime.sbuffer; /* convert screen-coordinates to appropriate coordinates (and store them) */ - gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); + annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); /* copy pressure and time */ pt->pressure = ptc->pressure; @@ -889,7 +896,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) ptc = ((tGPspoint *)runtime.sbuffer) + (runtime.sbuffer_used - 1); /* Convert screen-coordinates to appropriate coordinates (and store them). */ - gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); + annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); /* Copy pressure and time. */ pt->pressure = ptc->pressure; @@ -905,18 +912,19 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) /* Setting up arrow stroke. */ bGPDstroke *e_arrow_gps = BKE_gpencil_stroke_duplicate(gps, false); - gp_stroke_arrow_allocate(e_arrow_gps, totarrowpoints); + annotation_stroke_arrow_allocate(e_arrow_gps, totarrowpoints); /* Set pointer to first non-initialized point. */ pt = e_arrow_gps->points + (e_arrow_gps->totpoints - totarrowpoints); /* End point. */ ptc = ((tGPspoint *)runtime.sbuffer) + (runtime.sbuffer_used - 1); - gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); - gp_stroke_arrow_init_point_default(pt); + annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); + annotation_stroke_arrow_init_point_default(pt); /* Fill and convert arrow points to create arrow shape. */ - gp_arrow_create(p, ptc, pt, e_arrow_gps, runtime.arrow_end, runtime.arrow_end_style); + annotation_arrow_create( + p, ptc, pt, e_arrow_gps, runtime.arrow_end, runtime.arrow_end_style); } /* Start arrow stroke. */ if ((runtime.sbuffer_sflag & GP_STROKE_USE_ARROW_START) && @@ -925,18 +933,19 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) /* Setting up arrow stroke. */ bGPDstroke *s_arrow_gps = BKE_gpencil_stroke_duplicate(gps, false); - gp_stroke_arrow_allocate(s_arrow_gps, totarrowpoints); + annotation_stroke_arrow_allocate(s_arrow_gps, totarrowpoints); /* Set pointer to first non-initialized point. */ pt = s_arrow_gps->points + (s_arrow_gps->totpoints - totarrowpoints); /* Start point. */ ptc = runtime.sbuffer; - gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); - gp_stroke_arrow_init_point_default(pt); + annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); + annotation_stroke_arrow_init_point_default(pt); /* Fill and convert arrow points to create arrow shape. */ - gp_arrow_create(p, ptc, pt, s_arrow_gps, runtime.arrow_start, runtime.arrow_start_style); + annotation_arrow_create( + p, ptc, pt, s_arrow_gps, runtime.arrow_start, runtime.arrow_start_style); } } } @@ -945,7 +954,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) ptc = gpd->runtime.sbuffer; /* convert screen-coordinates to appropriate coordinates (and store them) */ - gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); + annotation_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); /* copy pressure and time */ pt->pressure = ptc->pressure; @@ -956,7 +965,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) float *depth_arr = NULL; /* get an array of depths, far depths are blended */ - if (gpencil_project_check(p)) { + if (annotation_project_check(p)) { int mval_i[2], mval_prev[2] = {0}; int interp_depth = 0; int found_depth = 0; @@ -1024,7 +1033,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) for (i = 0, ptc = gpd->runtime.sbuffer; i < gpd->runtime.sbuffer_used && ptc; i++, ptc++, pt++) { /* convert screen-coordinates to appropriate coordinates (and store them) */ - gp_stroke_convertcoords(p, &ptc->x, &pt->x, depth_arr ? depth_arr + i : NULL); + annotation_stroke_convertcoords(p, &ptc->x, &pt->x, depth_arr ? depth_arr + i : NULL); /* copy pressure and time */ pt->pressure = ptc->pressure; @@ -1040,7 +1049,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) /* add stroke to frame */ BLI_addtail(&p->gpf->strokes, gps); - gp_stroke_added_enable(p); + annotation_stroke_added_enable(p); } /* --- 'Eraser' for 'Paint' Tool ------ */ @@ -1048,7 +1057,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) /* helper to free a stroke * NOTE: gps->dvert and gps->triangles should be NULL, but check anyway for good measure */ -static void gp_free_stroke(bGPDframe *gpf, bGPDstroke *gps) +static void annotation_free_stroke(bGPDframe *gpf, bGPDstroke *gps) { if (gps->points) { MEM_freeN(gps->points); @@ -1066,7 +1075,9 @@ static void gp_free_stroke(bGPDframe *gpf, bGPDstroke *gps) BLI_freelinkN(&gpf->strokes, gps); } -/* which which point is infront (result should only be used for comparison) */ +/** + * Which which point is in front (result should only be used for comparison). + */ static float view3d_point_depth(const RegionView3D *rv3d, const float co[3]) { if (rv3d->is_persp) { @@ -1078,10 +1089,10 @@ static float view3d_point_depth(const RegionView3D *rv3d, const float co[3]) } /* only erase stroke points that are visible (3d view) */ -static bool gp_stroke_eraser_is_occluded(tGPsdata *p, - const bGPDspoint *pt, - const int x, - const int y) +static bool annotation_stroke_eraser_is_occluded(tGPsdata *p, + const bGPDspoint *pt, + const int x, + const int y) { if ((p->area->spacetype == SPACE_VIEW3D) && (p->flags & GP_PAINTFLAG_V3D_ERASER_DEPTH)) { RegionView3D *rv3d = p->region->regiondata; @@ -1100,14 +1111,13 @@ static bool gp_stroke_eraser_is_occluded(tGPsdata *p, return false; } -/* eraser tool - evaluation per stroke */ -/* TODO: this could really do with some optimization (KD-Tree/BVH?) */ -static void gp_stroke_eraser_dostroke(tGPsdata *p, - bGPDframe *gpf, - bGPDstroke *gps, - const float mval[2], - const int radius, - const rcti *rect) +/* Eraser tool - evaluation per stroke. */ +static void annotation_stroke_eraser_dostroke(tGPsdata *p, + bGPDframe *gpf, + bGPDstroke *gps, + const float mval[2], + const int radius, + const rcti *rect) { bGPDspoint *pt1, *pt2; int pc1[2] = {0}; @@ -1118,19 +1128,19 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p, if (gps->totpoints == 0) { /* just free stroke */ - gp_free_stroke(gpf, gps); + annotation_free_stroke(gpf, gps); } else if (gps->totpoints == 1) { /* only process if it hasn't been masked out... */ if (!(p->flags & GP_PAINTFLAG_SELECTMASK) || (gps->points->flag & GP_SPOINT_SELECT)) { - gp_point_to_xy(&p->gsc, gps, gps->points, &pc1[0], &pc1[1]); + gpencil_point_to_xy(&p->gsc, gps, gps->points, &pc1[0], &pc1[1]); /* do boundbox check first */ if ((!ELEM(V2D_IS_CLIPPED, pc1[0], pc1[1])) && BLI_rcti_isect_pt(rect, pc1[0], pc1[1])) { /* only check if point is inside */ if (len_v2v2_int(mval_i, pc1) <= radius) { /* free stroke */ - gp_free_stroke(gpf, gps); + annotation_free_stroke(gpf, gps); } } } @@ -1164,8 +1174,8 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p, continue; } - gp_point_to_xy(&p->gsc, gps, pt1, &pc1[0], &pc1[1]); - gp_point_to_xy(&p->gsc, gps, pt2, &pc2[0], &pc2[1]); + gpencil_point_to_xy(&p->gsc, gps, pt1, &pc1[0], &pc1[1]); + gpencil_point_to_xy(&p->gsc, gps, pt2, &pc2[0], &pc2[1]); /* Check that point segment of the boundbox of the eraser stroke */ if (((!ELEM(V2D_IS_CLIPPED, pc1[0], pc1[1])) && BLI_rcti_isect_pt(rect, pc1[0], pc1[1])) || @@ -1174,9 +1184,9 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p, * eraser region (either within stroke painted, or on its lines) * - this assumes that linewidth is irrelevant */ - if (gp_stroke_inside_circle(mval, radius, pc1[0], pc1[1], pc2[0], pc2[1])) { - if ((gp_stroke_eraser_is_occluded(p, pt1, pc1[0], pc1[1]) == false) || - (gp_stroke_eraser_is_occluded(p, pt2, pc2[0], pc2[1]) == false)) { + if (gpencil_stroke_inside_circle(mval, radius, pc1[0], pc1[1], pc2[0], pc2[1])) { + if ((annotation_stroke_eraser_is_occluded(p, pt1, pc1[0], pc1[1]) == false) || + (annotation_stroke_eraser_is_occluded(p, pt2, pc2[0], pc2[1]) == false)) { /* Edge is affected - Check individual points now */ if (len_v2v2_int(mval_i, pc1) <= radius) { pt1->flag |= GP_SPOINT_TAG; @@ -1192,13 +1202,13 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p, /* Second Pass: Remove any points that are tagged */ if (do_cull) { - gp_stroke_delete_tagged_points(gpf, gps, gps->next, GP_SPOINT_TAG, false, 0); + gpencil_stroke_delete_tagged_points(gpf, gps, gps->next, GP_SPOINT_TAG, false, 0); } } } /* erase strokes which fall under the eraser strokes */ -static void gp_stroke_doeraser(tGPsdata *p) +static void annotation_stroke_doeraser(tGPsdata *p) { bGPDframe *gpf = p->gpf; bGPDstroke *gps, *gpn; @@ -1227,7 +1237,7 @@ static void gp_stroke_doeraser(tGPsdata *p) * (e.g. 2D space strokes in the 3D view, if the same datablock is shared) */ if (ED_gpencil_stroke_can_use_direct(p->area, gps)) { - gp_stroke_eraser_dostroke(p, gpf, gps, p->mval, p->radius, &rect); + annotation_stroke_eraser_dostroke(p, gpf, gps, p->mval, p->radius, &rect); } } } @@ -1236,7 +1246,7 @@ static void gp_stroke_doeraser(tGPsdata *p) /* Sketching Operator */ /* clear the session buffers (call this before AND after a paint operation) */ -static void gp_session_validatebuffer(tGPsdata *p) +static void annotation_session_validatebuffer(tGPsdata *p) { bGPdata *gpd = p->gpd; @@ -1251,7 +1261,7 @@ static void gp_session_validatebuffer(tGPsdata *p) } /* (re)init new painting data */ -static bool gp_session_initdata(bContext *C, tGPsdata *p) +static bool annotation_session_initdata(bContext *C, tGPsdata *p) { Main *bmain = CTX_data_main(C); bGPdata **gpd_ptr = NULL; @@ -1422,13 +1432,13 @@ static bool gp_session_initdata(bContext *C, tGPsdata *p) } /* clear out buffer (stored in gp-data), in case something contaminated it */ - gp_session_validatebuffer(p); + annotation_session_validatebuffer(p); return 1; } /* init new painting session */ -static tGPsdata *gp_session_initpaint(bContext *C) +static tGPsdata *annotation_session_initpaint(bContext *C) { tGPsdata *p = NULL; @@ -1438,7 +1448,7 @@ static tGPsdata *gp_session_initpaint(bContext *C) /* Try to initialize context data * WARNING: This may not always succeed (e.g. using GP in an annotation-only context) */ - if (gp_session_initdata(C, p) == 0) { + if (annotation_session_initdata(C, p) == 0) { /* Invalid state - Exit * NOTE: It should be safe to just free the data, since failing context checks should * only happen when no data has been allocated. @@ -1458,7 +1468,7 @@ static tGPsdata *gp_session_initpaint(bContext *C) } /* cleanup after a painting session */ -static void gp_session_cleanup(tGPsdata *p) +static void annotation_session_cleanup(tGPsdata *p) { bGPdata *gpd = (p) ? p->gpd : NULL; @@ -1481,13 +1491,15 @@ static void gp_session_cleanup(tGPsdata *p) p->inittime = 0.0; } -static void gp_session_free(tGPsdata *p) +static void annotation_session_free(tGPsdata *p) { MEM_freeN(p); } /* init new stroke */ -static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode, Depsgraph *depsgraph) +static void annotation_paint_initstroke(tGPsdata *p, + eGPencil_PaintModes paintmode, + Depsgraph *depsgraph) { Scene *scene = p->scene; ToolSettings *ts = scene->toolsettings; @@ -1638,13 +1650,13 @@ static void gp_paint_initstroke(tGPsdata *p, eGPencil_PaintModes paintmode, Deps } /* finish off a stroke (clears buffer, but doesn't finish the paint operation) */ -static void gp_paint_strokeend(tGPsdata *p) +static void annotation_paint_strokeend(tGPsdata *p) { ToolSettings *ts = p->scene->toolsettings; /* for surface sketching, need to set the right OpenGL context stuff so that * the conversions will project the values correctly... */ - if (gpencil_project_check(p)) { + if (annotation_project_check(p)) { View3D *v3d = p->area->spacedata.first; /* need to restore the original projection settings before packing up */ @@ -1656,22 +1668,22 @@ static void gp_paint_strokeend(tGPsdata *p) /* check if doing eraser or not */ if ((p->gpd->runtime.sbuffer_sflag & GP_STROKE_ERASER) == 0) { /* transfer stroke to frame */ - gp_stroke_newfrombuffer(p); + annotation_stroke_newfrombuffer(p); } /* clean up buffer now */ - gp_session_validatebuffer(p); + annotation_session_validatebuffer(p); } /* finish off stroke painting operation */ -static void gp_paint_cleanup(tGPsdata *p) +static void annotation_paint_cleanup(tGPsdata *p) { /* p->gpd==NULL happens when stroke failed to initialize, * for example when GP is hidden in current space (sergey) */ if (p->gpd) { /* finish off a stroke */ - gp_paint_strokeend(p); + annotation_paint_strokeend(p); } /* "unlock" frame */ @@ -1683,7 +1695,7 @@ static void gp_paint_cleanup(tGPsdata *p) /* ------------------------------- */ /* Helper callback for drawing the cursor itself */ -static void gpencil_draw_eraser(bContext *UNUSED(C), int x, int y, void *p_ptr) +static void annotation_draw_eraser(bContext *UNUSED(C), int x, int y, void *p_ptr) { tGPsdata *p = (tGPsdata *)p_ptr; @@ -1729,7 +1741,7 @@ static void gpencil_draw_eraser(bContext *UNUSED(C), int x, int y, void *p_ptr) } /* Turn brush cursor in 3D view on/off */ -static void gpencil_draw_toggle_eraser_cursor(tGPsdata *p, short enable) +static void annotation_draw_toggle_eraser_cursor(tGPsdata *p, short enable) { if (p->erasercursor && !enable) { /* clear cursor */ @@ -1741,11 +1753,11 @@ static void gpencil_draw_toggle_eraser_cursor(tGPsdata *p, short enable) p->erasercursor = WM_paint_cursor_activate(SPACE_TYPE_ANY, RGN_TYPE_ANY, NULL, /* XXX */ - gpencil_draw_eraser, + annotation_draw_eraser, p); } } -static void gpencil_draw_stabilizer(bContext *C, int x, int y, void *p_ptr) +static void annotation_draw_stabilizer(bContext *C, int x, int y, void *p_ptr) { ARegion *region = CTX_wm_region(C); tGPsdata *p = (tGPsdata *)p_ptr; @@ -1793,7 +1805,7 @@ static void gpencil_draw_stabilizer(bContext *C, int x, int y, void *p_ptr) } /* Turn *stabilizer* brush cursor in 3D view on/off */ -static void gpencil_draw_toggle_stabilizer_cursor(tGPsdata *p, short enable) +static void annotation_draw_toggle_stabilizer_cursor(tGPsdata *p, short enable) { if (p->stabilizer_cursor && !enable) { /* clear cursor */ @@ -1803,19 +1815,19 @@ static void gpencil_draw_toggle_stabilizer_cursor(tGPsdata *p, short enable) else if (enable && !p->stabilizer_cursor) { /* enable cursor */ p->stabilizer_cursor = WM_paint_cursor_activate( - SPACE_TYPE_ANY, RGN_TYPE_ANY, NULL, gpencil_draw_stabilizer, p); + SPACE_TYPE_ANY, RGN_TYPE_ANY, NULL, annotation_draw_stabilizer, p); } } /* Check if tablet eraser is being used (when processing events) */ -static bool gpencil_is_tablet_eraser_active(const wmEvent *event) +static bool annotation_is_tablet_eraser_active(const wmEvent *event) { return (event->tablet.active == EVT_TABLET_ERASER); } /* ------------------------------- */ -static void gpencil_draw_exit(bContext *C, wmOperator *op) +static void annotation_draw_exit(bContext *C, wmOperator *op) { tGPsdata *p = op->customdata; @@ -1827,10 +1839,10 @@ static void gpencil_draw_exit(bContext *C, wmOperator *op) /* check size of buffer before cleanup, to determine if anything happened here */ if (p->paintmode == GP_PAINTMODE_ERASER) { /* turn off radial brush cursor */ - gpencil_draw_toggle_eraser_cursor(p, false); + annotation_draw_toggle_eraser_cursor(p, false); } else if (p->paintmode == GP_PAINTMODE_DRAW) { - gpencil_draw_toggle_stabilizer_cursor(p, false); + annotation_draw_toggle_stabilizer_cursor(p, false); } /* always store the new eraser size to be used again next time @@ -1843,40 +1855,40 @@ static void gpencil_draw_exit(bContext *C, wmOperator *op) gpencil_undo_finish(); /* cleanup */ - gp_paint_cleanup(p); - gp_session_cleanup(p); - gp_session_free(p); + annotation_paint_cleanup(p); + annotation_session_cleanup(p); + annotation_session_free(p); p = NULL; } op->customdata = NULL; } -static void gpencil_draw_cancel(bContext *C, wmOperator *op) +static void annotation_draw_cancel(bContext *C, wmOperator *op) { /* this is just a wrapper around exit() */ - gpencil_draw_exit(C, op); + annotation_draw_exit(C, op); } /* ------------------------------- */ -static int gpencil_draw_init(bContext *C, wmOperator *op, const wmEvent *event) +static int annotation_draw_init(bContext *C, wmOperator *op, const wmEvent *event) { tGPsdata *p; eGPencil_PaintModes paintmode = RNA_enum_get(op->ptr, "mode"); /* check context */ - p = op->customdata = gp_session_initpaint(C); + p = op->customdata = annotation_session_initpaint(C); if ((p == NULL) || (p->status == GP_STATUS_ERROR)) { /* something wasn't set correctly in context */ - gpencil_draw_exit(C, op); + annotation_draw_exit(C, op); return 0; } /* init painting data */ - gp_paint_initstroke(p, paintmode, CTX_data_ensure_evaluated_depsgraph(C)); + annotation_paint_initstroke(p, paintmode, CTX_data_ensure_evaluated_depsgraph(C)); if (p->status == GP_STATUS_ERROR) { - gpencil_draw_exit(C, op); + annotation_draw_exit(C, op); return 0; } @@ -1894,7 +1906,7 @@ static int gpencil_draw_init(bContext *C, wmOperator *op, const wmEvent *event) /* ------------------------------- */ /* ensure that the correct cursor icon is set */ -static void gpencil_draw_cursor_set(tGPsdata *p) +static void annotation_draw_cursor_set(tGPsdata *p) { if (p->paintmode == GP_PAINTMODE_ERASER) { WM_cursor_modal_set(p->win, WM_CURSOR_ERASER); @@ -1905,7 +1917,7 @@ static void gpencil_draw_cursor_set(tGPsdata *p) } /* update UI indicators of status, including cursor and header prints */ -static void gpencil_draw_status_indicators(bContext *C, tGPsdata *p) +static void annotation_draw_status_indicators(bContext *C, tGPsdata *p) { /* header prints */ switch (p->status) { @@ -1970,12 +1982,12 @@ static void gpencil_draw_status_indicators(bContext *C, tGPsdata *p) /* ------------------------------- */ /* create a new stroke point at the point indicated by the painting context */ -static void gpencil_draw_apply(wmOperator *op, tGPsdata *p, Depsgraph *depsgraph) +static void annotation_draw_apply(wmOperator *op, tGPsdata *p, Depsgraph *depsgraph) { /* handle drawing/erasing -> test for erasing first */ if (p->paintmode == GP_PAINTMODE_ERASER) { /* do 'live' erasing now */ - gp_stroke_doeraser(p); + annotation_stroke_doeraser(p); /* store used values */ p->mvalo[0] = p->mval[0]; @@ -1984,7 +1996,7 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p, Depsgraph *depsgraph } /* Only add current point to buffer if mouse moved * (even though we got an event, it might be just noise). */ - else if (gp_stroke_filtermval(p, p->mval, p->mvalo)) { + else if (annotation_stroke_filtermval(p, p->mval, p->mvalo)) { /* If lazy mouse, interpolate the last and current mouse positions. */ if (p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) { float now_mouse[2]; @@ -1996,26 +2008,24 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p, Depsgraph *depsgraph } /* try to add point */ - short ok = gp_stroke_addpoint(p, p->mval, p->pressure, p->curtime); + short ok = annotation_stroke_addpoint(p, p->mval, p->pressure, p->curtime); /* handle errors while adding point */ if ((ok == GP_STROKEADD_FULL) || (ok == GP_STROKEADD_OVERFLOW)) { /* finish off old stroke */ - gp_paint_strokeend(p); + annotation_paint_strokeend(p); /* And start a new one!!! Else, projection errors! */ - gp_paint_initstroke(p, p->paintmode, depsgraph); + annotation_paint_initstroke(p, p->paintmode, depsgraph); /* start a new stroke, starting from previous point */ - /* XXX Must manually reset inittime... */ - /* XXX We only need to reuse previous point if overflow! */ if (ok == GP_STROKEADD_OVERFLOW) { p->inittime = p->ocurtime; - gp_stroke_addpoint(p, p->mvalo, p->opressure, p->ocurtime); + annotation_stroke_addpoint(p, p->mvalo, p->opressure, p->ocurtime); } else { p->inittime = p->curtime; } - gp_stroke_addpoint(p, p->mval, p->pressure, p->curtime); + annotation_stroke_addpoint(p, p->mval, p->pressure, p->curtime); } else if (ok == GP_STROKEADD_INVALID) { /* the painting operation cannot continue... */ @@ -2053,16 +2063,16 @@ static void annotation_draw_apply_event( /* Key to toggle stabilization. */ if (event->shift > 0 && p->paintmode == GP_PAINTMODE_DRAW) { /* Using permanent stabilization, shift will deactivate the flag. */ - if (p->flags & (GP_PAINTFLAG_USE_STABILIZER)) { + if (p->flags & GP_PAINTFLAG_USE_STABILIZER) { if (p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) { - gpencil_draw_toggle_stabilizer_cursor(p, false); + annotation_draw_toggle_stabilizer_cursor(p, false); p->flags &= ~GP_PAINTFLAG_USE_STABILIZER_TEMP; } } /* Not using any stabilization flag. Activate temporal one. */ else if ((p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) == 0) { p->flags |= GP_PAINTFLAG_USE_STABILIZER_TEMP; - gpencil_draw_toggle_stabilizer_cursor(p, true); + annotation_draw_toggle_stabilizer_cursor(p, true); } } /* verify key status for straight lines */ @@ -2091,7 +2101,7 @@ static void annotation_draw_apply_event( so activate the temp flag back again. */ if (p->flags & GP_PAINTFLAG_USE_STABILIZER) { if ((p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) == 0) { - gpencil_draw_toggle_stabilizer_cursor(p, true); + annotation_draw_toggle_stabilizer_cursor(p, true); p->flags |= GP_PAINTFLAG_USE_STABILIZER_TEMP; } } @@ -2101,7 +2111,7 @@ static void annotation_draw_apply_event( else if (p->flags & GP_PAINTFLAG_USE_STABILIZER_TEMP) { /* Reset temporal stabilizer flag and remove cursor. */ p->flags &= ~GP_PAINTFLAG_USE_STABILIZER_TEMP; - gpencil_draw_toggle_stabilizer_cursor(p, false); + annotation_draw_toggle_stabilizer_cursor(p, false); } } @@ -2165,7 +2175,7 @@ static void annotation_draw_apply_event( RNA_float_set(&itemptr, "time", p->curtime - p->inittime); /* apply the current latest drawing point */ - gpencil_draw_apply(op, p, depsgraph); + annotation_draw_apply(op, p, depsgraph); /* force refresh */ /* just active area for now, since doing whole screen is too slow */ @@ -2175,7 +2185,7 @@ static void annotation_draw_apply_event( /* ------------------------------- */ /* operator 'redo' (i.e. after changing some properties, but also for repeat last) */ -static int gpencil_draw_exec(bContext *C, wmOperator *op) +static int annotation_draw_exec(bContext *C, wmOperator *op) { tGPsdata *p = NULL; Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C); @@ -2183,7 +2193,7 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op) /* printf("GPencil - Starting Re-Drawing\n"); */ /* try to initialize context data needed while drawing */ - if (!gpencil_draw_init(C, op, NULL)) { + if (!annotation_draw_init(C, op, NULL)) { if (op->customdata) { MEM_freeN(op->customdata); } @@ -2217,8 +2227,8 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op) */ if ((p->flags & GP_PAINTFLAG_FIRSTRUN) == 0) { /* TODO: both of these ops can set error-status, but we probably don't need to worry */ - gp_paint_strokeend(p); - gp_paint_initstroke(p, p->paintmode, depsgraph); + annotation_paint_strokeend(p); + annotation_paint_initstroke(p, p->paintmode, depsgraph); } } @@ -2233,14 +2243,14 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op) } /* apply this data as necessary now (as per usual) */ - gpencil_draw_apply(op, p, depsgraph); + annotation_draw_apply(op, p, depsgraph); } RNA_END; /* printf("\tGP - done\n"); */ /* cleanup */ - gpencil_draw_exit(C, op); + annotation_draw_exit(C, op); /* refreshes */ WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL); @@ -2252,12 +2262,12 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op) /* ------------------------------- */ /* start of interactive drawing part of operator */ -static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event) +static int annotation_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event) { tGPsdata *p = NULL; /* support for tablets eraser pen */ - if (gpencil_is_tablet_eraser_active(event)) { + if (annotation_is_tablet_eraser_active(event)) { RNA_enum_set(op->ptr, "mode", GP_PAINTMODE_ERASER); } @@ -2266,7 +2276,7 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event } /* try to initialize context data needed while drawing */ - if (!gpencil_draw_init(C, op, event)) { + if (!annotation_draw_init(C, op, event)) { if (op->customdata) { MEM_freeN(op->customdata); } @@ -2281,21 +2291,15 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event /* if empty erase capture and finish */ if (p->status == GP_STATUS_CAPTURE) { - gpencil_draw_exit(C, op); + annotation_draw_exit(C, op); BKE_report(op->reports, RPT_ERROR, "Nothing to erase"); return OPERATOR_FINISHED; } - /* TODO: set any additional settings that we can take from the events? - * TODO? if tablet is erasing, force eraser to be on? */ - - /* TODO: move cursor setting stuff to stroke-start so that paintmode can be changed midway... - */ - /* if eraser is on, draw radial aid */ if (p->paintmode == GP_PAINTMODE_ERASER) { - gpencil_draw_toggle_eraser_cursor(p, true); + annotation_draw_toggle_eraser_cursor(p, true); } else if (p->paintmode == GP_PAINTMODE_DRAW_STRAIGHT) { if (RNA_enum_get(op->ptr, "arrowstyle_start") != GP_STROKE_ARROWSTYLE_NONE) { @@ -2312,18 +2316,18 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event p->stabilizer_radius = RNA_int_get(op->ptr, "stabilizer_radius"); if (RNA_boolean_get(op->ptr, "use_stabilizer")) { p->flags |= GP_PAINTFLAG_USE_STABILIZER | GP_PAINTFLAG_USE_STABILIZER_TEMP; - gpencil_draw_toggle_stabilizer_cursor(p, true); + annotation_draw_toggle_stabilizer_cursor(p, true); } else if (event->shift > 0) { p->flags |= GP_PAINTFLAG_USE_STABILIZER_TEMP; - gpencil_draw_toggle_stabilizer_cursor(p, true); + annotation_draw_toggle_stabilizer_cursor(p, true); } } /* set cursor * NOTE: This may change later (i.e. intentionally via brush toggle, * or unintentionally if the user scrolls outside the area)... */ - gpencil_draw_cursor_set(p); + annotation_draw_cursor_set(p); /* only start drawing immediately if we're allowed to do so... */ if (RNA_boolean_get(op->ptr, "wait_for_input") == false) { @@ -2348,13 +2352,13 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event } /* gpencil modal operator stores area, which can be removed while using it (like fullscreen) */ -static bool gpencil_area_exists(bContext *C, ScrArea *area_test) +static bool annotation_area_exists(bContext *C, ScrArea *area_test) { bScreen *screen = CTX_wm_screen(C); return (BLI_findindex(&screen->areabase, area_test) != -1); } -static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op) +static tGPsdata *annotation_stroke_begin(bContext *C, wmOperator *op) { tGPsdata *p = op->customdata; @@ -2372,8 +2376,8 @@ static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op) /* XXX: watch it with the paintmode! in future, * it'd be nice to allow changing paint-mode when in sketching-sessions */ - if (gp_session_initdata(C, p)) { - gp_paint_initstroke(p, p->paintmode, CTX_data_ensure_evaluated_depsgraph(C)); + if (annotation_session_initdata(C, p)) { + annotation_paint_initstroke(p, p->paintmode, CTX_data_ensure_evaluated_depsgraph(C)); } if (p->status != GP_STATUS_ERROR) { @@ -2384,15 +2388,15 @@ static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op) return op->customdata; } -static void gpencil_stroke_end(wmOperator *op) +static void annotation_stroke_end(wmOperator *op) { tGPsdata *p = op->customdata; - gp_paint_cleanup(p); + annotation_paint_cleanup(p); gpencil_undo_push(p->gpd); - gp_session_cleanup(p); + annotation_session_cleanup(p); p->status = GP_STATUS_IDLING; op->flag |= OP_IS_MODAL_CURSOR_REGION; @@ -2439,7 +2443,7 @@ static void annotation_add_missing_events(bContext *C, } /* events handling during interactive drawing part of operator */ -static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) +static int annotation_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) { tGPsdata *p = op->customdata; /* default exit state - pass through to support MMB view nav, etc. */ @@ -2542,7 +2546,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) if (sketch) { /* end stroke only, and then wait to resume painting soon */ /* printf("\t\tGP - end stroke only\n"); */ - gpencil_stroke_end(op); + annotation_stroke_end(op); /* If eraser mode is on, turn it off after the stroke finishes * NOTE: This just makes it nicer to work with drawing sessions @@ -2561,7 +2565,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) * Just hiding this makes it seem like * you can paint again... */ - gpencil_draw_toggle_eraser_cursor(p, false); + annotation_draw_toggle_eraser_cursor(p, false); } } @@ -2637,7 +2641,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) /* Switch paintmode (temporarily if need be) based on which button was used * NOTE: This is to make it more convenient to erase strokes when using drawing sessions */ - if ((event->type == RIGHTMOUSE) || gpencil_is_tablet_eraser_active(event)) { + if ((event->type == RIGHTMOUSE) || annotation_is_tablet_eraser_active(event)) { /* turn on eraser */ p->paintmode = GP_PAINTMODE_ERASER; } @@ -2646,10 +2650,10 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) p->paintmode = RNA_enum_get(op->ptr, "mode"); } - gpencil_draw_toggle_eraser_cursor(p, p->paintmode == GP_PAINTMODE_ERASER); + annotation_draw_toggle_eraser_cursor(p, p->paintmode == GP_PAINTMODE_ERASER); /* not painting, so start stroke (this should be mouse-button down) */ - p = gpencil_stroke_begin(C, op); + p = annotation_stroke_begin(C, op); if (p->status == GP_STATUS_ERROR) { estate = OPERATOR_CANCELLED; @@ -2733,26 +2737,26 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) } /* gpencil modal operator stores area, which can be removed while using it (like fullscreen) */ - if (0 == gpencil_area_exists(C, p->area)) { + if (0 == annotation_area_exists(C, p->area)) { estate = OPERATOR_CANCELLED; } else { /* update status indicators - cursor, header, etc. */ - gpencil_draw_status_indicators(C, p); + annotation_draw_status_indicators(C, p); /* cursor may have changed outside our control - T44084 */ - gpencil_draw_cursor_set(p); + annotation_draw_cursor_set(p); } /* process last operations before exiting */ switch (estate) { case OPERATOR_FINISHED: /* one last flush before we're done */ - gpencil_draw_exit(C, op); + annotation_draw_exit(C, op); WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL); break; case OPERATOR_CANCELLED: - gpencil_draw_exit(C, op); + annotation_draw_exit(C, op); break; case OPERATOR_RUNNING_MODAL | OPERATOR_PASS_THROUGH: @@ -2811,11 +2815,11 @@ void GPENCIL_OT_annotate(wmOperatorType *ot) ot->description = "Make annotations on the active data"; /* api callbacks */ - ot->exec = gpencil_draw_exec; - ot->invoke = gpencil_draw_invoke; - ot->modal = gpencil_draw_modal; - ot->cancel = gpencil_draw_cancel; - ot->poll = gpencil_draw_poll; + ot->exec = annotation_draw_exec; + ot->invoke = annotation_draw_invoke; + ot->modal = annotation_draw_modal; + ot->cancel = annotation_draw_cancel; + ot->poll = annotation_draw_poll; /* flags */ ot->flag = OPTYPE_UNDO | OPTYPE_BLOCKING; |