Whitespace tweaks and Bugfixes
* Fixed memory leak, where temp buffers for tGpTimingData were not freed * Fixed crash when there was no active object when converting to paths
This commit is contained in:
parent
d22c5d4341
commit
5d8a207b67
|
@ -471,7 +471,7 @@ static void gp_strokepoint_convertcoords(bContext *C, bGPDstroke *gps, bGPDspoin
|
|||
mvalf[1] = (float)pt->y / 100.0f * ar->winy;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* convert screen coordinate to 3d coordinates
|
||||
* - method taken from editview.c - mouse_cursor()
|
||||
*/
|
||||
|
@ -504,19 +504,22 @@ typedef struct tGpTimingData {
|
|||
double inittime;
|
||||
} tGpTimingData;
|
||||
|
||||
/* init point buffers for timing data */
|
||||
static void _gp_timing_data_set_nbr(tGpTimingData *gtd, int nbr)
|
||||
{
|
||||
float *tmp;
|
||||
|
||||
BLI_assert(nbr > gtd->num_points);
|
||||
|
||||
|
||||
/* distances */
|
||||
tmp = gtd->dists;
|
||||
gtd->dists = MEM_callocN(sizeof(float) * nbr, __func__);
|
||||
if (tmp) {
|
||||
memcpy(gtd->dists, tmp, sizeof(float) * gtd->num_points);
|
||||
MEM_freeN(tmp);
|
||||
}
|
||||
|
||||
|
||||
/* times */
|
||||
tmp = gtd->times;
|
||||
gtd->times = MEM_callocN(sizeof(float) * nbr, __func__);
|
||||
if (tmp) {
|
||||
|
@ -527,6 +530,7 @@ static void _gp_timing_data_set_nbr(tGpTimingData *gtd, int nbr)
|
|||
gtd->num_points = nbr;
|
||||
}
|
||||
|
||||
/* add stroke point to timing buffers */
|
||||
static void gp_timing_data_add_point(tGpTimingData *gtd, double stroke_inittime, float time, float delta_dist)
|
||||
{
|
||||
if (time < 0.0f) {
|
||||
|
@ -534,13 +538,16 @@ static void gp_timing_data_add_point(tGpTimingData *gtd, double stroke_inittime,
|
|||
gtd->tot_time = -(gtd->times[gtd->cur_point] = -(((float)(stroke_inittime - gtd->inittime)) + time));
|
||||
gtd->gap_tot_time += gtd->times[gtd->cur_point] - gtd->times[gtd->cur_point - 1];
|
||||
}
|
||||
else
|
||||
else {
|
||||
gtd->tot_time = (gtd->times[gtd->cur_point] = (((float)(stroke_inittime - gtd->inittime)) + time));
|
||||
gtd->dists[gtd->cur_point] = (gtd->tot_dist += delta_dist);
|
||||
}
|
||||
|
||||
gtd->tot_dist += delta_dist;
|
||||
gtd->dists[gtd->cur_point] = gtd->tot_dist;
|
||||
gtd->cur_point++;
|
||||
}
|
||||
|
||||
/* In frames! Binary search for FCurve keys have a threshold of 0.01, so we can’t set
|
||||
/* In frames! Binary search for FCurve keys have a threshold of 0.01, so we can't set
|
||||
* arbitrarily close points - this is esp. important with NoGaps mode!
|
||||
*/
|
||||
#define MIN_TIME_DELTA 0.02f
|
||||
|
@ -550,7 +557,7 @@ static int gp_find_end_of_stroke_idx(tGpTimingData *gtd, int idx, int nbr_gaps,
|
|||
float tot_gaps_time, float delta_time, float *next_delta_time)
|
||||
{
|
||||
int j;
|
||||
|
||||
|
||||
for (j = idx + 1; j < gtd->num_points; j++) {
|
||||
if (gtd->times[j] < 0) {
|
||||
gtd->times[j] = -gtd->times[j];
|
||||
|
@ -572,10 +579,12 @@ static int gp_find_end_of_stroke_idx(tGpTimingData *gtd, int idx, int nbr_gaps,
|
|||
/* This code ensures that if the first gaps have been shorter than average gap_duration,
|
||||
* next gaps will tend to be longer (i.e. try to recover the lateness), and vice-versa!
|
||||
*/
|
||||
delta = delta_time - (gtd->gap_duration * *nbr_done_gaps);
|
||||
delta = delta_time - (gtd->gap_duration * (*nbr_done_gaps));
|
||||
|
||||
/* Clamp min between [-gap_randomness, 0.0], with lower delta giving higher min */
|
||||
min = -gtd->gap_randomness - delta;
|
||||
CLAMP(min, -gtd->gap_randomness, 0.0f);
|
||||
|
||||
/* Clamp max between [0.0, gap_randomness], with lower delta giving higher max */
|
||||
max = gtd->gap_randomness - delta;
|
||||
CLAMP(max, 0.0f, gtd->gap_randomness);
|
||||
|
@ -655,11 +664,11 @@ static void gp_stroke_path_animation_add_keyframes(ReportList *reports, PointerR
|
|||
/* This one should *never* be negative! */
|
||||
end_stroke_time = time_start + ((gtd->times[end_stroke_idx] + delta_time) / gtd->tot_time * time_range);
|
||||
}
|
||||
|
||||
|
||||
/* Simple proportional stuff... */
|
||||
cu->ctime = gtd->dists[i] / gtd->tot_dist * cu->pathlen;
|
||||
cfra = time_start + ((gtd->times[i] + delta_time) / gtd->tot_time * time_range);
|
||||
|
||||
|
||||
/* And now, the checks about timing... */
|
||||
if (i == start_stroke_idx) {
|
||||
/* If first point of a stroke, be sure it's enough ahead of last valid keyframe, and
|
||||
|
@ -709,45 +718,44 @@ static void gp_stroke_path_animation(bContext *C, ReportList *reports, Curve *cu
|
|||
FCurve *fcu;
|
||||
PointerRNA ptr;
|
||||
PropertyRNA *prop = NULL;
|
||||
|
||||
int nbr_gaps = 0, i;
|
||||
|
||||
|
||||
if (gtd->mode == GP_STROKECONVERT_TIMING_NONE)
|
||||
return;
|
||||
|
||||
|
||||
/* gap_duration and gap_randomness are in frames, but we need seconds!!! */
|
||||
gtd->gap_duration = FRA2TIME(gtd->gap_duration);
|
||||
gtd->gap_randomness = FRA2TIME(gtd->gap_randomness);
|
||||
|
||||
|
||||
/* Enable path! */
|
||||
cu->flag |= CU_PATH;
|
||||
cu->pathlen = gtd->frame_range;
|
||||
|
||||
/* Get or create default action to add F-Curve+keyframe to */
|
||||
act = verify_adt_action((ID*)cu, TRUE);
|
||||
/* Create RNA stuff */
|
||||
RNA_id_pointer_create((ID*)cu, &ptr);
|
||||
|
||||
/* Get RNA pointer to read/write path time values */
|
||||
RNA_id_pointer_create((ID *)cu, &ptr);
|
||||
prop = RNA_struct_find_property(&ptr, "eval_time");
|
||||
/* Get or create fcurve */
|
||||
|
||||
/* Ensure we have an F-Curve to add keyframes to */
|
||||
act = verify_adt_action((ID *)cu, TRUE);
|
||||
fcu = verify_fcurve(act, NULL, &ptr, "eval_time", 0, TRUE);
|
||||
|
||||
|
||||
if (G.debug & G_DEBUG) {
|
||||
printf("%s: tot len: %f\t\ttot time: %f\n", __func__, gtd->tot_dist, gtd->tot_time);
|
||||
for (i = 0; i < gtd->num_points; i++) {
|
||||
printf("\tpoint %d:\t\tlen: %f\t\ttime: %f\n", i, gtd->dists[i], gtd->times[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (gtd->mode == GP_STROKECONVERT_TIMING_LINEAR) {
|
||||
float cfra;
|
||||
|
||||
|
||||
/* Linear extrapolation! */
|
||||
fcu->extend = FCURVE_EXTRAPOLATE_LINEAR;
|
||||
|
||||
|
||||
cu->ctime = 0.0f;
|
||||
cfra = (float)gtd->start_frame;
|
||||
insert_keyframe_direct(reports, ptr, prop, fcu, cfra, INSERTKEY_FAST);
|
||||
|
||||
|
||||
cu->ctime = cu->pathlen;
|
||||
if (gtd->realtime) {
|
||||
cfra += (float)TIME2FRA(gtd->tot_time); /* Seconds to frames */
|
||||
|
@ -760,34 +768,33 @@ static void gp_stroke_path_animation(bContext *C, ReportList *reports, Curve *cu
|
|||
else {
|
||||
/* Use actual recorded timing! */
|
||||
float time_range;
|
||||
|
||||
|
||||
/* CustomGaps specific */
|
||||
float tot_gaps_time = 0.0f;
|
||||
|
||||
/* Pre-process gaps, in case we don't want to keep their org timing */
|
||||
|
||||
/* Pre-process gaps, in case we don't want to keep their original timing */
|
||||
if (gtd->mode == GP_STROKECONVERT_TIMING_CUSTOMGAP) {
|
||||
gp_stroke_path_animation_preprocess_gaps(gtd, &nbr_gaps, &tot_gaps_time);
|
||||
}
|
||||
|
||||
|
||||
if (gtd->realtime) {
|
||||
time_range = (float)TIME2FRA(gtd->tot_time); /* Seconds to frames */
|
||||
}
|
||||
else {
|
||||
time_range = (float)(gtd->end_frame - gtd->start_frame);
|
||||
}
|
||||
|
||||
|
||||
if (G.debug & G_DEBUG) {
|
||||
printf("Starting keying!\n");
|
||||
printf("GP Stroke Path Conversion: Starting keying!\n");
|
||||
}
|
||||
|
||||
|
||||
gp_stroke_path_animation_add_keyframes(reports, ptr, prop, fcu, cu, gtd, time_range,
|
||||
nbr_gaps, tot_gaps_time);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/* As we used INSERTKEY_FAST mode, we need to recompute all curve's handles now */
|
||||
calchandles_fcurve(fcu);
|
||||
|
||||
|
||||
if (G.debug & G_DEBUG) {
|
||||
printf("%s: \ntot len: %f\t\ttot time: %f\n", __func__, gtd->tot_dist, gtd->tot_time);
|
||||
for (i = 0; i < gtd->num_points; i++) {
|
||||
|
@ -795,11 +802,11 @@ static void gp_stroke_path_animation(bContext *C, ReportList *reports, Curve *cu
|
|||
}
|
||||
printf("\n\n");
|
||||
}
|
||||
|
||||
|
||||
WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_EDITED, NULL);
|
||||
|
||||
|
||||
/* send updates */
|
||||
DAG_id_tag_update((ID*)cu, 0);
|
||||
DAG_id_tag_update(&cu->id, 0);
|
||||
}
|
||||
|
||||
#undef MIN_TIME_DELTA
|
||||
|
@ -813,14 +820,15 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
|
|||
float minmax_weights[2], float rad_fac, int stitch, tGpTimingData *gtd)
|
||||
{
|
||||
bGPDspoint *pt;
|
||||
Nurb *nu = curnu ? *curnu : NULL;
|
||||
Nurb *nu = (curnu) ? *curnu : NULL;
|
||||
BPoint *bp, *prev_bp = NULL;
|
||||
int i, old_nbp = 0;
|
||||
const int do_gtd = (gtd->mode != GP_STROKECONVERT_TIMING_NONE);
|
||||
int i, old_nbp = 0;
|
||||
|
||||
/* create new 'nurb' or extend current one within the curve */
|
||||
if (nu) {
|
||||
old_nbp = nu->pntsu;
|
||||
|
||||
/* If stitch, the first point of this stroke is already present in current nu.
|
||||
* Else, we have to add to additional points to make the zero-radius link between strokes.
|
||||
*/
|
||||
|
@ -837,9 +845,9 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
|
|||
nu->resolu = cu->resolu;
|
||||
nu->resolv = cu->resolv;
|
||||
nu->knotsu = NULL;
|
||||
|
||||
|
||||
nu->bp = (BPoint *)MEM_callocN(sizeof(BPoint) * nu->pntsu, "bpoints");
|
||||
|
||||
|
||||
stitch = FALSE; /* Security! */
|
||||
}
|
||||
|
||||
|
@ -861,11 +869,12 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
|
|||
float delta_time;
|
||||
|
||||
prev_bp = NULL;
|
||||
if (old_nbp > 1 && gps->prev && gps->prev->totpoints > 1) {
|
||||
if ((old_nbp > 1) && gps->prev && (gps->prev->totpoints > 1)) {
|
||||
/* Only use last curve segment if previous stroke was not a single-point one! */
|
||||
prev_bp = nu->bp + old_nbp - 2;
|
||||
}
|
||||
bp = nu->bp + old_nbp - 1;
|
||||
|
||||
/* XXX We do this twice... Not sure it's worth to bother about this! */
|
||||
gp_strokepoint_convertcoords(C, gps, gps->points, p, subrect);
|
||||
if (prev_bp) {
|
||||
|
@ -874,6 +883,7 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
|
|||
else {
|
||||
interp_v3_v3v3(p1, bp->vec, p, GAP_DFAC);
|
||||
}
|
||||
|
||||
if (gps->totpoints > 1) {
|
||||
/* XXX We do this twice... Not sure it's worth to bother about this! */
|
||||
gp_strokepoint_convertcoords(C, gps, gps->points + 1, next_p, subrect);
|
||||
|
@ -882,7 +892,7 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
|
|||
else {
|
||||
interp_v3_v3v3(p2, p, bp->vec, GAP_DFAC);
|
||||
}
|
||||
|
||||
|
||||
/* First point */
|
||||
bp++;
|
||||
copy_v3_v3(bp->vec, p1);
|
||||
|
@ -898,7 +908,7 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
|
|||
}
|
||||
gp_timing_data_add_point(gtd, gtd->inittime, delta_time, len_v3v3((bp - 1)->vec, p1));
|
||||
}
|
||||
|
||||
|
||||
/* Second point */
|
||||
bp++;
|
||||
copy_v3_v3(bp->vec, p2);
|
||||
|
@ -915,25 +925,26 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
|
|||
}
|
||||
gp_timing_data_add_point(gtd, gps->inittime, delta_time, len_v3v3(p1, p2));
|
||||
}
|
||||
|
||||
|
||||
old_nbp += 2;
|
||||
}
|
||||
if (old_nbp && do_gtd) {
|
||||
prev_bp = nu->bp + old_nbp - 1;
|
||||
}
|
||||
|
||||
/* add points */
|
||||
for (i = stitch ? 1 : 0, pt = gps->points + (stitch ? 1 : 0), bp = nu->bp + old_nbp;
|
||||
for (i = (stitch) ? 1 : 0, pt = gps->points + ((stitch) ? 1 : 0), bp = nu->bp + old_nbp;
|
||||
i < gps->totpoints;
|
||||
i++, pt++, bp++)
|
||||
{
|
||||
float p3d[3];
|
||||
float width = pt->pressure * gpl->thickness * WIDTH_CORR_FAC;
|
||||
|
||||
|
||||
/* get coordinates to add at */
|
||||
gp_strokepoint_convertcoords(C, gps, pt, p3d, subrect);
|
||||
copy_v3_v3(bp->vec, p3d);
|
||||
bp->vec[3] = 1.0f;
|
||||
|
||||
|
||||
/* set settings */
|
||||
bp->f1 = SELECT;
|
||||
bp->radius = width * rad_fac;
|
||||
|
@ -945,14 +956,14 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
|
|||
else if (bp->weight > minmax_weights[1]) {
|
||||
minmax_weights[1] = bp->weight;
|
||||
}
|
||||
|
||||
|
||||
/* Update timing data */
|
||||
if (do_gtd) {
|
||||
gp_timing_data_add_point(gtd, gps->inittime, pt->time, prev_bp ? len_v3v3(prev_bp->vec, p3d) : 0.0f);
|
||||
gp_timing_data_add_point(gtd, gps->inittime, pt->time, (prev_bp) ? len_v3v3(prev_bp->vec, p3d) : 0.0f);
|
||||
}
|
||||
prev_bp = bp;
|
||||
}
|
||||
|
||||
|
||||
/* add nurb to curve */
|
||||
if (!curnu || !*curnu) {
|
||||
BLI_addtail(&cu->nurb, nu);
|
||||
|
@ -960,7 +971,7 @@ static void gp_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curv
|
|||
if (curnu) {
|
||||
*curnu = nu;
|
||||
}
|
||||
|
||||
|
||||
BKE_nurb_knot_calc_u(nu);
|
||||
}
|
||||
|
||||
|
@ -968,7 +979,7 @@ static int gp_camera_view_subrect(bContext *C, rctf *subrect)
|
|||
{
|
||||
View3D *v3d = CTX_wm_view3d(C);
|
||||
ARegion *ar = CTX_wm_region(C);
|
||||
|
||||
|
||||
if (v3d) {
|
||||
RegionView3D *rv3d = ar->regiondata;
|
||||
|
||||
|
@ -979,7 +990,7 @@ static int gp_camera_view_subrect(bContext *C, rctf *subrect)
|
|||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -988,12 +999,12 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
float minmax_weights[2], float rad_fac, int stitch, tGpTimingData *gtd)
|
||||
{
|
||||
bGPDspoint *pt;
|
||||
Nurb *nu = curnu ? *curnu : NULL;
|
||||
Nurb *nu = (curnu) ? *curnu : NULL;
|
||||
BezTriple *bezt, *prev_bezt = NULL;
|
||||
int i, tot, old_nbezt = 0;
|
||||
float p3d_cur[3], p3d_prev[3], p3d_next[3];
|
||||
const int do_gtd = (gtd->mode != GP_STROKECONVERT_TIMING_NONE);
|
||||
|
||||
|
||||
/* create new 'nurb' or extend current one within the curve */
|
||||
if (nu) {
|
||||
old_nbezt = nu->pntsu;
|
||||
|
@ -1001,17 +1012,17 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
* so no need to add it.
|
||||
* If no stitch, we want to add two additional points to make a "zero-radius" link between both strokes.
|
||||
*/
|
||||
BKE_nurb_bezierPoints_add(nu, gps->totpoints + (stitch ? -1 : 2));
|
||||
BKE_nurb_bezierPoints_add(nu, gps->totpoints + ((stitch) ? -1 : 2));
|
||||
}
|
||||
else {
|
||||
nu = (Nurb *)MEM_callocN(sizeof(Nurb), "gpstroke_to_bezier(nurb)");
|
||||
|
||||
|
||||
nu->pntsu = gps->totpoints;
|
||||
nu->resolu = 12;
|
||||
nu->resolv = 12;
|
||||
nu->type = CU_BEZIER;
|
||||
nu->bezt = (BezTriple *)MEM_callocN(gps->totpoints * sizeof(BezTriple), "bezts");
|
||||
|
||||
|
||||
stitch = FALSE; /* Security! */
|
||||
}
|
||||
|
||||
|
@ -1024,9 +1035,9 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
/* get initial coordinates */
|
||||
pt = gps->points;
|
||||
if (tot) {
|
||||
gp_strokepoint_convertcoords(C, gps, pt, stitch ? p3d_prev : p3d_cur, subrect);
|
||||
gp_strokepoint_convertcoords(C, gps, pt, (stitch) ? p3d_prev : p3d_cur, subrect);
|
||||
if (tot > 1) {
|
||||
gp_strokepoint_convertcoords(C, gps, pt + 1, stitch ? p3d_cur : p3d_next, subrect);
|
||||
gp_strokepoint_convertcoords(C, gps, pt + 1, (stitch) ? p3d_cur : p3d_next, subrect);
|
||||
}
|
||||
if (stitch && tot > 2) {
|
||||
gp_strokepoint_convertcoords(C, gps, pt + 2, p3d_next, subrect);
|
||||
|
@ -1035,7 +1046,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
|
||||
/* If needed, make the link between both strokes with two zero-radius additional points */
|
||||
if (curnu && old_nbezt) {
|
||||
/* Update last point's second handle! */
|
||||
/* Update last point's second handle */
|
||||
if (stitch) {
|
||||
float h2[3];
|
||||
bezt = nu->bezt + old_nbezt - 1;
|
||||
|
@ -1043,6 +1054,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
copy_v3_v3(bezt->vec[2], h2);
|
||||
pt++;
|
||||
}
|
||||
|
||||
/* Create "link points" */
|
||||
/* About "zero-radius" point interpolations:
|
||||
* - If we have at least two points in current curve (most common case), we linearly extrapolate
|
||||
|
@ -1055,7 +1067,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
else {
|
||||
float h1[3], h2[3], p1[3], p2[3];
|
||||
float delta_time;
|
||||
|
||||
|
||||
prev_bezt = NULL;
|
||||
if (old_nbezt > 1 && gps->prev && gps->prev->totpoints > 1) {
|
||||
/* Only use last curve segment if previous stroke was not a single-point one! */
|
||||
|
@ -1074,15 +1086,15 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
else {
|
||||
interp_v3_v3v3(p2, p3d_cur, bezt->vec[1], GAP_DFAC);
|
||||
}
|
||||
|
||||
|
||||
/* Second handle of last point */
|
||||
interp_v3_v3v3(h2, bezt->vec[1], p1, BEZT_HANDLE_FAC);
|
||||
copy_v3_v3(bezt->vec[2], h2);
|
||||
|
||||
|
||||
/* First point */
|
||||
interp_v3_v3v3(h1, p1, bezt->vec[1], BEZT_HANDLE_FAC);
|
||||
interp_v3_v3v3(h2, p1, p2, BEZT_HANDLE_FAC);
|
||||
|
||||
|
||||
bezt++;
|
||||
copy_v3_v3(bezt->vec[0], h1);
|
||||
copy_v3_v3(bezt->vec[1], p1);
|
||||
|
@ -1090,7 +1102,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
bezt->h1 = bezt->h2 = HD_FREE;
|
||||
bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
|
||||
minmax_weights[0] = bezt->radius = bezt->weight = 0.0f;
|
||||
|
||||
|
||||
if (do_gtd) {
|
||||
if (prev_bezt) {
|
||||
delta_time = gtd->tot_time + (gtd->tot_time - gtd->times[gtd->cur_point - 1]) * GAP_DFAC;
|
||||
|
@ -1100,11 +1112,11 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
}
|
||||
gp_timing_data_add_point(gtd, gtd->inittime, delta_time, len_v3v3((bezt - 1)->vec[1], p1));
|
||||
}
|
||||
|
||||
|
||||
/* Second point */
|
||||
interp_v3_v3v3(h1, p2, p1, BEZT_HANDLE_FAC);
|
||||
interp_v3_v3v3(h2, p2, p3d_cur, BEZT_HANDLE_FAC);
|
||||
|
||||
|
||||
bezt++;
|
||||
copy_v3_v3(bezt->vec[0], h1);
|
||||
copy_v3_v3(bezt->vec[1], p2);
|
||||
|
@ -1112,7 +1124,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
bezt->h1 = bezt->h2 = HD_FREE;
|
||||
bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
|
||||
minmax_weights[0] = bezt->radius = bezt->weight = 0.0f;
|
||||
|
||||
|
||||
if (do_gtd) {
|
||||
/* This negative delta_time marks the gap! */
|
||||
if (tot > 1) {
|
||||
|
@ -1123,7 +1135,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
}
|
||||
gp_timing_data_add_point(gtd, gps->inittime, delta_time, len_v3v3(p1, p2));
|
||||
}
|
||||
|
||||
|
||||
old_nbezt += 2;
|
||||
copy_v3_v3(p3d_prev, p2);
|
||||
}
|
||||
|
@ -1131,29 +1143,30 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
if (old_nbezt && do_gtd) {
|
||||
prev_bezt = nu->bezt + old_nbezt - 1;
|
||||
}
|
||||
|
||||
/* add points */
|
||||
for (i = stitch ? 1 : 0, bezt = nu->bezt + old_nbezt; i < tot; i++, pt++, bezt++) {
|
||||
float h1[3], h2[3];
|
||||
float width = pt->pressure * gpl->thickness * WIDTH_CORR_FAC;
|
||||
|
||||
|
||||
if (i || old_nbezt) {
|
||||
interp_v3_v3v3(h1, p3d_cur, p3d_prev, BEZT_HANDLE_FAC);
|
||||
}
|
||||
else {
|
||||
interp_v3_v3v3(h1, p3d_cur, p3d_next, -BEZT_HANDLE_FAC);
|
||||
}
|
||||
|
||||
|
||||
if (i < tot - 1) {
|
||||
interp_v3_v3v3(h2, p3d_cur, p3d_next, BEZT_HANDLE_FAC);
|
||||
}
|
||||
else {
|
||||
interp_v3_v3v3(h2, p3d_cur, p3d_prev, -BEZT_HANDLE_FAC);
|
||||
}
|
||||
|
||||
|
||||
copy_v3_v3(bezt->vec[0], h1);
|
||||
copy_v3_v3(bezt->vec[1], p3d_cur);
|
||||
copy_v3_v3(bezt->vec[2], h2);
|
||||
|
||||
|
||||
/* set settings */
|
||||
bezt->h1 = bezt->h2 = HD_FREE;
|
||||
bezt->f1 = bezt->f2 = bezt->f3 = SELECT;
|
||||
|
@ -1166,23 +1179,23 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
else if (bezt->weight > minmax_weights[1]) {
|
||||
minmax_weights[1] = bezt->weight;
|
||||
}
|
||||
|
||||
|
||||
/* Update timing data */
|
||||
if (do_gtd) {
|
||||
gp_timing_data_add_point(gtd, gps->inittime, pt->time, prev_bezt ? len_v3v3(prev_bezt->vec[1], p3d_cur) : 0.0f);
|
||||
}
|
||||
|
||||
|
||||
/* shift coord vects */
|
||||
copy_v3_v3(p3d_prev, p3d_cur);
|
||||
copy_v3_v3(p3d_cur, p3d_next);
|
||||
|
||||
|
||||
if (i + 2 < tot) {
|
||||
gp_strokepoint_convertcoords(C, gps, pt + 2, p3d_next, subrect);
|
||||
}
|
||||
|
||||
|
||||
prev_bezt = bezt;
|
||||
}
|
||||
|
||||
|
||||
/* must calculate handles or else we crash */
|
||||
BKE_nurb_handles_calc(nu);
|
||||
|
||||
|
@ -1200,6 +1213,7 @@ static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Cu
|
|||
|
||||
static void gp_stroke_finalize_curve_endpoints(Curve *cu)
|
||||
{
|
||||
/* start */
|
||||
Nurb *nu = cu->nurb.first;
|
||||
int i = 0;
|
||||
if (nu->bezt) {
|
||||
|
@ -1214,7 +1228,8 @@ static void gp_stroke_finalize_curve_endpoints(Curve *cu)
|
|||
bp[i].weight = bp[i].radius = 0.0f;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* end */
|
||||
nu = cu->nurb.last;
|
||||
i = nu->pntsu - 1;
|
||||
if (nu->bezt) {
|
||||
|
@ -1237,7 +1252,7 @@ static void gp_stroke_norm_curve_weights(Curve *cu, float minmax_weights[2])
|
|||
const float delta = minmax_weights[0];
|
||||
const float fac = 1.0f / (minmax_weights[1] - delta);
|
||||
int i;
|
||||
|
||||
|
||||
for (nu = cu->nurb.first; nu; nu = nu->next) {
|
||||
if (nu->bezt) {
|
||||
BezTriple *bezt = nu->bezt;
|
||||
|
@ -1269,11 +1284,11 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
|
|||
|
||||
/* camera framing */
|
||||
rctf subrect, *subrect_ptr = NULL;
|
||||
|
||||
|
||||
/* error checking */
|
||||
if (ELEM3(NULL, gpd, gpl, gpf))
|
||||
return;
|
||||
|
||||
|
||||
/* only convert if there are any strokes on this layer's frame to convert */
|
||||
if (gpf->strokes.first == NULL)
|
||||
return;
|
||||
|
@ -1282,7 +1297,7 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
|
|||
if (gp_camera_view_subrect(C, &subrect)) {
|
||||
subrect_ptr = &subrect;
|
||||
}
|
||||
|
||||
|
||||
/* init the curve object (remove rotation and get curve data from it)
|
||||
* - must clear transforms set on object, as those skew our results
|
||||
*/
|
||||
|
@ -1291,28 +1306,34 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
|
|||
zero_v3(ob->rot);
|
||||
cu = ob->data;
|
||||
cu->flag |= CU_3D;
|
||||
|
||||
|
||||
/* rename object and curve to layer name */
|
||||
rename_id((ID *)ob, gpl->info);
|
||||
rename_id((ID *)cu, gpl->info);
|
||||
|
||||
gtd->inittime = ((bGPDstroke*)gpf->strokes.first)->inittime;
|
||||
|
||||
|
||||
gtd->inittime = ((bGPDstroke *)gpf->strokes.first)->inittime;
|
||||
|
||||
/* add points to curve */
|
||||
for (gps = gpf->strokes.first; gps; gps = gps->next) {
|
||||
/* Detect new strokes created because of GP_STROKE_BUFFER_MAX reached,
|
||||
* and stitch them to previous one.
|
||||
*/
|
||||
int stitch = FALSE;
|
||||
|
||||
if (prev_gps) {
|
||||
bGPDspoint *pt1 = prev_gps->points + prev_gps->totpoints - 1;
|
||||
bGPDspoint *pt2 = gps->points;
|
||||
if (pt1->x == pt2->x && pt1->y == pt2->y)
|
||||
|
||||
if ((pt1->x == pt2->x) && (pt1->y == pt2->y)) {
|
||||
stitch = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
/* Decide whether we connect this stroke to previous one */
|
||||
if (!(stitch || link_strokes))
|
||||
if (!(stitch || link_strokes)) {
|
||||
nu = NULL;
|
||||
}
|
||||
|
||||
switch (mode) {
|
||||
case GP_STROKECONVERT_PATH:
|
||||
gp_stroke_to_path(C, gpl, gps, cu, subrect_ptr, &nu, minmax_weights, rad_fac, stitch, gtd);
|
||||
|
@ -1332,20 +1353,25 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG
|
|||
gp_stroke_finalize_curve_endpoints(cu);
|
||||
|
||||
/* Update curve's weights, if needed */
|
||||
if (norm_weights && (minmax_weights[0] > 0.0f || minmax_weights[1] < 1.0f))
|
||||
if (norm_weights && ((minmax_weights[0] > 0.0f) || (minmax_weights[1] < 1.0f)))
|
||||
gp_stroke_norm_curve_weights(cu, minmax_weights);
|
||||
|
||||
/* Create the path animation, if needed */
|
||||
gp_stroke_path_animation(C, reports, cu, gtd);
|
||||
|
||||
/* Reset org object as active, else we can't edit operator's settings!!! */
|
||||
/* Reset original object as active, else we can't edit operator's settings!!! */
|
||||
/* set layers OK */
|
||||
newbase = BASACT;
|
||||
newbase->lay = base->lay;
|
||||
ob->lay = newbase->lay;
|
||||
if (base) {
|
||||
newbase->lay = base->lay;
|
||||
ob->lay = newbase->lay;
|
||||
}
|
||||
|
||||
/* restore, BKE_object_add sets active */
|
||||
BASACT = base;
|
||||
base->flag |= SELECT;
|
||||
if (base) {
|
||||
base->flag |= SELECT;
|
||||
}
|
||||
}
|
||||
|
||||
/* --- */
|
||||
|
@ -1361,13 +1387,14 @@ static int gp_convert_check_has_valid_timing(bContext *C, bGPDlayer *gpl, wmOper
|
|||
bGPDspoint *pt;
|
||||
double base_time, cur_time, prev_time = -1.0;
|
||||
int i, valid = TRUE;
|
||||
|
||||
|
||||
do {
|
||||
base_time = cur_time = gps->inittime;
|
||||
if (cur_time <= prev_time) {
|
||||
valid = FALSE;
|
||||
break;
|
||||
}
|
||||
|
||||
prev_time = cur_time;
|
||||
for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
|
||||
cur_time = base_time + (double)pt->time;
|
||||
|
@ -1380,11 +1407,12 @@ static int gp_convert_check_has_valid_timing(bContext *C, bGPDlayer *gpl, wmOper
|
|||
}
|
||||
prev_time = cur_time;
|
||||
}
|
||||
|
||||
if (!valid) {
|
||||
break;
|
||||
}
|
||||
} while ((gps = gps->next));
|
||||
|
||||
|
||||
if (op) {
|
||||
RNA_boolean_set(op->ptr, "use_timing_data", valid);
|
||||
}
|
||||
|
@ -1396,6 +1424,7 @@ static void gp_convert_set_end_frame(struct Main *UNUSED(main), struct Scene *UN
|
|||
{
|
||||
int start_frame = RNA_int_get(ptr, "start_frame");
|
||||
int end_frame = RNA_int_get(ptr, "end_frame");
|
||||
|
||||
if (end_frame <= start_frame) {
|
||||
RNA_int_set(ptr, "end_frame", start_frame + 1);
|
||||
}
|
||||
|
@ -1423,19 +1452,19 @@ static int gp_convert_layer_exec(bContext *C, wmOperator *op)
|
|||
int link_strokes = RNA_boolean_get(op->ptr, "use_link_strokes");
|
||||
int valid_timing;
|
||||
tGpTimingData gtd;
|
||||
|
||||
|
||||
/* check if there's data to work with */
|
||||
if (gpd == NULL) {
|
||||
BKE_report(op->reports, RPT_ERROR, "No grease pencil data to work on");
|
||||
BKE_report(op->reports, RPT_ERROR, "No Grease Pencil data to work on");
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
|
||||
if (!RNA_property_is_set(op->ptr, prop) && !gp_convert_check_has_valid_timing(C, gpl, op)) {
|
||||
BKE_report(op->reports, RPT_WARNING,
|
||||
"Current grease pencil strokes have no valid timing data, most timing options will be hidden!");
|
||||
"Current Grease Pencil strokes have no valid timing data, most timing options will be hidden!");
|
||||
}
|
||||
valid_timing = RNA_property_boolean_get(op->ptr, prop);
|
||||
|
||||
|
||||
gtd.mode = RNA_enum_get(op->ptr, "timing_mode");
|
||||
/* Check for illegal timing mode! */
|
||||
if (!valid_timing && !ELEM(gtd.mode, GP_STROKECONVERT_TIMING_NONE, GP_STROKECONVERT_TIMING_LINEAR)) {
|
||||
|
@ -1445,7 +1474,8 @@ static int gp_convert_layer_exec(bContext *C, wmOperator *op)
|
|||
if (!link_strokes) {
|
||||
gtd.mode = GP_STROKECONVERT_TIMING_NONE;
|
||||
}
|
||||
|
||||
|
||||
/* grab all relevant settings */
|
||||
gtd.frame_range = RNA_int_get(op->ptr, "frame_range");
|
||||
gtd.start_frame = RNA_int_get(op->ptr, "start_frame");
|
||||
gtd.realtime = valid_timing ? RNA_boolean_get(op->ptr, "use_realtime") : FALSE;
|
||||
|
@ -1458,13 +1488,24 @@ static int gp_convert_layer_exec(bContext *C, wmOperator *op)
|
|||
gtd.dists = gtd.times = NULL;
|
||||
gtd.tot_dist = gtd.tot_time = gtd.gap_tot_time = 0.0f;
|
||||
gtd.inittime = 0.0;
|
||||
|
||||
|
||||
/* perform conversion */
|
||||
gp_layer_to_curve(C, op->reports, gpd, gpl, mode, norm_weights, rad_fac, link_strokes, >d);
|
||||
|
||||
|
||||
/* free temp memory */
|
||||
if (gtd.dists) {
|
||||
MEM_freeN(gtd.dists);
|
||||
gtd.dists = NULL;
|
||||
}
|
||||
if (gtd.times) {
|
||||
MEM_freeN(gtd.times);
|
||||
gtd.times = NULL;
|
||||
}
|
||||
|
||||
/* notifiers */
|
||||
WM_event_add_notifier(C, NC_OBJECT | NA_ADDED, NULL);
|
||||
WM_event_add_notifier(C, NC_SCENE | ND_OB_ACTIVE, scene);
|
||||
|
||||
|
||||
/* done */
|
||||
return OPERATOR_FINISHED;
|
||||
}
|
||||
|
@ -1478,7 +1519,7 @@ static int gp_convert_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
|
|||
float gap_duration = RNA_float_get(ptr, "gap_duration");
|
||||
float gap_randomness = RNA_float_get(ptr, "gap_randomness");
|
||||
int valid_timing = RNA_boolean_get(ptr, "use_timing_data");
|
||||
|
||||
|
||||
/* Always show those props */
|
||||
if (strcmp(prop_id, "type") == 0 ||
|
||||
strcmp(prop_id, "use_normalize_weights") == 0 ||
|
||||
|
@ -1487,7 +1528,7 @@ static int gp_convert_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
|
|||
{
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/* Never show this prop */
|
||||
if (strcmp(prop_id, "use_timing_data") == 0)
|
||||
return FALSE;
|
||||
|
@ -1496,7 +1537,7 @@ static int gp_convert_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
|
|||
/* Only show when link_stroke is TRUE */
|
||||
if (strcmp(prop_id, "timing_mode") == 0)
|
||||
return TRUE;
|
||||
|
||||
|
||||
if (timing_mode != GP_STROKECONVERT_TIMING_NONE) {
|
||||
/* Only show when link_stroke is TRUE and stroke timing is enabled */
|
||||
if (strcmp(prop_id, "frame_range") == 0 ||
|
||||
|
@ -1504,26 +1545,26 @@ static int gp_convert_draw_check_prop(PointerRNA *ptr, PropertyRNA *prop)
|
|||
{
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/* Only show if we have valid timing data! */
|
||||
if (valid_timing && strcmp(prop_id, "use_realtime") == 0)
|
||||
return TRUE;
|
||||
|
||||
|
||||
/* Only show if realtime or valid_timing is FALSE! */
|
||||
if ((!realtime || !valid_timing) && strcmp(prop_id, "end_frame") == 0)
|
||||
return TRUE;
|
||||
|
||||
|
||||
if (valid_timing && timing_mode == GP_STROKECONVERT_TIMING_CUSTOMGAP) {
|
||||
/* Only show for custom gaps! */
|
||||
if (strcmp(prop_id, "gap_duration") == 0)
|
||||
return TRUE;
|
||||
|
||||
|
||||
/* Only show randomness for non-null custom gaps! */
|
||||
if (strcmp(prop_id, "gap_randomness") == 0 && gap_duration > 0.0f)
|
||||
if (strcmp(prop_id, "gap_randomness") == 0 && (gap_duration > 0.0f))
|
||||
return TRUE;
|
||||
|
||||
|
||||
/* Only show seed for randomize action! */
|
||||
if (strcmp(prop_id, "seed") == 0 && gap_duration > 0.0f && gap_randomness > 0.0f)
|
||||
if (strcmp(prop_id, "seed") == 0 && (gap_duration > 0.0f) && (gap_randomness > 0.0f))
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
@ -1565,15 +1606,18 @@ void GPENCIL_OT_convert(wmOperatorType *ot)
|
|||
|
||||
/* properties */
|
||||
ot->prop = RNA_def_enum(ot->srna, "type", prop_gpencil_convertmodes, 0, "Type", "Which type of curve to convert to");
|
||||
|
||||
RNA_def_boolean(ot->srna, "use_normalize_weights", TRUE, "Normalize Weight",
|
||||
"Normalize weight (set from stroke width)");
|
||||
RNA_def_float(ot->srna, "radius_multiplier", 1.0f, 0.0f, 1000.0f, "Radius Fac",
|
||||
"Multiplier for the points' radii (set from stroke width)", 0.0f, 10.0f);
|
||||
RNA_def_boolean(ot->srna, "use_link_strokes", TRUE, "Link Strokes",
|
||||
"Whether to link strokes with zero-radius sections of curves");
|
||||
|
||||
prop = RNA_def_enum(ot->srna, "timing_mode", prop_gpencil_convert_timingmodes, GP_STROKECONVERT_TIMING_FULL,
|
||||
"Timing Mode", "How to use timing data stored in strokes");
|
||||
RNA_def_enum_funcs(prop, rna_GPConvert_mode_items);
|
||||
|
||||
RNA_def_int(ot->srna, "frame_range", 100, 1, 10000, "Frame Range",
|
||||
"The duration of evaluation of the path control curve", 1, 1000);
|
||||
RNA_def_int(ot->srna, "start_frame", 1, 1, 100000, "Start Frame",
|
||||
|
@ -1583,16 +1627,18 @@ void GPENCIL_OT_convert(wmOperatorType *ot)
|
|||
prop = RNA_def_int(ot->srna, "end_frame", 250, 1, 100000, "End Frame",
|
||||
"The end frame of the path control curve (if Realtime is not set)", 1, 100000);
|
||||
RNA_def_property_update_runtime(prop, gp_convert_set_end_frame);
|
||||
|
||||
RNA_def_float(ot->srna, "gap_duration", 0.0f, 0.0f, 10000.0f, "Gap Duration",
|
||||
"Custom Gap mode: (Average) length of gaps, in frames "
|
||||
"(note: realtime value, will be scaled if Realtime is not set)", 0.0f, 1000.0f);
|
||||
"(Note: Realtime value, will be scaled if Realtime is not set)", 0.0f, 1000.0f);
|
||||
RNA_def_float(ot->srna, "gap_randomness", 0.0f, 0.0f, 10000.0f, "Gap Randomness",
|
||||
"Custom Gap mode: Number of frames that gap lengths can vary", 0.0f, 1000.0f);
|
||||
RNA_def_int(ot->srna, "seed", 0, 0, 1000, "Random Seed",
|
||||
"Custom Gap mode: Random generator seed", 0, 100);
|
||||
|
||||
/* Note: Internal use, this one will always be hidden by UI code... */
|
||||
prop = RNA_def_boolean(ot->srna, "use_timing_data", FALSE, "Has Valid Timing",
|
||||
"Whether the converted grease pencil layer has valid timing data (internal use)");
|
||||
"Whether the converted Grease Pencil layer has valid timing data (internal use)");
|
||||
RNA_def_property_flag(prop, PROP_SKIP_SAVE);
|
||||
}
|
||||
|
||||
|
|
|
@ -100,8 +100,8 @@ typedef struct tGPsdata {
|
|||
|
||||
short radius; /* radius of influence for eraser */
|
||||
short flags; /* flags that can get set during runtime */
|
||||
|
||||
/* Those needs 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!
|
||||
* double, with its 15 digits precision, ensures us millisecond precision for a few centuries at least.
|
||||
*/
|
||||
|
@ -110,7 +110,7 @@ typedef struct tGPsdata {
|
|||
double ocurtime; /* Used when converting to path */
|
||||
|
||||
float imat[4][4]; /* inverted transformation matrix applying when converting coords from screen-space
|
||||
* to region space */
|
||||
* to region space */
|
||||
|
||||
float custom_color[4]; /* custom color - hack for enforcing a particular color for track/mask editing */
|
||||
|
||||
|
@ -455,11 +455,13 @@ static void gp_stroke_smooth(tGPsdata *p)
|
|||
if ((cmx <= 2) || (gpd->sbuffer == NULL))
|
||||
return;
|
||||
|
||||
/* Calculate smoothing coordinates using weighted-averages */
|
||||
/* XXX DO NOT smooth first and last points! */
|
||||
/* Calculate smoothing coordinates using weighted-averages
|
||||
* WARNING: we do NOT smooth first and last points (to avoid shrinkage)
|
||||
*/
|
||||
spt = (tGPspoint *)gpd->sbuffer;
|
||||
/* This small array stores the last two points' org coordinates, we don't want to use already averaged ones!
|
||||
* Note it is used as a cyclic buffer...
|
||||
|
||||
/* This (tmp_spt) small array stores the last two points' original coordinates,
|
||||
* as we don't want to use already averaged ones! It is used as a cyclic buffer...
|
||||
*/
|
||||
tmp_spt[0] = *spt;
|
||||
for (i = 1, spt++; i < cmx - 1; i++, spt++) {
|
||||
|
@ -469,7 +471,7 @@ static void gp_stroke_smooth(tGPsdata *p)
|
|||
const tGPspoint *pd = pc + 1;
|
||||
const tGPspoint *pe = (i + 2 < cmx) ? (pc + 2) : (pd);
|
||||
|
||||
/* Store current point's org state for the two next points! */
|
||||
/* Store current point's original state for the two next points! */
|
||||
tmp_spt[i % 3] = *spt;
|
||||
|
||||
spt->x = (int)(0.1 * pa->x + 0.2 * pb->x + 0.4 * pc->x + 0.2 * pd->x + 0.1 * pe->x);
|
||||
|
@ -588,7 +590,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
|
|||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* allocate memory for a new stroke */
|
||||
gps = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
|
||||
|
||||
|
@ -600,10 +602,10 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
|
|||
|
||||
/* allocate enough memory for a continuous array for storage points */
|
||||
gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points");
|
||||
|
||||
|
||||
/* set pointer to first non-initialized point */
|
||||
pt = gps->points + (gps->totpoints - totelem);
|
||||
|
||||
|
||||
/* copy points from the buffer to the stroke */
|
||||
if (p->paintmode == GP_PAINTMODE_DRAW_STRAIGHT) {
|
||||
/* straight lines only -> only endpoints */
|
||||
|
@ -722,7 +724,7 @@ static void gp_stroke_newfrombuffer(tGPsdata *p)
|
|||
if (depth_arr)
|
||||
MEM_freeN(depth_arr);
|
||||
}
|
||||
|
||||
|
||||
/* add stroke to frame */
|
||||
BLI_addtail(&p->gpf->strokes, gps);
|
||||
gp_stroke_added_enable(p);
|
||||
|
@ -735,7 +737,7 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i)
|
|||
{
|
||||
bGPDspoint *pt_tmp = gps->points;
|
||||
bGPDstroke *gsn = NULL;
|
||||
|
||||
|
||||
/* if stroke only had two points, get rid of stroke */
|
||||
if (gps->totpoints == 2) {
|
||||
/* free stroke points, then stroke */
|
||||
|
@ -745,7 +747,7 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i)
|
|||
/* nothing left in stroke, so stop */
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/* if last segment, just remove segment from the stroke */
|
||||
else if (i == gps->totpoints - 2) {
|
||||
/* allocate new points array, and assign most of the old stroke there */
|
||||
|
@ -759,14 +761,14 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i)
|
|||
/* nothing left in stroke, so stop */
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/* if first segment, just remove segment from the stroke */
|
||||
else if (i == 0) {
|
||||
/* allocate new points array, and assign most of the old stroke there */
|
||||
gps->totpoints--;
|
||||
gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points");
|
||||
memcpy(gps->points, pt_tmp + 1, sizeof(bGPDspoint) * gps->totpoints);
|
||||
|
||||
|
||||
/* We must adjust timings!
|
||||
* Each point's timing data is a delta from stroke's inittime, so as we erase the first
|
||||
* point of the stroke, we have to offset this inittime and all remaing points' delta values.
|
||||
|
@ -777,9 +779,9 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i)
|
|||
bGPDspoint *pts;
|
||||
float delta = pt_tmp[1].time;
|
||||
int j;
|
||||
|
||||
|
||||
gps->inittime += delta;
|
||||
|
||||
|
||||
pts = gps->points;
|
||||
for (j = 0; j < gps->totpoints; j++, pts++) {
|
||||
pts->time -= delta;
|
||||
|
@ -792,7 +794,7 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i)
|
|||
/* no break here, as there might still be stuff to remove in this stroke */
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* segment occurs in 'middle' of stroke, so split */
|
||||
else {
|
||||
/* duplicate stroke, and assign 'later' data to that stroke */
|
||||
|
@ -814,15 +816,15 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i)
|
|||
bGPDspoint *pts;
|
||||
float delta = pt_tmp[i].time;
|
||||
int j;
|
||||
|
||||
|
||||
gsn->inittime += delta;
|
||||
|
||||
|
||||
pts = gsn->points;
|
||||
for (j = 0; j < gsn->totpoints; j++, pts++) {
|
||||
pts->time -= delta;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* adjust existing stroke */
|
||||
gps->totpoints = i;
|
||||
gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points");
|
||||
|
@ -844,7 +846,7 @@ static short gp_stroke_eraser_strokeinside(const int mval[], const int UNUSED(mv
|
|||
const float mval_fl[2] = {mval[0], mval[1]};
|
||||
const float screen_co_a[2] = {x0, y0};
|
||||
const float screen_co_b[2] = {x1, y1};
|
||||
|
||||
|
||||
if (edge_inside_circle(mval_fl, rad, screen_co_a, screen_co_b)) {
|
||||
return TRUE;
|
||||
}
|
||||
|
@ -904,7 +906,6 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p,
|
|||
gp_point_to_xy(p->ar, p->v2d, p->subrect, gps, gps->points, &x0, &y0);
|
||||
|
||||
/* do boundbox check first */
|
||||
|
||||
if ((!ELEM(V2D_IS_CLIPPED, x0, y0)) && BLI_rcti_isect_pt(rect, x0, y0)) {
|
||||
/* only check if point is inside */
|
||||
if (((x0 - mval[0]) * (x0 - mval[0]) + (y0 - mval[1]) * (y0 - mval[1])) <= rad * rad) {
|
||||
|
@ -922,10 +923,10 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p,
|
|||
/* get points to work with */
|
||||
pt1 = gps->points + i;
|
||||
pt2 = gps->points + i + 1;
|
||||
|
||||
|
||||
gp_point_to_xy(p->ar, p->v2d, p->subrect, gps, pt1, &x0, &y0);
|
||||
gp_point_to_xy(p->ar, p->v2d, p->subrect, gps, pt2, &x1, &y1);
|
||||
|
||||
|
||||
/* check that point segment of the boundbox of the eraser stroke */
|
||||
if (((!ELEM(V2D_IS_CLIPPED, x0, y0)) && BLI_rcti_isect_pt(rect, x0, y0)) ||
|
||||
((!ELEM(V2D_IS_CLIPPED, x1, y1)) && BLI_rcti_isect_pt(rect, x1, y1))) {
|
||||
|
@ -1033,7 +1034,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p)
|
|||
}
|
||||
}
|
||||
break;
|
||||
|
||||
|
||||
case SPACE_NODE:
|
||||
{
|
||||
/* SpaceNode *snode = curarea->spacedata.first; */
|
||||
|
@ -1554,14 +1555,14 @@ static void gpencil_draw_apply_event(wmOperator *op, wmEvent *event)
|
|||
PointerRNA itemptr;
|
||||
float mousef[2];
|
||||
int tablet = 0;
|
||||
|
||||
|
||||
/* convert from window-space to area-space mouse coordinates
|
||||
* NOTE: float to ints conversions, +1 factor is probably used to ensure a bit more accurate rounding...
|
||||
*/
|
||||
p->mval[0] = event->mval[0] + 1;
|
||||
p->mval[1] = event->mval[1] + 1;
|
||||
p->curtime = PIL_check_seconds_timer();
|
||||
|
||||
|
||||
/* handle pressure sensitivity (which is supplied by tablets) */
|
||||
if (event->custom == EVT_DATA_TABLET) {
|
||||
wmTabletData *wmtab = event->customdata;
|
||||
|
@ -1592,7 +1593,7 @@ static void gpencil_draw_apply_event(wmOperator *op, wmEvent *event)
|
|||
p->mvalo[1] = p->mval[1];
|
||||
p->opressure = p->pressure;
|
||||
p->inittime = p->ocurtime = p->curtime;
|
||||
|
||||
|
||||
/* special exception here for too high pressure values on first touch in
|
||||
* windows for some tablets, then we just skip first touch...
|
||||
*/
|
||||
|
@ -1601,7 +1602,7 @@ static void gpencil_draw_apply_event(wmOperator *op, wmEvent *event)
|
|||
}
|
||||
|
||||
RNA_float_set(&itemptr, "time", p->curtime - p->inittime);
|
||||
|
||||
|
||||
/* apply the current latest drawing point */
|
||||
gpencil_draw_apply(op, p);
|
||||
|
||||
|
@ -1754,7 +1755,7 @@ static int gpencil_area_exists(bContext *C, ScrArea *sa_test)
|
|||
static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op)
|
||||
{
|
||||
tGPsdata *p = op->customdata;
|
||||
|
||||
|
||||
/* we must check that we're still within the area that we're set up to work from
|
||||
* otherwise we could crash (see bug #20586)
|
||||
*/
|
||||
|
@ -1762,20 +1763,20 @@ static tGPsdata *gpencil_stroke_begin(bContext *C, wmOperator *op)
|
|||
printf("\t\t\tGP - wrong area execution abort!\n");
|
||||
p->status = GP_STATUS_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/* printf("\t\tGP - start stroke\n"); */
|
||||
|
||||
|
||||
/* we may need to set up paint env again if we're resuming */
|
||||
/* XXX: watch it with the paintmode! in future,
|
||||
* it'd be nice to allow changing paint-mode when in sketching-sessions */
|
||||
/* XXX: with tablet events, we may event want to check for eraser here, for nicer tablet support */
|
||||
|
||||
|
||||
if (gp_session_initdata(C, p))
|
||||
gp_paint_initstroke(p, p->paintmode);
|
||||
|
||||
|
||||
if (p->status != GP_STATUS_ERROR)
|
||||
p->status = GP_STATUS_PAINTING;
|
||||
|
||||
|
||||
return op->customdata;
|
||||
}
|
||||
|
||||
|
@ -1800,7 +1801,7 @@ static void gpencil_stroke_end(wmOperator *op)
|
|||
static int gpencil_draw_modal(bContext *C, wmOperator *op, wmEvent *event)
|
||||
{
|
||||
tGPsdata *p = op->customdata;
|
||||
int estate = OPERATOR_PASS_THROUGH; /* default exit state */
|
||||
int estate = OPERATOR_PASS_THROUGH; /* default exit state - pass through to support MMB view nav, etc. */
|
||||
|
||||
/* if (event->type == NDOF_MOTION)
|
||||
* return OPERATOR_PASS_THROUGH;
|
||||
|
@ -1814,7 +1815,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, wmEvent *event)
|
|||
* better in tools that immediately apply
|
||||
* in 3D space.
|
||||
*/
|
||||
|
||||
|
||||
/* we don't pass on key events, GP is used with key-modifiers - prevents Dkey to insert drivers */
|
||||
if (ISKEYBOARD(event->type))
|
||||
estate = OPERATOR_RUNNING_MODAL;
|
||||
|
|
Loading…
Reference in New Issue