Page MenuHome
Differential D4036 Diff 12772 source/blender/editors/gpencil/annotate_paint.c

Changeset View

Standalone View

View Options

source/blender/editors/gpencil/annotate_paint.c

Show First 20 Lines • Show All 135 Lines • ▼ Show 20 Linestypedef struct tGPsdata {
char *align_flag; /* projection-mode flags (toolsettings - eGPencil_Placement_Flags) */ char *align_flag; /* projection-mode flags (toolsettings - eGPencil_Placement_Flags) */
eGPencil_PaintStatus status; /* current status of painting */ eGPencil_PaintStatus status; /* current status of painting */
eGPencil_PaintModes paintmode; /* mode for painting */ eGPencil_PaintModes paintmode; /* mode for painting */
eGPencil_PaintFlags flags; /* flags that can get set during runtime (eGPencil_PaintFlags) */ eGPencil_PaintFlags flags; /* flags that can get set during runtime (eGPencil_PaintFlags) */
short radius; /* radius of influence for eraser */ short radius; /* radius of influence for eraser */
int mval[2]; /* current mouse-position */ float mval[2]; /* current mouse-position */
int mvalo[2]; /* previous recorded mouse-position */ float mvalo[2]; /* previous recorded mouse-position */
float pressure; /* current stylus pressure */ float pressure; /* current stylus pressure */
float opressure; /* previous stylus pressure */ float opressure; /* previous stylus pressure */
/* These need to be doubles, as (at least under unix) they are in seconds since epoch, /* These need to be doubles, as (at least under unix) they are in seconds since epoch,
* float (and its 7 digits precision) is definitively not enough here! * float (and its 7 digits precision) is definitively not enough here!
* double, with its 15 digits precision, ensures us millisecond precision for a few centuries at least. * double, with its 15 digits precision, ensures us millisecond precision for a few centuries at least.
*/ */
▲ Show 20 Lines • Show All 83 Lines • ▼ Show 20 Linesstatic void gp_get_3d_reference(tGPsdata *p, float vec[3])
/* use 3D-cursor */ /* use 3D-cursor */
copy_v3_v3(vec, fp); copy_v3_v3(vec, fp);
} }
/* Stroke Editing ---------------------------- */ /* Stroke Editing ---------------------------- */
/* check if the current mouse position is suitable for adding a new point */ /* check if the current mouse position is suitable for adding a new point */
static bool gp_stroke_filtermval(tGPsdata *p, const int mval[2], int pmval[2]) static bool gp_stroke_filtermval(tGPsdata *p, const float mval[2], float pmval[2])
{ {
int dx = abs(mval[0] - pmval[0]); int dx = (int)fabsf(mval[0] - pmval[0]);
int dy = abs(mval[1] - pmval[1]); int dy = (int)fabsf(mval[1] - pmval[1]);
/* if buffer is empty, just let this go through (i.e. so that dots will work) */ /* if buffer is empty, just let this go through (i.e. so that dots will work) */
if (p->gpd->runtime.sbuffer_size == 0) if (p->gpd->runtime.sbuffer_size == 0)
return true; return true;
/* check if mouse moved at least certain distance on both axes (best case) /* check if mouse moved at least certain distance on both axes (best case)
* - aims to eliminate some jitter-noise from input when trying to draw straight lines freehand * - aims to eliminate some jitter-noise from input when trying to draw straight lines freehand
*/ */
else if ((dx > MIN_MANHATTEN_PX) && (dy > MIN_MANHATTEN_PX)) else if ((dx > MIN_MANHATTEN_PX) && (dy > MIN_MANHATTEN_PX))
return true; return true;
/* check if the distance since the last point is significant enough /* check if the distance since the last point is significant enough
* - prevents points being added too densely * - prevents points being added too densely
* - distance here doesn't use sqrt to prevent slowness... we should still be safe from overflows though * - distance here doesn't use sqrt to prevent slowness... we should still be safe from overflows though
*/ */
else if ((dx * dx + dy * dy) > MIN_EUCLIDEAN_PX * MIN_EUCLIDEAN_PX) else if ((dx * dx + dy * dy) > MIN_EUCLIDEAN_PX * MIN_EUCLIDEAN_PX)
return true; return true;
/* mouse 'didn't move' */ /* mouse 'didn't move' */
else else
return false; return false;
} }
/* convert screen-coordinates to buffer-coordinates */ /* convert screen-coordinates to buffer-coordinates */
static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3], float *depth) static void gp_stroke_convertcoords(tGPsdata *p, const float mval[2], float out[3], float *depth)
{ {
bGPdata *gpd = p->gpd; bGPdata *gpd = p->gpd;
/* in 3d-space - pt->x/y/z are 3 side-by-side floats */ /* in 3d-space - pt->x/y/z are 3 side-by-side floats */
if (gpd->runtime.sbuffer_sflag & GP_STROKE_3DSPACE) { if (gpd->runtime.sbuffer_sflag & GP_STROKE_3DSPACE) {
if (gpencil_project_check(p) && (ED_view3d_autodist_simple(p->ar, mval, out, 0, depth))) { int mval_i[2];
round_v2i_v2fl(mval_i, mval);
if (gpencil_project_check(p) && (ED_view3d_autodist_simple(p->ar, mval_i, out, 0, depth))) {
/* projecting onto 3D-Geometry /* projecting onto 3D-Geometry
* - nothing more needs to be done here, since view_autodist_simple() has already done it * - nothing more needs to be done here, since view_autodist_simple() has already done it
*/ */
} }
else { else {
float mval_prj[2]; float mval_prj[2];
float rvec[3], dvec[3]; float rvec[3], dvec[3];
float mval_f[2] = {UNPACK2(mval)};
float zfac; float zfac;
/* Current method just converts each point in screen-coordinates to /* Current method just converts each point in screen-coordinates to
* 3D-coordinates using the 3D-cursor as reference. In general, this * 3D-coordinates using the 3D-cursor as reference. In general, this
* works OK, but it could of course be improved. * works OK, but it could of course be improved.
* *
* TODO: * TODO:
* - investigate using nearest point(s) on a previous stroke as * - investigate using nearest point(s) on a previous stroke as
* reference point instead or as offset, for easier stroke matching * reference point instead or as offset, for easier stroke matching
*/ */
gp_get_3d_reference(p, rvec); gp_get_3d_reference(p, rvec);
zfac = ED_view3d_calc_zfac(p->ar->regiondata, rvec, NULL); zfac = ED_view3d_calc_zfac(p->ar->regiondata, rvec, NULL);
if (ED_view3d_project_float_global(p->ar, rvec, mval_prj, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) { if (ED_view3d_project_float_global(p->ar, rvec, mval_prj, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
sub_v2_v2v2(mval_f, mval_prj, mval_f); float mval_f[2];
sub_v2_v2v2(mval_f, mval_prj, mval);
ED_view3d_win_to_delta(p->ar, mval_f, dvec, zfac); ED_view3d_win_to_delta(p->ar, mval_f, dvec, zfac);
sub_v3_v3v3(out, rvec, dvec); sub_v3_v3v3(out, rvec, dvec);
} }
else { else {
zero_v3(out); zero_v3(out);
} }
} }
} }
Show All 14 Lines else { /* camera view, use subrect */
out[0] = ((mval[0] - p->subrect->xmin) / BLI_rctf_size_x(p->subrect)) * 100; out[0] = ((mval[0] - p->subrect->xmin) / BLI_rctf_size_x(p->subrect)) * 100;
out[1] = ((mval[1] - p->subrect->ymin) / BLI_rctf_size_y(p->subrect)) * 100; out[1] = ((mval[1] - p->subrect->ymin) / BLI_rctf_size_y(p->subrect)) * 100;
} }
} }
} }
/* add current stroke-point to buffer (returns whether point was successfully added) */ /* add current stroke-point to buffer (returns whether point was successfully added) */
static short gp_stroke_addpoint( static short gp_stroke_addpoint(
tGPsdata *p, const int mval[2], float pressure, double curtime) tGPsdata *p, const float mval[2], float pressure, double curtime)
{ {
bGPdata *gpd = p->gpd; bGPdata *gpd = p->gpd;
tGPspoint *pt; tGPspoint *pt;
ToolSettings *ts = p->scene->toolsettings; ToolSettings *ts = p->scene->toolsettings;
/* check painting mode */ /* check painting mode */
if (p->paintmode == GP_PAINTMODE_DRAW_STRAIGHT) { if (p->paintmode == GP_PAINTMODE_DRAW_STRAIGHT) {
/* straight lines only - i.e. only store start and end point in buffer */ /* straight lines only - i.e. only store start and end point in buffer */
if (gpd->runtime.sbuffer_size == 0) { if (gpd->runtime.sbuffer_size == 0) {
/* first point in buffer (start point) */ /* first point in buffer (start point) */
pt = (tGPspoint *)(gpd->runtime.sbuffer); pt = (tGPspoint *)(gpd->runtime.sbuffer);
/* store settings */ /* store settings */
copy_v2_v2_int(&pt->x, mval); copy_v2_v2(&pt->x, mval);
pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */ pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */
pt->strength = 1.0f; pt->strength = 1.0f;
pt->time = (float)(curtime - p->inittime); pt->time = (float)(curtime - p->inittime);
/* increment buffer size */ /* increment buffer size */
gpd->runtime.sbuffer_size++; gpd->runtime.sbuffer_size++;
} }
else { else {
/* just reset the endpoint to the latest value /* just reset the endpoint to the latest value
* - assume that pointers for this are always valid... * - assume that pointers for this are always valid...
*/ */
pt = ((tGPspoint *)(gpd->runtime.sbuffer) + 1); pt = ((tGPspoint *)(gpd->runtime.sbuffer) + 1);
/* store settings */ /* store settings */
copy_v2_v2_int(&pt->x, mval); copy_v2_v2(&pt->x, mval);
pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */ pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */
pt->strength = 1.0f; pt->strength = 1.0f;
pt->time = (float)(curtime - p->inittime); pt->time = (float)(curtime - p->inittime);
/* now the buffer has 2 points (and shouldn't be allowed to get any larger) */ /* now the buffer has 2 points (and shouldn't be allowed to get any larger) */
gpd->runtime.sbuffer_size = 2; gpd->runtime.sbuffer_size = 2;
} }
/* can keep carrying on this way :) */ /* can keep carrying on this way :) */
return GP_STROKEADD_NORMAL; return GP_STROKEADD_NORMAL;
} }
else if (p->paintmode == GP_PAINTMODE_DRAW) { /* normal drawing */ else if (p->paintmode == GP_PAINTMODE_DRAW) { /* normal drawing */
/* check if still room in buffer */ /* check if still room in buffer */
if (gpd->runtime.sbuffer_size >= GP_STROKE_BUFFER_MAX) if (gpd->runtime.sbuffer_size >= GP_STROKE_BUFFER_MAX)
return GP_STROKEADD_OVERFLOW; return GP_STROKEADD_OVERFLOW;
/* get pointer to destination point */ /* get pointer to destination point */
pt = ((tGPspoint *)(gpd->runtime.sbuffer) + gpd->runtime.sbuffer_size); pt = ((tGPspoint *)(gpd->runtime.sbuffer) + gpd->runtime.sbuffer_size);
/* store settings */ /* store settings */
copy_v2_v2_int(&pt->x, mval); copy_v2_v2(&pt->x, mval);
pt->pressure = pressure; pt->pressure = pressure;
pt->strength = 1.0f; /* unused for annotations, but initialise for easier conversions to GP Object */ pt->strength = 1.0f; /* unused for annotations, but initialise for easier conversions to GP Object */
/* point time */ /* point time */
pt->time = (float)(curtime - p->inittime); pt->time = (float)(curtime - p->inittime);
/* increment counters */ /* increment counters */
gpd->runtime.sbuffer_size++; gpd->runtime.sbuffer_size++;
/* check if another operation can still occur */ /* check if another operation can still occur */
if (gpd->runtime.sbuffer_size == GP_STROKE_BUFFER_MAX) if (gpd->runtime.sbuffer_size == GP_STROKE_BUFFER_MAX)
return GP_STROKEADD_FULL; return GP_STROKEADD_FULL;
else else
return GP_STROKEADD_NORMAL; return GP_STROKEADD_NORMAL;
} }
else if (p->paintmode == GP_PAINTMODE_DRAW_POLY) { else if (p->paintmode == GP_PAINTMODE_DRAW_POLY) {
/* get pointer to destination point */ /* get pointer to destination point */
pt = (tGPspoint *)(gpd->runtime.sbuffer); pt = (tGPspoint *)(gpd->runtime.sbuffer);
/* store settings */ /* store settings */
copy_v2_v2_int(&pt->x, mval); copy_v2_v2(&pt->x, mval);
pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */ pt->pressure = 1.0f; /* T44932 - Pressure vals are unreliable, so ignore for now */
pt->strength = 1.0f; pt->strength = 1.0f;
pt->time = (float)(curtime - p->inittime); pt->time = (float)(curtime - p->inittime);
/* if there's stroke for this poly line session add (or replace last) point /* if there's stroke for this poly line session add (or replace last) point
* to stroke. This allows to draw lines more interactively (see new segment * to stroke. This allows to draw lines more interactively (see new segment
* during mouse slide, e.g.) * during mouse slide, e.g.)
*/ */
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines#define GP_SIMPLIFY_AVPOINT(offs, sfac) \
time += old_points[offs].time * sfac; \ time += old_points[offs].time * sfac; \
} (void)0 } (void)0
/* XXX Here too, do not lose start and end points! */ /* XXX Here too, do not lose start and end points! */
gp_stroke_addpoint(p, &old_points->x, old_points->pressure, p->inittime + (double)old_points->time); gp_stroke_addpoint(p, &old_points->x, old_points->pressure, p->inittime + (double)old_points->time);
for (i = 0, j = 0; i < num_points; i++) { for (i = 0, j = 0; i < num_points; i++) {
if (i - j == 3) { if (i - j == 3) {
float co[2], pressure, time; float co[2], pressure, time;
int mco[2]; float mco[2];
/* initialize values */ /* initialize values */
co[0] = 0.0f; co[0] = 0.0f;
co[1] = 0.0f; co[1] = 0.0f;
pressure = 0.0f; pressure = 0.0f;
time = 0.0f; time = 0.0f;
/* using macro, calculate new point */ /* using macro, calculate new point */
GP_SIMPLIFY_AVPOINT(j, -0.25f); GP_SIMPLIFY_AVPOINT(j, -0.25f);
GP_SIMPLIFY_AVPOINT(j + 1, 0.75f); GP_SIMPLIFY_AVPOINT(j + 1, 0.75f);
GP_SIMPLIFY_AVPOINT(j + 2, 0.75f); GP_SIMPLIFY_AVPOINT(j + 2, 0.75f);
GP_SIMPLIFY_AVPOINT(j + 3, -0.25f); GP_SIMPLIFY_AVPOINT(j + 3, -0.25f);
/* set values for adding */ /* set values for adding */
mco[0] = (int)co[0]; mco[0] = co[0];
mco[1] = (int)co[1]; mco[1] = co[1];
/* ignore return values on this... assume to be ok for now */ /* ignore return values on this... assume to be ok for now */
gp_stroke_addpoint(p, mco, pressure, p->inittime + (double)time); gp_stroke_addpoint(p, mco, pressure, p->inittime + (double)time);
j += 2; j += 2;
} }
} }
gp_stroke_addpoint( gp_stroke_addpoint(
▲ Show 20 Lines • Show All 114 Lines • ▼ Show 20 Lines else {
if (gpencil_project_check(p)) { if (gpencil_project_check(p)) {
int mval[2], mval_prev[2] = { 0 }; int mval[2], mval_prev[2] = { 0 };
int interp_depth = 0; int interp_depth = 0;
int found_depth = 0; int found_depth = 0;
depth_arr = MEM_mallocN(sizeof(float) * gpd->runtime.sbuffer_size, "depth_points"); depth_arr = MEM_mallocN(sizeof(float) * gpd->runtime.sbuffer_size, "depth_points");
for (i = 0, ptc = gpd->runtime.sbuffer; i < gpd->runtime.sbuffer_size; i++, ptc++, pt++) { for (i = 0, ptc = gpd->runtime.sbuffer; i < gpd->runtime.sbuffer_size; i++, ptc++, pt++) {
copy_v2_v2_int(mval, &ptc->x); int mval_i[2];
round_v2i_v2fl(mval_i, &ptc->x);
if ((ED_view3d_autodist_depth(p->ar, mval, depth_margin, depth_arr + i) == 0) && if ((ED_view3d_autodist_depth(p->ar, mval_i, depth_margin, depth_arr + i) == 0) &&
(i && (ED_view3d_autodist_depth_seg(p->ar, mval, mval_prev, depth_margin + 1, depth_arr + i) == 0))) (i && (ED_view3d_autodist_depth_seg(p->ar, mval_i, mval_prev, depth_margin + 1, depth_arr + i) == 0)))
{ {
interp_depth = true; interp_depth = true;
} }
else { else {
found_depth = true; found_depth = true;
} }
copy_v2_v2_int(mval_prev, mval); copy_v2_v2_int(mval_prev, mval);
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 Linesstatic bool gp_stroke_eraser_is_occluded(tGPsdata *p, const bGPDspoint *pt, const int x, const int y)
return false; return false;
} }
/* eraser tool - evaluation per stroke */ /* eraser tool - evaluation per stroke */
/* TODO: this could really do with some optimization (KD-Tree/BVH?) */ /* TODO: this could really do with some optimization (KD-Tree/BVH?) */
static void gp_stroke_eraser_dostroke( static void gp_stroke_eraser_dostroke(
tGPsdata *p, tGPsdata *p,
bGPDframe *gpf, bGPDstroke *gps, bGPDframe *gpf, bGPDstroke *gps,
const int mval[2], const int mvalo[2], const float mval[2], const float mvalo[2],
const int radius, const rcti *rect) const int radius, const rcti *rect)
{ {
bGPDspoint *pt1, *pt2; bGPDspoint *pt1, *pt2;
int pc1[2] = {0}; int pc1[2] = {0};
int pc2[2] = {0}; int pc2[2] = {0};
int i; int i;
if (gps->totpoints == 0) { if (gps->totpoints == 0) {
/* just free stroke */ /* just free stroke */
gp_free_stroke(gpf, gps); gp_free_stroke(gpf, gps);
} }
else if (gps->totpoints == 1) { else if (gps->totpoints == 1) {
/* only process if it hasn't been masked out... */ /* only process if it hasn't been masked out... */
if (!(p->flags & GP_PAINTFLAG_SELECTMASK) || (gps->points->flag & GP_SPOINT_SELECT)) { 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]); gp_point_to_xy(&p->gsc, gps, gps->points, &pc1[0], &pc1[1]);
/* do boundbox check first */ /* do boundbox check first */
if ((!ELEM(V2D_IS_CLIPPED, pc1[0], pc1[1])) && BLI_rcti_isect_pt(rect, pc1[0], pc1[1])) { if ((!ELEM(V2D_IS_CLIPPED, pc1[0], pc1[1])) && BLI_rcti_isect_pt(rect, pc1[0], pc1[1])) {
/* only check if point is inside */ /* only check if point is inside */
if (len_v2v2_int(mval, pc1) <= radius) { int mval_i[2];
antoniovUnsubmitted
Done
Inline Actions

Maybe you could calc mval_i at the begining of the function.

antoniov: Maybe you could calc mval_i at the begining of the function.
round_v2i_v2fl(mval_i, mval);
if (len_v2v2_int(mval_i, pc1) <= radius) {
/* free stroke */ /* free stroke */
gp_free_stroke(gpf, gps); gp_free_stroke(gpf, gps);
} }
} }
} }
} }
else { else {
/* Perform culling? */ /* Perform culling? */
Show All 34 Lines for (i = 0; (i + 1) < gps->totpoints; i++) {
* eraser region (either within stroke painted, or on its lines) * eraser region (either within stroke painted, or on its lines)
* - this assumes that linewidth is irrelevant * - this assumes that linewidth is irrelevant
*/ */
if (gp_stroke_inside_circle(mval, mvalo, radius, pc1[0], pc1[1], pc2[0], pc2[1])) { if (gp_stroke_inside_circle(mval, mvalo, radius, pc1[0], pc1[1], pc2[0], pc2[1])) {
if ((gp_stroke_eraser_is_occluded(p, pt1, pc1[0], pc1[1]) == false) || 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)) (gp_stroke_eraser_is_occluded(p, pt2, pc2[0], pc2[1]) == false))
{ {
/* Edge is affected - Check individual points now */ /* Edge is affected - Check individual points now */
if (len_v2v2_int(mval, pc1) <= radius) { int mval_i[2];
round_v2i_v2fl(mval_i, mval);
if (len_v2v2_int(mval_i, pc1) <= radius) {
pt1->flag |= GP_SPOINT_TAG; pt1->flag |= GP_SPOINT_TAG;
} }
if (len_v2v2_int(mval, pc2) <= radius) { if (len_v2v2_int(mval_i, pc2) <= radius) {
pt2->flag |= GP_SPOINT_TAG; pt2->flag |= GP_SPOINT_TAG;
} }
do_cull = true; do_cull = true;
} }
} }
} }
} }
▲ Show 20 Lines • Show All 1,463 Lines • Show Last 20 Lines