From fd4720204399e16032574159699d5a26a250e6d5 Mon Sep 17 00:00:00 2001 From: julianeisel Date: Fri, 26 Dec 2014 20:00:52 +0100 Subject: GPencil: Picky whitespace cleanup --- source/blender/editors/gpencil/drawgpencil.c | 318 ++++++------ .../blender/editors/gpencil/editaction_gpencil.c | 164 +++---- source/blender/editors/gpencil/gpencil_edit.c | 201 ++++---- source/blender/editors/gpencil/gpencil_intern.h | 20 +- source/blender/editors/gpencil/gpencil_ops.c | 90 ++-- source/blender/editors/gpencil/gpencil_paint.c | 538 ++++++++++----------- source/blender/editors/gpencil/gpencil_undo.c | 11 +- 7 files changed, 672 insertions(+), 670 deletions(-) (limited to 'source') diff --git a/source/blender/editors/gpencil/drawgpencil.c b/source/blender/editors/gpencil/drawgpencil.c index 4af41a56e8f..174e7b609ce 100644 --- a/source/blender/editors/gpencil/drawgpencil.c +++ b/source/blender/editors/gpencil/drawgpencil.c @@ -27,6 +27,7 @@ * \ingroup edgpencil */ + #include #include #include @@ -92,15 +93,15 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn { tGPspoint *pt; int i; - + /* error checking */ if ((points == NULL) || (totpoints <= 0)) return; - + /* check if buffer can be drawn */ if (dflag & (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_ONLYV2D)) return; - + /* if drawing a single point, draw it larger */ if (totpoints == 1) { /* draw point */ @@ -113,7 +114,7 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn } else { float oldpressure = points[0].pressure; - + /* draw stroke curve */ if (G.debug & G_DEBUG) setlinestyle(2); @@ -128,13 +129,13 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn glEnd(); glLineWidth(pt->pressure * thickness); glBegin(GL_LINE_STRIP); - + /* need to roll-back one point to ensure that there are no gaps in the stroke */ if (i != 0) glVertex2iv(&(pt - 1)->x); /* now the point we want... */ glVertex2iv(&pt->x); - + oldpressure = pt->pressure; } else @@ -144,7 +145,7 @@ static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickn /* reset for predictable OpenGL context */ glLineWidth(1.0f); - + if (G.debug & G_DEBUG) setlinestyle(0); } } @@ -161,14 +162,14 @@ static void gp_calc_2d_stroke_xy(bGPDspoint *pt, short sflag, int offsx, int off else if (sflag & GP_STROKE_2DIMAGE) { const float x = (float)((pt->x * winx) + offsx); const float y = (float)((pt->y * winy) + offsy); - + r_co[0] = x; r_co[1] = y; } else { const float x = (float)(pt->x / 100 * winx) + offsx; const float y = (float)(pt->y / 100 * winy) + offsy; - + r_co[0] = x; r_co[1] = y; } @@ -184,39 +185,39 @@ static void gp_draw_stroke_volumetric_buffer(tGPspoint *points, int totpoints, s { GLUquadricObj *qobj = gluNewQuadric(); float modelview[4][4]; - + tGPspoint *pt; int i; - + /* error checking */ if ((points == NULL) || (totpoints <= 0)) return; - + /* check if buffer can be drawn */ if (dflag & (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_ONLYV2D)) return; - + /* get basic matrix - should be camera space (i.e "identity") */ glGetFloatv(GL_MODELVIEW_MATRIX, (float *)modelview); - + /* draw points */ glPushMatrix(); - + for (i = 0, pt = points; i < totpoints; i++, pt++) { /* set the transformed position */ // TODO: scale should change based on zoom level, which requires proper translation mult too! modelview[3][0] = pt->x; modelview[3][1] = pt->y; - + glLoadMatrixf((float *)modelview); - + /* draw the disk using the current state... */ gluDisk(qobj, 0.0, pt->pressure * thickness, 32, 1); - - + + modelview[3][0] = modelview[3][1] = 0.0f; } - + glPopMatrix(); gluDeleteQuadric(qobj); } @@ -230,10 +231,10 @@ static void gp_draw_stroke_volumetric_2d(bGPDspoint *points, int totpoints, shor float modelview[4][4]; float baseloc[3]; float scalefac = 1.0f; - + bGPDspoint *pt; int i; - + /* HACK: We need a scale factor for the drawing in the image editor, * which seems to use 1 unit as it's maximum size, whereas everything @@ -242,30 +243,30 @@ static void gp_draw_stroke_volumetric_2d(bGPDspoint *points, int totpoints, shor if ((dflag & GP_DRAWDATA_IEDITHACK) && (dflag & GP_DRAWDATA_ONLYV2D)) { scalefac = 0.001f; } - + /* get basic matrix */ glGetFloatv(GL_MODELVIEW_MATRIX, (float *)modelview); copy_v3_v3(baseloc, modelview[3]); - + /* draw points */ glPushMatrix(); - + for (i = 0, pt = points; i < totpoints; i++, pt++) { /* set the transformed position */ float co[2]; - + gp_calc_2d_stroke_xy(pt, sflag, offsx, offsy, winx, winy, co); translate_m4(modelview, co[0], co[1], 0.0f); - + glLoadMatrixf((float *)modelview); - + /* draw the disk using the current state... */ gluDisk(qobj, 0.0, pt->pressure * thickness * scalefac, 32, 1); - + /* restore matrix */ copy_v3_v3(modelview[3], baseloc); } - + glPopMatrix(); gluDeleteQuadric(qobj); } @@ -275,48 +276,48 @@ static void gp_draw_stroke_volumetric_3d(bGPDspoint *points, int totpoints, shor short UNUSED(dflag), short UNUSED(sflag)) { GLUquadricObj *qobj = gluNewQuadric(); - + float base_modelview[4][4], modelview[4][4]; float base_loc[3]; - + bGPDspoint *pt; int i; - + /* Get the basic modelview matrix we use for performing calculations */ glGetFloatv(GL_MODELVIEW_MATRIX, (float *)base_modelview); copy_v3_v3(base_loc, base_modelview[3]); - + /* Create the basic view-aligned billboard matrix we're going to actually draw qobj with: - * - We need to knock out the rotation so that we are + * - We need to knock out the rotation so that we are * simply left with a camera-facing billboard * - The scale factors here are chosen so that the thickness * is relatively reasonable. Otherwise, it gets far too * large! */ scale_m4_fl(modelview, 0.1f); - + /* draw each point as a disk... */ glPushMatrix(); - + for (i = 0, pt = points; i < totpoints && pt; i++, pt++) { /* apply translation to base_modelview, so that the translated point is put in the right place */ translate_m4(base_modelview, pt->x, pt->y, pt->z); - + /* copy the translation component to the billboard matrix we're going to use, * then reset the base matrix to the original values so that we can do the same * for the next point without accumulation/pollution effects */ copy_v3_v3(modelview[3], base_modelview[3]); /* copy offset value */ copy_v3_v3(base_modelview[3], base_loc); /* restore */ - + /* apply our billboard matrix for drawing... */ glLoadMatrixf((float *)modelview); - + /* draw the disk using the current state... */ gluDisk(qobj, 0.0, pt->pressure * thickness, 32, 1); } - + glPopMatrix(); gluDeleteQuadric(qobj); } @@ -331,28 +332,28 @@ static void gp_draw_stroke_fill(bGPDspoint *points, int totpoints, short UNUSED( { bGPDspoint *pt; int i; - + BLI_assert(totpoints >= 3); - - /* As an initial implementation, we use the OpenGL filled polygon drawing + + /* As an initial implementation, we use the OpenGL filled polygon drawing * here since it's the easiest option to implement for this case. It does * come with limitations (notably for concave shapes), though it shouldn't * be much of an issue in most cases. */ glBegin(GL_POLYGON); - + for (i = 0, pt = points; i < totpoints; i++, pt++) { if (sflag & GP_STROKE_3DSPACE) { glVertex3fv(&pt->x); } else { float co[2]; - + gp_calc_2d_stroke_xy(pt, sflag, offsx, offsy, winx, winy, co); glVertex2fv(co); } } - + glEnd(); } @@ -370,10 +371,10 @@ static void gp_draw_stroke_point(bGPDspoint *points, short thickness, short dfla } else { float co[2]; - + /* get coordinates of point */ gp_calc_2d_stroke_xy(points, sflag, offsx, offsy, winx, winy, co); - + /* if thickness is less than GP_DRAWTHICKNESS_SPECIAL, simple dot looks ok * - also mandatory in if Image Editor 'image-based' dot */ @@ -386,15 +387,15 @@ static void gp_draw_stroke_point(bGPDspoint *points, short thickness, short dfla } else { /* draw filled circle as is done in circf (but without the matrix push/pops which screwed things up) */ - GLUquadricObj *qobj = gluNewQuadric(); - - gluQuadricDrawStyle(qobj, GLU_FILL); - + GLUquadricObj *qobj = gluNewQuadric(); + + gluQuadricDrawStyle(qobj, GLU_FILL); + /* need to translate drawing position, but must reset after too! */ glTranslatef(co[0], co[1], 0.0); - gluDisk(qobj, 0.0, thickness, 32, 1); + gluDisk(qobj, 0.0, thickness, 32, 1); glTranslatef(-co[0], -co[1], 0.0); - + gluDeleteQuadric(qobj); } } @@ -406,7 +407,7 @@ static void gp_draw_stroke_3d(bGPDspoint *points, int totpoints, short thickness bGPDspoint *pt; float curpressure = points[0].pressure; int i; - + /* draw stroke curve */ glLineWidth(curpressure * thickness); glBegin(GL_LINE_STRIP); @@ -420,10 +421,10 @@ static void gp_draw_stroke_3d(bGPDspoint *points, int totpoints, short thickness curpressure = pt->pressure; glLineWidth(curpressure * thickness); glBegin(GL_LINE_STRIP); - + /* need to roll-back one point to ensure that there are no gaps in the stroke */ if (i != 0) glVertex3fv(&(pt - 1)->x); - + /* now the point we want... */ glVertex3fv(&pt->x); } @@ -432,7 +433,7 @@ static void gp_draw_stroke_3d(bGPDspoint *points, int totpoints, short thickness } } glEnd(); - + /* draw debug points of curve on top? */ /* XXX: for now, we represent "selected" strokes in the same way as debug, which isn't used anymore */ if (debug) { @@ -451,14 +452,13 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness { /* otherwise thickness is twice that of the 3D view */ float thickness = (float)thickness_s * 0.5f; - + /* strokes in Image Editor need a scale factor, since units there are not pixels! */ float scalefac = 1.0f; if ((dflag & GP_DRAWDATA_IEDITHACK) && (dflag & GP_DRAWDATA_ONLYV2D)) { scalefac = 0.001f; } - - + /* tessellation code - draw stroke as series of connected quads with connection * edges rotated to minimize shrinking artifacts, and rounded endcaps */ @@ -466,58 +466,58 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness bGPDspoint *pt1, *pt2; float pm[2]; int i; - + glShadeModel(GL_FLAT); glBegin(GL_QUADS); - + for (i = 0, pt1 = points, pt2 = points + 1; i < (totpoints - 1); i++, pt1++, pt2++) { float s0[2], s1[2]; /* segment 'center' points */ float t0[2], t1[2]; /* tessellated coordinates */ float m1[2], m2[2]; /* gradient and normal */ float mt[2], sc[2]; /* gradient for thickness, point for end-cap */ float pthick; /* thickness at segment point */ - + /* get x and y coordinates from points */ gp_calc_2d_stroke_xy(pt1, sflag, offsx, offsy, winx, winy, s0); gp_calc_2d_stroke_xy(pt2, sflag, offsx, offsy, winx, winy, s1); - + /* calculate gradient and normal - 'angle'=(ny/nx) */ m1[1] = s1[1] - s0[1]; m1[0] = s1[0] - s0[0]; normalize_v2(m1); m2[1] = -m1[0]; m2[0] = m1[1]; - + /* always use pressure from first point here */ pthick = (pt1->pressure * thickness * scalefac); - + /* if the first segment, start of segment is segment's normal */ if (i == 0) { - /* draw start cap first - * - make points slightly closer to center (about halfway across) + /* draw start cap first + * - make points slightly closer to center (about halfway across) */ mt[0] = m2[0] * pthick * 0.5f; mt[1] = m2[1] * pthick * 0.5f; sc[0] = s0[0] - (m1[0] * pthick * 0.75f); sc[1] = s0[1] - (m1[1] * pthick * 0.75f); - + t0[0] = sc[0] - mt[0]; t0[1] = sc[1] - mt[1]; t1[0] = sc[0] + mt[0]; t1[1] = sc[1] + mt[1]; - + glVertex2fv(t0); glVertex2fv(t1); - + /* calculate points for start of segment */ mt[0] = m2[0] * pthick; mt[1] = m2[1] * pthick; - + t0[0] = s0[0] - mt[0]; t0[1] = s0[1] - mt[1]; t1[0] = s0[0] + mt[0]; t1[1] = s0[1] + mt[1]; - + /* draw this line twice (first to finish off start cap, then for stroke) */ glVertex2fv(t1); glVertex2fv(t0); @@ -528,13 +528,13 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness else { float mb[2]; /* bisector normal */ float athick, dfac; /* actual thickness, difference between thicknesses */ - + /* calculate gradient of bisector (as average of normals) */ mb[0] = (pm[0] + m2[0]) / 2; mb[1] = (pm[1] + m2[1]) / 2; normalize_v2(mb); - - /* calculate gradient to apply + + /* calculate gradient to apply * - as basis, use just pthick * bisector gradient * - if cross-section not as thick as it should be, add extra padding to fix it */ @@ -542,79 +542,79 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness mt[1] = mb[1] * pthick; athick = len_v2(mt); dfac = pthick - (athick * 2); - + if (((athick * 2.0f) < pthick) && (IS_EQF(athick, pthick) == 0)) { mt[0] += (mb[0] * dfac); mt[1] += (mb[1] * dfac); } - + /* calculate points for start of segment */ t0[0] = s0[0] - mt[0]; t0[1] = s0[1] - mt[1]; t1[0] = s0[0] + mt[0]; t1[1] = s0[1] + mt[1]; - + /* draw this line twice (once for end of current segment, and once for start of next) */ glVertex2fv(t1); glVertex2fv(t0); glVertex2fv(t0); glVertex2fv(t1); } - + /* if last segment, also draw end of segment (defined as segment's normal) */ if (i == totpoints - 2) { /* for once, we use second point's pressure (otherwise it won't be drawn) */ pthick = (pt2->pressure * thickness * scalefac); - + /* calculate points for end of segment */ mt[0] = m2[0] * pthick; mt[1] = m2[1] * pthick; - + t0[0] = s1[0] - mt[0]; t0[1] = s1[1] - mt[1]; t1[0] = s1[0] + mt[0]; t1[1] = s1[1] + mt[1]; - + /* draw this line twice (once for end of stroke, and once for endcap)*/ glVertex2fv(t1); glVertex2fv(t0); glVertex2fv(t0); glVertex2fv(t1); - - - /* draw end cap as last step - * - make points slightly closer to center (about halfway across) + + + /* draw end cap as last step + * - make points slightly closer to center (about halfway across) */ mt[0] = m2[0] * pthick * 0.5f; mt[1] = m2[1] * pthick * 0.5f; sc[0] = s1[0] + (m1[0] * pthick * 0.75f); sc[1] = s1[1] + (m1[1] * pthick * 0.75f); - + t0[0] = sc[0] - mt[0]; t0[1] = sc[1] - mt[1]; t1[0] = sc[0] + mt[0]; t1[1] = sc[1] + mt[1]; - + glVertex2fv(t1); glVertex2fv(t0); } - + /* store stroke's 'natural' normal for next stroke to use */ copy_v2_v2(pm, m2); } - + glEnd(); } - + /* draw debug points of curve on top? (original stroke points) */ if (debug) { bGPDspoint *pt; int i; - + glBegin(GL_POINTS); for (i = 0, pt = points; i < totpoints && pt; i++, pt++) { float co[2]; - + gp_calc_2d_stroke_xy(pt, sflag, offsx, offsy, winx, winy, co); glVertex2fv(co); } @@ -633,24 +633,24 @@ static bool gp_can_draw_stroke(const bGPDstroke *gps, const int dflag) return false; if (!(dflag & GP_DRAWDATA_ONLY3D) && (gps->flag & GP_STROKE_3DSPACE)) return false; - + /* 2) Screen Space 2D Strokes */ if ((dflag & GP_DRAWDATA_ONLYV2D) && !(gps->flag & GP_STROKE_2DSPACE)) return false; if (!(dflag & GP_DRAWDATA_ONLYV2D) && (gps->flag & GP_STROKE_2DSPACE)) return false; - + /* 3) Image Space (2D) */ if ((dflag & GP_DRAWDATA_ONLYI2D) && !(gps->flag & GP_STROKE_2DIMAGE)) return false; if (!(dflag & GP_DRAWDATA_ONLYI2D) && (gps->flag & GP_STROKE_2DIMAGE)) return false; - - + + /* skip stroke if it doesn't have any valid data */ if ((gps->points == NULL) || (gps->totpoints < 1)) return false; - + /* stroke can be drawn */ return true; } @@ -660,22 +660,22 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int bool debug, short lthick, const float color[4], const float fill_color[4]) { bGPDstroke *gps; - + for (gps = gpf->strokes.first; gps; gps = gps->next) { /* check if stroke can be drawn */ if (gp_can_draw_stroke(gps, dflag) == false) continue; - + /* check which stroke-drawer to use */ if (dflag & GP_DRAWDATA_ONLY3D) { const int no_xray = (dflag & GP_DRAWDATA_NO_XRAY); int mask_orig = 0; - + if (no_xray) { glGetIntegerv(GL_DEPTH_WRITEMASK, &mask_orig); glDepthMask(0); glEnable(GL_DEPTH_TEST); - + /* first arg is normally rv3d->dist, but this isn't * available here and seems to work quite well without */ bglPolygonOffset(1.0f, 1.0f); @@ -684,16 +684,16 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int glPolygonOffset(-1.0f, -1.0f); #endif } - + /* 3D Fill */ if ((dflag & GP_DRAWDATA_FILL) && (gps->totpoints >= 3)) { glColor4fv(fill_color); gp_draw_stroke_fill(gps->points, gps->totpoints, lthick, dflag, gps->flag, offsx, offsy, winx, winy); } - + /* 3D Stroke */ glColor4fv(color); - + if (dflag & GP_DRAWDATA_VOLUMETRIC) { /* volumetric stroke drawing */ gp_draw_stroke_volumetric_3d(gps->points, gps->totpoints, lthick, dflag, gps->flag); @@ -707,11 +707,11 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int gp_draw_stroke_3d(gps->points, gps->totpoints, lthick, debug, gps->flag); } } - + if (no_xray) { glDepthMask(mask_orig); glDisable(GL_DEPTH_TEST); - + bglPolygonOffset(0.0, 0.0); #if 0 glDisable(GL_POLYGON_OFFSET_LINE); @@ -725,10 +725,10 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int glColor4fv(fill_color); gp_draw_stroke_fill(gps->points, gps->totpoints, lthick, dflag, gps->flag, offsx, offsy, winx, winy); } - + /* 2D Strokes... */ glColor4fv(color); - + if (dflag & GP_DRAWDATA_VOLUMETRIC) { /* blob/disk-based "volumetric" drawing */ gp_draw_stroke_volumetric_2d(gps->points, gps->totpoints, lthick, dflag, gps->flag, offsx, offsy, winx, winy); @@ -750,17 +750,17 @@ static void gp_draw_strokes(bGPDframe *gpf, int offsx, int offsy, int winx, int static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx, int winy, short dflag, const float tcolor[3]) { bGPDstroke *gps; - + const int no_xray = (dflag & GP_DRAWDATA_NO_XRAY); int mask_orig = 0; - + /* set up depth masks... */ if (dflag & GP_DRAWDATA_ONLY3D) { if (no_xray) { glGetIntegerv(GL_DEPTH_WRITEMASK, &mask_orig); glDepthMask(0); glEnable(GL_DEPTH_TEST); - + /* first arg is normally rv3d->dist, but this isn't * available here and seems to work quite well without */ bglPolygonOffset(1.0f, 1.0f); @@ -770,25 +770,25 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx, #endif } } - - + + /* draw stroke verts */ for (gps = gpf->strokes.first; gps; gps = gps->next) { bGPDspoint *pt; float vsize, bsize; int i; - + /* check if stroke can be drawn */ if (gp_can_draw_stroke(gps, dflag) == false) continue; - + /* Optimisation: only draw points for selected strokes * We assume that selected points can only occur in * strokes that are selected too. */ if ((gps->flag & GP_STROKE_SELECT) == 0) continue; - + /* Get size of verts: * - The selected state needs to be larger than the unselected state so that * they stand out more. @@ -802,7 +802,7 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx, else { vsize = bsize + 2; } - + /* First Pass: Draw all the verts (i.e. these become the unselected state) */ if (tcolor != NULL) { /* for now, we assume that the base color of the points is not too close to the real color */ @@ -813,7 +813,7 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx, UI_ThemeColor(TH_VERTEX); } glPointSize(bsize); - + glBegin(GL_POINTS); for (i = 0, pt = gps->points; i < gps->totpoints && pt; i++, pt++) { if (gps->flag & GP_STROKE_3DSPACE) { @@ -821,18 +821,18 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx, } else { float co[2]; - + gp_calc_2d_stroke_xy(pt, gps->flag, offsx, offsy, winx, winy, co); glVertex2fv(co); } } glEnd(); - - + + /* Second Pass: Draw only verts which are selected */ UI_ThemeColor(TH_VERTEX_SELECT); glPointSize(vsize); - + glBegin(GL_POINTS); for (i = 0, pt = gps->points; i < gps->totpoints && pt; i++, pt++) { if (pt->flag & GP_SPOINT_SELECT) { @@ -841,7 +841,7 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx, } else { float co[2]; - + gp_calc_2d_stroke_xy(pt, gps->flag, offsx, offsy, winx, winy, co); glVertex2fv(co); } @@ -849,14 +849,14 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx, } glEnd(); } - - + + /* clear depth mask */ if (dflag & GP_DRAWDATA_ONLY3D) { if (no_xray) { glDepthMask(mask_orig); glDisable(GL_DEPTH_TEST); - + bglPolygonOffset(0.0, 0.0); #if 0 glDisable(GL_POLYGON_OFFSET_LINE); @@ -869,12 +869,12 @@ static void gp_draw_strokes_edit(bGPDframe *gpf, int offsx, int offsy, int winx, /* ----- General Drawing ------ */ /* draw onion-skinning for a layer */ -static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int offsy, int winx, int winy, +static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int offsy, int winx, int winy, int UNUSED(cfra), int dflag, short debug, short lthick) { const float alpha = gpl->color[3]; float color[4]; - + /* 1) Draw Previous Frames First */ if (gpl->flag & GP_LAYER_GHOST_PREVCOL) { copy_v3_v3(color, gpl->gcolor_prev); @@ -882,11 +882,11 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of else { copy_v3_v3(color, gpl->color); } - + if (gpl->gstep) { bGPDframe *gf; float fac; - + /* draw previous frames first */ for (gf = gpf->prev; gf; gf = gf->prev) { /* check if frame is drawable */ @@ -896,7 +896,7 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of color[3] = alpha * fac * 0.66f; gp_draw_strokes(gf, offsx, offsy, winx, winy, dflag, debug, lthick, color, color); } - else + else break; } } @@ -907,8 +907,8 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of gp_draw_strokes(gpf->prev, offsx, offsy, winx, winy, dflag, debug, lthick, color, color); } } - - + + /* 2) Now draw next frames */ if (gpl->flag & GP_LAYER_GHOST_NEXTCOL) { copy_v3_v3(color, gpl->gcolor_next); @@ -916,11 +916,11 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of else { copy_v3_v3(color, gpl->color); } - + if (gpl->gstep_next) { bGPDframe *gf; float fac; - + /* now draw next frames */ for (gf = gpf->next; gf; gf = gf->next) { /* check if frame is drawable */ @@ -930,7 +930,7 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of color[3] = alpha * fac * 0.66f; gp_draw_strokes(gf, offsx, offsy, winx, winy, dflag, debug, lthick, color, color); } - else + else break; } } @@ -941,7 +941,7 @@ static void gp_draw_onionskins(bGPDlayer *gpl, bGPDframe *gpf, int offsx, int of gp_draw_strokes(gpf->next, offsx, offsy, winx, winy, dflag, debug, lthick, color, color); } } - + /* 3) restore alpha */ glColor4fv(gpl->color); } @@ -1075,7 +1075,7 @@ static void gp_draw_data(bGPdata *gpd, int offsx, int offsy, int winx, int winy, /* if we have strokes for scenes (3d view)/clips (movie clip editor) * and objects/tracks, multiple data blocks have to be drawn */ static void gp_draw_data_all(Scene *scene, bGPdata *gpd, int offsx, int offsy, int winx, int winy, - int cfra, int dflag, const char spacetype) + int cfra, int dflag, const char spacetype) { bGPdata *gpd_source = NULL; @@ -1117,25 +1117,25 @@ void ED_gpencil_draw_2dimage(const bContext *C) bGPdata *gpd; int offsx, offsy, sizex, sizey; int dflag = GP_DRAWDATA_NOSTATUS; - + gpd = ED_gpencil_data_get_active(C); // XXX if (gpd == NULL) return; - + /* calculate rect */ switch (sa->spacetype) { case SPACE_IMAGE: /* image */ case SPACE_CLIP: /* clip */ { - + /* just draw using standard scaling (settings here are currently ignored anyways) */ /* FIXME: the opengl poly-strokes don't draw at right thickness when done this way, so disabled */ offsx = 0; offsy = 0; sizex = ar->winx; sizey = ar->winy; - + wmOrtho2(ar->v2d.cur.xmin, ar->v2d.cur.xmax, ar->v2d.cur.ymin, ar->v2d.cur.ymax); - + dflag |= GP_DRAWDATA_ONLYV2D | GP_DRAWDATA_IEDITHACK; break; } @@ -1146,9 +1146,9 @@ void ED_gpencil_draw_2dimage(const bContext *C) offsy = 0; sizex = ar->winx; sizey = ar->winy; - - /* NOTE: I2D was used in 2.4x, but the old settings for that have been deprecated - * and everything moved to standard View2d + + /* NOTE: I2D was used in 2.4x, but the old settings for that have been deprecated + * and everything moved to standard View2d */ dflag |= GP_DRAWDATA_ONLYV2D; break; @@ -1158,17 +1158,17 @@ void ED_gpencil_draw_2dimage(const bContext *C) offsy = 0; sizex = ar->winx; sizey = ar->winy; - + dflag |= GP_DRAWDATA_ONLYI2D; break; } - - + + /* draw it! */ gp_draw_data_all(scene, gpd, offsx, offsy, sizex, sizey, CFRA, dflag, sa->spacetype); } -/* draw grease-pencil sketches to specified 2d-view assuming that matrices are already set correctly +/* draw grease-pencil sketches to specified 2d-view assuming that matrices are already set correctly * Note: this gets called twice - first time with onlyv2d=1 to draw 'canvas' strokes, * second time with onlyv2d=0 for screen-aligned strokes */ void ED_gpencil_draw_view2d(const bContext *C, bool onlyv2d) @@ -1178,23 +1178,23 @@ void ED_gpencil_draw_view2d(const bContext *C, bool onlyv2d) Scene *scene = CTX_data_scene(C); bGPdata *gpd; int dflag = 0; - + /* check that we have grease-pencil stuff to draw */ if (sa == NULL) return; gpd = ED_gpencil_data_get_active(C); // XXX if (gpd == NULL) return; - + /* special hack for Image Editor */ /* FIXME: the opengl poly-strokes don't draw at right thickness when done this way, so disabled */ if (ELEM(sa->spacetype, SPACE_IMAGE, SPACE_CLIP)) dflag |= GP_DRAWDATA_IEDITHACK; - + /* draw it! */ if (onlyv2d) dflag |= (GP_DRAWDATA_ONLYV2D | GP_DRAWDATA_NOSTATUS); gp_draw_data_all(scene, gpd, 0, 0, ar->winx, ar->winy, CFRA, dflag, sa->spacetype); } -/* draw grease-pencil sketches to specified 3d-view assuming that matrices are already set correctly +/* draw grease-pencil sketches to specified 3d-view assuming that matrices are already set correctly * Note: this gets called twice - first time with only3d=1 to draw 3d-strokes, * second time with only3d=0 for screen-aligned strokes */ void ED_gpencil_draw_view3d(Scene *scene, View3D *v3d, ARegion *ar, bool only3d) @@ -1225,7 +1225,7 @@ void ED_gpencil_draw_view3d(Scene *scene, View3D *v3d, ARegion *ar, bool only3d) winx = ar->winx; winy = ar->winy; } - + /* draw it! */ if (only3d) dflag |= (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_NOSTATUS); diff --git a/source/blender/editors/gpencil/editaction_gpencil.c b/source/blender/editors/gpencil/editaction_gpencil.c index 73b2b033e24..edef9a392d5 100644 --- a/source/blender/editors/gpencil/editaction_gpencil.c +++ b/source/blender/editors/gpencil/editaction_gpencil.c @@ -27,7 +27,7 @@ * \ingroup edgpencil */ - + #include #include #include @@ -62,18 +62,18 @@ bool ED_gplayer_frames_looper(bGPDlayer *gpl, Scene *scene, short (*gpf_cb)(bGPDframe *, Scene *)) { bGPDframe *gpf; - + /* error checker */ if (gpl == NULL) return false; - + /* do loop */ for (gpf = gpl->frames.first; gpf; gpf = gpf->next) { /* execute callback */ if (gpf_cb(gpf, scene)) return true; } - + /* nothing to return */ return false; } @@ -86,19 +86,19 @@ void ED_gplayer_make_cfra_list(bGPDlayer *gpl, ListBase *elems, bool onlysel) { bGPDframe *gpf; CfraElem *ce; - + /* error checking */ if (ELEM(NULL, gpl, elems)) return; - + /* loop through gp-frames, adding */ for (gpf = gpl->frames.first; gpf; gpf = gpf->next) { if ((onlysel == 0) || (gpf->flag & GP_FRAME_SELECT)) { ce = MEM_callocN(sizeof(CfraElem), "CfraElem"); - + ce->cfra = (float)gpf->framenum; ce->sel = (gpf->flag & GP_FRAME_SELECT) ? 1 : 0; - + BLI_addtail(elems, ce); } } @@ -111,17 +111,17 @@ void ED_gplayer_make_cfra_list(bGPDlayer *gpl, ListBase *elems, bool onlysel) bool ED_gplayer_frame_select_check(bGPDlayer *gpl) { bGPDframe *gpf; - + /* error checking */ - if (gpl == NULL) + if (gpl == NULL) return false; - + /* stop at the first one found */ for (gpf = gpl->frames.first; gpf; gpf = gpf->next) { if (gpf->flag & GP_FRAME_SELECT) return true; } - + /* not found */ return false; } @@ -131,7 +131,7 @@ static void gpframe_select(bGPDframe *gpf, short select_mode) { if (gpf == NULL) return; - + switch (select_mode) { case SELECT_ADD: gpf->flag |= GP_FRAME_SELECT; @@ -149,11 +149,11 @@ static void gpframe_select(bGPDframe *gpf, short select_mode) void ED_gpencil_select_frames(bGPDlayer *gpl, short select_mode) { bGPDframe *gpf; - + /* error checking */ - if (gpl == NULL) + if (gpl == NULL) return; - + /* handle according to mode */ for (gpf = gpl->frames.first; gpf; gpf = gpf->next) { gpframe_select(gpf, select_mode); @@ -164,9 +164,9 @@ void ED_gpencil_select_frames(bGPDlayer *gpl, short select_mode) void ED_gplayer_frame_select_set(bGPDlayer *gpl, short mode) { /* error checking */ - if (gpl == NULL) + if (gpl == NULL) return; - + /* now call the standard function */ ED_gpencil_select_frames(gpl, mode); } @@ -175,8 +175,8 @@ void ED_gplayer_frame_select_set(bGPDlayer *gpl, short mode) void ED_gpencil_select_frame(bGPDlayer *gpl, int selx, short select_mode) { bGPDframe *gpf; - - if (gpl == NULL) + + if (gpl == NULL) return; gpf = BKE_gpencil_layer_find_frame(gpl, selx); @@ -190,10 +190,10 @@ void ED_gpencil_select_frame(bGPDlayer *gpl, int selx, short select_mode) void ED_gplayer_frames_select_border(bGPDlayer *gpl, float min, float max, short select_mode) { bGPDframe *gpf; - + if (gpl == NULL) return; - + /* only select those frames which are in bounds */ for (gpf = gpl->frames.first; gpf; gpf = gpf->next) { if (IN_RANGE(gpf->framenum, min, max)) @@ -209,15 +209,15 @@ bool ED_gplayer_frames_delete(bGPDlayer *gpl) { bGPDframe *gpf, *gpfn; bool changed = false; - + /* error checking */ if (gpl == NULL) return false; - + /* check for frames to delete */ for (gpf = gpl->frames.first; gpf; gpf = gpfn) { gpfn = gpf->next; - + if (gpf->flag & GP_FRAME_SELECT) changed |= gpencil_layer_delframe(gpl, gpf); } @@ -229,38 +229,38 @@ bool ED_gplayer_frames_delete(bGPDlayer *gpl) void ED_gplayer_frames_duplicate(bGPDlayer *gpl) { bGPDframe *gpf, *gpfn; - + /* error checking */ if (gpl == NULL) return; - + /* duplicate selected frames */ for (gpf = gpl->frames.first; gpf; gpf = gpfn) { gpfn = gpf->next; - + /* duplicate this frame */ if (gpf->flag & GP_FRAME_SELECT) { - bGPDframe *gpfd; - + bGPDframe *gpfd; + /* duplicate frame, and deselect self */ gpfd = gpencil_frame_duplicate(gpf); gpf->flag &= ~GP_FRAME_SELECT; - + BLI_insertlinkafter(&gpl->frames, gpf, gpfd); } } } -/* Set keyframe type for selected frames from given gp-layer +/* Set keyframe type for selected frames from given gp-layer * \param type The type of keyframe (eBezTriple_KeyframeType) to set selected frames to */ void ED_gplayer_frames_keytype_set(bGPDlayer *gpl, short type) { bGPDframe *gpf; - + if (gpl == NULL) return; - + for (gpf = gpl->frames.first; gpf; gpf = gpf->next) { if (gpf->flag & GP_FRAME_SELECT) { gpf->key_type = type; @@ -278,7 +278,7 @@ void ED_gplayer_frames_keytype_set(bGPDlayer *gpl, short type) * the current frame and the 'first keyframe' (i.e. the earliest one in all channels). * - The earliest frame is calculated per copy operation. */ - + /* globals for copy/paste data (like for other copy/paste buffers) */ ListBase gpcopybuf = {NULL, NULL}; static int gpcopy_firstframe = 999999999; @@ -286,8 +286,8 @@ static int gpcopy_firstframe = 999999999; /* This function frees any MEM_calloc'ed copy/paste buffer data */ void free_gpcopybuf() { - free_gpencil_layers(&gpcopybuf); - + free_gpencil_layers(&gpcopybuf); + BLI_listbase_clear(&gpcopybuf); gpcopy_firstframe = 999999999; } @@ -302,33 +302,33 @@ void copy_gpdata() int filter; void *data; short datatype; - + /* clear buffer first */ free_gpcopybuf(); - + /* get data */ data = get_action_context(&datatype); if (data == NULL) return; if (datatype != ACTCONT_GPENCIL) return; - + /* filter data */ filter = (ACTFILTER_VISIBLE | ACTFILTER_SEL); actdata_filter(&act_data, filter, data, datatype); - + /* assume that each of these is an ipo-block */ for (ale = act_data.first; ale; ale = ale->next) { bGPDlayer *gpls, *gpln; bGPDframe *gpf, *gpfn; - + /* get new layer to put into buffer */ gpls = (bGPDlayer *)ale->data; gpln = MEM_callocN(sizeof(bGPDlayer), "GPCopyPasteLayer"); - + BLI_listbase_clear(&gpln->frames); BLI_strncpy(gpln->info, gpls->info, sizeof(gpln->info)); - + BLI_addtail(&gpcopybuf, gpln); - + /* loop over frames, and copy only selected frames */ for (gpf = gpls->frames.first; gpf; gpf = gpf->next) { /* if frame is selected, make duplicate it and its strokes */ @@ -336,18 +336,18 @@ void copy_gpdata() /* add frame to buffer */ gpfn = gpencil_frame_duplicate(gpf); BLI_addtail(&gpln->frames, gpfn); - + /* check if this is the earliest frame encountered so far */ if (gpf->framenum < gpcopy_firstframe) gpcopy_firstframe = gpf->framenum; } } } - + /* check if anything ended up in the buffer */ if (ELEM(NULL, gpcopybuf.first, gpcopybuf.last)) error("Nothing copied to buffer"); - + /* free temp memory */ BLI_freelistN(&act_data); } @@ -359,10 +359,10 @@ void paste_gpdata(Scene *scene) int filter; void *data; short datatype; - + const int offset = (CFRA - gpcopy_firstframe); short no_name = 0; - + /* check if buffer is empty */ if (ELEM(NULL, gpcopybuf.first, gpcopybuf.last)) { error("No data in buffer to paste"); @@ -371,60 +371,60 @@ void paste_gpdata(Scene *scene) /* check if single channel in buffer (disregard names if so) */ if (gpcopybuf.first == gpcopybuf.last) no_name = 1; - + /* get data */ data = get_action_context(&datatype); if (data == NULL) return; if (datatype != ACTCONT_GPENCIL) return; - + /* filter data */ filter = (ACTFILTER_VISIBLE | ACTFILTER_SEL | ACTFILTER_FOREDIT); actdata_filter(&act_data, filter, data, datatype); - + /* from selected channels */ for (ale = act_data.first; ale; ale = ale->next) { bGPDlayer *gpld = (bGPDlayer *)ale->data; bGPDlayer *gpls = NULL; bGPDframe *gpfs, *gpf; - + /* find suitable layer from buffer to use to paste from */ for (gpls = gpcopybuf.first; gpls; gpls = gpls->next) { /* check if layer name matches */ if ((no_name) || (strcmp(gpls->info, gpld->info) == 0)) break; } - + /* this situation might occur! */ if (gpls == NULL) continue; - + /* add frames from buffer */ for (gpfs = gpls->frames.first; gpfs; gpfs = gpfs->next) { /* temporarily apply offset to buffer-frame while copying */ gpfs->framenum += offset; - + /* get frame to copy data into (if no frame returned, then just ignore) */ gpf = gpencil_layer_getframe(gpld, gpfs->framenum, 1); if (gpf) { bGPDstroke *gps, *gpsn; ScrArea *sa; - + /* get area that gp-data comes from */ //sa = gpencil_data_findowner((bGPdata *)ale->owner); sa = NULL; - - /* this should be the right frame... as it may be a pre-existing frame, - * must make sure that only compatible stroke types get copied over + + /* this should be the right frame... as it may be a pre-existing frame, + * must make sure that only compatible stroke types get copied over * - we cannot just add a duplicate frame, as that would cause errors * - need to check for compatible types to minimize memory usage (copying 'junk' over) */ for (gps = gpfs->strokes.first; gps; gps = gps->next) { short stroke_ok; - + /* if there's an area, check that it supports this type of stroke */ if (sa) { stroke_ok = 0; - + /* check if spacetype supports this type of stroke * - NOTE: must sync this with gp_paint_initstroke() in gpencil.c */ @@ -433,14 +433,14 @@ void paste_gpdata(Scene *scene) if ((gps->flag == 0) || (gps->flag & GP_STROKE_3DSPACE)) stroke_ok = 1; break; - + case SPACE_NODE: /* Nodes Editor: either screen-aligned or view-aligned */ case SPACE_IMAGE: /* Image Editor: either screen-aligned or view\image-aligned */ case SPACE_CLIP: /* Image Editor: either screen-aligned or view\image-aligned */ if ((gps->flag == 0) || (gps->flag & GP_STROKE_2DSPACE)) stroke_ok = 1; break; - + case SPACE_SEQ: /* Sequence Editor: either screen-aligned or view-aligned */ if ((gps->flag == 0) || (gps->flag & GP_STROKE_2DIMAGE)) stroke_ok = 1; @@ -449,31 +449,31 @@ void paste_gpdata(Scene *scene) } else stroke_ok = 1; - + /* if stroke is ok, we make a copy of this stroke and add to frame */ if (stroke_ok) { /* make a copy of stroke, then of its points array */ gpsn = MEM_dupallocN(gps); gpsn->points = MEM_dupallocN(gps->points); - + /* append stroke to frame */ BLI_addtail(&gpf->strokes, gpsn); } } - + /* if no strokes (i.e. new frame) added, free gpf */ if (BLI_listbase_is_empty(&gpf->strokes)) gpencil_layer_delframe(gpld, gpf); } - + /* unapply offset from buffer-frame */ gpfs->framenum -= offset; } } - + /* free temp memory */ BLI_freelistN(&act_data); - + /* undo and redraw stuff */ BIF_undo_push("Paste Grease Pencil Frames"); } @@ -541,36 +541,36 @@ void ED_gplayer_snap_frames(bGPDlayer *gpl, Scene *scene, short mode) static short mirror_gpf_cframe(bGPDframe *gpf, Scene *scene) { int diff; - + if (gpf->flag & GP_FRAME_SELECT) { diff = CFRA - gpf->framenum; gpf->framenum = CFRA; } - + return 0; } static short mirror_gpf_yaxis(bGPDframe *gpf, Scene *scene) { int diff; - + if (gpf->flag & GP_FRAME_SELECT) { diff = -gpf->framenum; gpf->framenum = diff; } - + return 0; } static short mirror_gpf_xaxis(bGPDframe *gpf, Scene *scene) { int diff; - + if (gpf->flag & GP_FRAME_SELECT) { diff = -gpf->framenum; gpf->framenum = diff; } - + return 0; } @@ -579,15 +579,15 @@ static short mirror_gpf_marker(bGPDframe *gpf, Scene *scene) static TimeMarker *marker; static short initialized = 0; int diff; - + /* In order for this mirror function to work without * any extra arguments being added, we use the case - * of bezt==NULL to denote that we should find the + * of bezt==NULL to denote that we should find the * marker to mirror over. The static pointer is safe - * to use this way, as it will be set to null after + * to use this way, as it will be set to null after * each cycle in which this is called. */ - + if (gpf) { /* mirroring time */ if ((gpf->flag & GP_FRAME_SELECT) && (marker)) { @@ -610,7 +610,7 @@ static short mirror_gpf_marker(bGPDframe *gpf, Scene *scene) } } } - + return 0; } diff --git a/source/blender/editors/gpencil/gpencil_edit.c b/source/blender/editors/gpencil/gpencil_edit.c index 63f34917a4d..402174437e9 100644 --- a/source/blender/editors/gpencil/gpencil_edit.c +++ b/source/blender/editors/gpencil/gpencil_edit.c @@ -27,6 +27,7 @@ * \ingroup edgpencil */ + #include #include #include @@ -96,7 +97,7 @@ bGPdata **ED_gpencil_data_get_pointers_direct(ID *screen_id, Scene *scene, ScrAr */ if (sa) { SpaceLink *sl = sa->spacedata.first; - + switch (sa->spacetype) { case SPACE_VIEW3D: /* 3D-View */ case SPACE_TIME: /* Timeline - XXX: this is a hack to get it to show GP keyframes for 3D view */ @@ -106,7 +107,7 @@ bGPdata **ED_gpencil_data_get_pointers_direct(ID *screen_id, Scene *scene, ScrAr if (scene->toolsettings->gpencil_src == GP_TOOL_SOURCE_OBJECT) { /* legacy behaviour for usage with old addons requiring object-linked to objects */ - + /* just in case no active/selected object... */ if (ob && (ob->flag & SELECT)) { /* for now, as long as there's an object, default to using that in 3D-View */ @@ -196,7 +197,7 @@ bGPdata **ED_gpencil_data_get_pointers(const bContext *C, PointerRNA *ptr) Scene *scene = CTX_data_scene(C); ScrArea *sa = CTX_wm_area(C); Object *ob = CTX_data_active_object(C); - + return ED_gpencil_data_get_pointers_direct(screen_id, scene, sa, ob, ptr); } @@ -247,7 +248,7 @@ static int gp_active_layer_poll(bContext *C) { bGPdata *gpd = ED_gpencil_data_get_active(C); bGPDlayer *gpl = gpencil_layer_getactive(gpd); - + return (gpl != NULL); } @@ -319,7 +320,7 @@ static int gp_data_unlink_exec(bContext *C, wmOperator *op) } /* notifiers */ - WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL); + WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL); return OPERATOR_FINISHED; } @@ -367,9 +368,9 @@ void GPENCIL_OT_layer_add(wmOperatorType *ot) ot->name = "Add New Layer"; ot->idname = "GPENCIL_OT_layer_add"; ot->description = "Add new Grease Pencil layer for the active Grease Pencil datablock"; - + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; - + /* callbacks */ ot->exec = gp_layer_add_exec; ot->poll = gp_add_poll; @@ -381,17 +382,17 @@ static int gp_layer_remove_exec(bContext *C, wmOperator *op) { bGPdata *gpd = ED_gpencil_data_get_active(C); bGPDlayer *gpl = gpencil_layer_getactive(gpd); - + /* sanity checks */ if (ELEM(NULL, gpd, gpl)) return OPERATOR_CANCELLED; - + if (gpl->flag & GP_LAYER_LOCKED) { BKE_report(op->reports, RPT_ERROR, "Cannot delete locked layers"); return OPERATOR_CANCELLED; - } - - /* make the layer before this the new active layer + } + + /* make the layer before this the new active layer * - use the one after if this is the first * - if this is the only layer, this naturally becomes NULL */ @@ -399,13 +400,13 @@ static int gp_layer_remove_exec(bContext *C, wmOperator *op) gpencil_layer_setactive(gpd, gpl->prev); else gpencil_layer_setactive(gpd, gpl->next); - + /* delete the layer now... */ gpencil_layer_delete(gpd, gpl); - + /* notifiers */ WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL); - + return OPERATOR_FINISHED; } @@ -415,9 +416,9 @@ void GPENCIL_OT_layer_remove(wmOperatorType *ot) ot->name = "Remove Layer"; ot->idname = "GPENCIL_OT_layer_remove"; ot->description = "Remove active Grease Pencil layer"; - + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; - + /* callbacks */ ot->exec = gp_layer_remove_exec; ot->poll = gp_active_layer_poll; @@ -434,13 +435,13 @@ static int gp_layer_move_exec(bContext *C, wmOperator *op) { bGPdata *gpd = ED_gpencil_data_get_active(C); bGPDlayer *gpl = gpencil_layer_getactive(gpd); - + int direction = RNA_enum_get(op->ptr, "type"); - + /* sanity checks */ if (ELEM(NULL, gpd, gpl)) return OPERATOR_CANCELLED; - + /* up or down? */ if (direction == GP_LAYER_MOVE_UP) { /* up */ @@ -452,10 +453,10 @@ static int gp_layer_move_exec(bContext *C, wmOperator *op) BLI_remlink(&gpd->layers, gpl); BLI_insertlinkafter(&gpd->layers, gpl->next, gpl); } - + /* notifiers */ WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL); - + return OPERATOR_FINISHED; } @@ -499,10 +500,10 @@ static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes) { bGPDspoint *pt; int i; - + int start_idx = -1; - - + + /* Step through the original stroke's points: * - We accumulate selected points (from start_idx to current index) * and then convert that to a new stroke @@ -517,8 +518,8 @@ static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes) } else { size_t len = 0; - - /* is this the end of current island yet? + + /* is this the end of current island yet? * 1) Point i-1 was the last one that was selected * 2) Point i is the last in the array */ @@ -529,23 +530,23 @@ static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes) len = i - start_idx + 1; } //printf("copying from %d to %d = %d\n", start_idx, i, len); - + /* make copies of the relevant data */ if (len) { bGPDstroke *gpsd; - + /* make a stupid copy first of the entire stroke (to get the flags too) */ gpsd = MEM_dupallocN(gps); - + /* now, make a new points array, and copy of the relevant parts */ gpsd->points = MEM_callocN(sizeof(bGPDspoint) * len, "gps stroke points copy"); memcpy(gpsd->points, gps->points + start_idx, sizeof(bGPDspoint) * len); gpsd->totpoints = len; - + /* add to temp buffer */ gpsd->next = gpsd->prev = NULL; BLI_addtail(new_strokes, gpsd); - + /* cleanup + reset for next */ start_idx = -1; } @@ -556,12 +557,12 @@ static void gp_duplicate_points(const bGPDstroke *gps, ListBase *new_strokes) static int gp_duplicate_exec(bContext *C, wmOperator *op) { bGPdata *gpd = ED_gpencil_data_get_active(C); - + if (gpd == NULL) { BKE_report(op->reports, RPT_ERROR, "No Grease Pencil data"); return OPERATOR_CANCELLED; } - + /* for each visible (and editable) layer's selected strokes, * copy the strokes into a temporary buffer, then append * once all done @@ -571,21 +572,21 @@ static int gp_duplicate_exec(bContext *C, wmOperator *op) ListBase new_strokes = {NULL, NULL}; bGPDframe *gpf = gpl->actframe; bGPDstroke *gps; - + if (gpf == NULL) continue; - + /* make copies of selected strokes, and deselect these once we're done */ for (gps = gpf->strokes.first; gps; gps = gps->next) { if (gps->flag & GP_STROKE_SELECT) { if (gps->totpoints == 1) { /* Special Case: If there's just a single point in this stroke... */ bGPDstroke *gpsd; - + /* make direct copies of the stroke and its points */ gpsd = MEM_dupallocN(gps); gpsd->points = MEM_dupallocN(gps->points); - + /* add to temp buffer */ gpsd->next = gpsd->prev = NULL; BLI_addtail(&new_strokes, gpsd); @@ -594,23 +595,23 @@ static int gp_duplicate_exec(bContext *C, wmOperator *op) /* delegate to a helper, as there's too much to fit in here (for copying subsets)... */ gp_duplicate_points(gps, &new_strokes); } - - /* deselect original stroke, or else the originals get moved too + + /* deselect original stroke, or else the originals get moved too * (when using the copy + move macro) */ gps->flag &= ~GP_STROKE_SELECT; } } - + /* add all new strokes in temp buffer to the frame (preventing double-copies) */ BLI_movelisttolist(&gpf->strokes, &new_strokes); BLI_assert(new_strokes.first == NULL); } CTX_DATA_END; - + /* updates */ WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL); - + return OPERATOR_FINISHED; } @@ -620,11 +621,11 @@ void GPENCIL_OT_duplicate(wmOperatorType *ot) ot->name = "Duplicate Strokes"; ot->idname = "GPENCIL_OT_duplicate"; ot->description = "Duplicate the selected Grease Pencil strokes"; - + /* callbacks */ ot->exec = gp_duplicate_exec; ot->poll = gp_stroke_edit_poll; - + /* flags */ ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; } @@ -673,7 +674,7 @@ void GPENCIL_OT_active_frame_delete(wmOperatorType *ot) ot->name = "Delete Active Frame"; ot->idname = "GPENCIL_OT_active_frame_delete"; ot->description = "Delete the active frame for the active Grease Pencil datablock"; - + ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO; /* callbacks */ @@ -699,30 +700,30 @@ typedef enum eGP_DeleteMode { static int gp_delete_selected_strokes(bContext *C) { bool changed = false; - + CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers) { bGPDframe *gpf = gpl->actframe; bGPDstroke *gps, *gpsn; - + if (gpf == NULL) continue; - + /* simply delete strokes which are selected */ for (gps = gpf->strokes.first; gps; gps = gpsn) { gpsn = gps->next; - + if (gps->flag & GP_STROKE_SELECT) { /* free stroke memory arrays, then stroke itself */ if (gps->points) MEM_freeN(gps->points); BLI_freelinkN(&gpf->strokes, gps); - + changed = true; } } } CTX_DATA_END; - + if (changed) { WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL); return OPERATOR_FINISHED; @@ -736,27 +737,27 @@ static int gp_delete_selected_strokes(bContext *C) static int gp_dissolve_selected_points(bContext *C) { bool changed = false; - + CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers) { bGPDframe *gpf = gpl->actframe; bGPDstroke *gps, *gpsn; - + if (gpf == NULL) continue; - + /* simply delete points from selected strokes * NOTE: we may still have to remove the stroke if it ends up having no points! */ for (gps = gpf->strokes.first; gps; gps = gpsn) { gpsn = gps->next; - + if (gps->flag & GP_STROKE_SELECT) { bGPDspoint *pt; int i; - + int tot = gps->totpoints; /* number of points in new buffer */ - + /* First Pass: Count how many points are selected (i.e. how many to remove) */ for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) { if (pt->flag & GP_SPOINT_SELECT) { @@ -764,42 +765,42 @@ static int gp_dissolve_selected_points(bContext *C) tot--; } } - + /* if no points are left, we simply delete the entire stroke */ if (tot <= 0) { /* remove the entire stroke */ MEM_freeN(gps->points); BLI_freelinkN(&gpf->strokes, gps); } - else { + else { /* just copy all unselected into a smaller buffer */ bGPDspoint *new_points = MEM_callocN(sizeof(bGPDspoint) * tot, "new gp stroke points copy"); bGPDspoint *npt = new_points; - + for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) { if ((pt->flag & GP_SPOINT_SELECT) == 0) { *npt = *pt; npt++; } } - + /* free the old buffer */ MEM_freeN(gps->points); - + /* save the new buffer */ gps->points = new_points; gps->totpoints = tot; - + /* deselect the stroke, since none of its selected points will still be selected */ gps->flag &= ~GP_STROKE_SELECT; } - + changed = true; } } } CTX_DATA_END; - + if (changed) { WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL); return OPERATOR_FINISHED; @@ -813,27 +814,27 @@ static int gp_dissolve_selected_points(bContext *C) static int gp_delete_selected_points(bContext *C) { bool changed = false; - + CTX_DATA_BEGIN(C, bGPDlayer *, gpl, editable_gpencil_layers) { bGPDframe *gpf = gpl->actframe; bGPDstroke *gps, *gpsn; - + if (gpf == NULL) continue; - + /* simply delete strokes which are selected */ for (gps = gpf->strokes.first; gps; gps = gpsn) { gpsn = gps->next; - + if (gps->flag & GP_STROKE_SELECT) { bGPDspoint *pt; int i; - + /* The algorithm used here is as follows: * 1) We firstly identify the number of "islands" of non-selected points * which will all end up being in new strokes. - * - In the most extreme case (i.e. every other vert is a 1-vert island), + * - In the most extreme case (i.e. every other vert is a 1-vert island), * we have at most n / 2 islands * - Once we start having larger islands than that, the number required * becomes much less @@ -843,11 +844,11 @@ static int gp_delete_selected_points(bContext *C) int start_idx; int end_idx; } tGPDeleteIsland; - + tGPDeleteIsland *islands = MEM_callocN(sizeof(tGPDeleteIsland) * (gps->totpoints + 1) / 2, "gp_point_islands"); bool in_island = false; int num_islands = 0; - + /* First Pass: Identify start/end of islands */ for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) { if (pt->flag & GP_SPOINT_SELECT) { @@ -857,7 +858,7 @@ static int gp_delete_selected_points(bContext *C) else { /* unselected - start of a new island? */ int idx; - + if (in_island) { /* extend existing island */ idx = num_islands - 1; @@ -867,33 +868,33 @@ static int gp_delete_selected_points(bContext *C) /* start of new island */ in_island = true; num_islands++; - + idx = num_islands - 1; islands[idx].start_idx = islands[idx].end_idx = i; } } } - + /* Watch out for special case where No islands = All points selected = Delete Stroke only */ if (num_islands) { /* there are islands, so create a series of new strokes, adding them before the "next" stroke */ int idx; - + /* deselect old stroke, since it will be used as template for the new strokes */ gps->flag &= ~GP_STROKE_SELECT; - + /* create each new stroke... */ for (idx = 0; idx < num_islands; idx++) { tGPDeleteIsland *island = &islands[idx]; bGPDstroke *new_stroke = MEM_dupallocN(gps); - + /* compute new buffer size (+ 1 needed as the endpoint index is "inclusive") */ new_stroke->totpoints = island->end_idx - island->start_idx + 1; new_stroke->points = MEM_callocN(sizeof(bGPDspoint) * new_stroke->totpoints, "gp delete stroke fragment"); - + /* copy over the relevant points */ memcpy(new_stroke->points, gps->points + island->start_idx, sizeof(bGPDspoint) * new_stroke->totpoints); - + /* add new stroke to the frame */ if (gpsn) { BLI_insertlinkbefore(&gpf->strokes, gpsn, new_stroke); @@ -903,20 +904,20 @@ static int gp_delete_selected_points(bContext *C) } } } - + /* free islands */ MEM_freeN(islands); - + /* Delete the old stroke */ MEM_freeN(gps->points); BLI_freelinkN(&gpf->strokes, gps); - + changed = true; } } } CTX_DATA_END; - + if (changed) { WM_event_add_notifier(C, NC_GPENCIL | ND_DATA | NA_EDITED, NULL); return OPERATOR_FINISHED; @@ -928,28 +929,28 @@ static int gp_delete_selected_points(bContext *C) static int gp_delete_exec(bContext *C, wmOperator *op) -{ +{ eGP_DeleteMode mode = RNA_enum_get(op->ptr, "type"); int result = OPERATOR_CANCELLED; - + switch (mode) { case GP_DELETEOP_STROKES: /* selected strokes */ result = gp_delete_selected_strokes(C); break; - + case GP_DELETEOP_POINTS: /* selected points (breaks the stroke into segments) */ result = gp_delete_selected_points(C); break; - + case GP_DELETEOP_POINTS_DISSOLVE: /* selected points (without splitting the stroke) */ result = gp_dissolve_selected_points(C); break; - + case GP_DELETEOP_FRAME: /* active frame */ result = gp_actframe_delete_exec(C, op); break; } - + return result; } @@ -964,20 +965,20 @@ void GPENCIL_OT_delete(wmOperatorType *ot) "Delete selected points without splitting strokes"}, {0, NULL, 0, NULL, NULL} }; - + /* identifiers */ ot->name = "Delete..."; ot->idname = "GPENCIL_OT_delete"; ot->description = "Delete selected Grease Pencil strokes, vertices, or frames"; - + /* callbacks */ ot->invoke = WM_menu_invoke; ot->exec = gp_delete_exec; ot->poll = gp_stroke_edit_poll; - + /* flags */ ot->flag = OPTYPE_UNDO | OPTYPE_REGISTER; - + /* props */ ot->prop = RNA_def_enum(ot->srna, "type", prop_gpencil_delete_types, 0, "Type", "Method used for deleting Grease Pencil data"); } @@ -1034,7 +1035,7 @@ static EnumPropertyItem *rna_GPConvert_mode_items(bContext *UNUSED(C), PointerRN /* --- */ -/* convert the coordinates from the given stroke point into 3d-coordinates +/* convert the coordinates from the given stroke point into 3d-coordinates * - assumes that the active space is the 3D-View */ static void gp_strokepoint_convertcoords(bContext *C, bGPDstroke *gps, bGPDspoint *pt, float p3d[3], rctf *subrect) @@ -1670,8 +1671,8 @@ static void gp_stroke_to_bezier_add_point(tGpTimingData *gtd, BezTriple *bezt, } static void gp_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curve *cu, rctf *subrect, Nurb **curnu, - float minmax_weights[2], const float rad_fac, bool stitch, const bool add_start_point, - const bool add_end_point, tGpTimingData *gtd) + float minmax_weights[2], const float rad_fac, bool stitch, const bool add_start_point, + const bool add_end_point, tGpTimingData *gtd) { bGPDspoint *pt; Nurb *nu = (curnu) ? *curnu : NULL; @@ -2056,7 +2057,7 @@ static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bG } switch (mode) { - case GP_STROKECONVERT_PATH: + case GP_STROKECONVERT_PATH: gp_stroke_to_path(C, gpl, gps, cu, subrect_ptr, &nu, minmax_weights, rad_fac, stitch, add_start_point, add_end_point, gtd); break; diff --git a/source/blender/editors/gpencil/gpencil_intern.h b/source/blender/editors/gpencil/gpencil_intern.h index 12f231a47bf..ce4a81c05d0 100644 --- a/source/blender/editors/gpencil/gpencil_intern.h +++ b/source/blender/editors/gpencil/gpencil_intern.h @@ -54,20 +54,20 @@ struct wmOperatorType; typedef struct GP_SpaceConversion { struct bGPdata *gpd; struct bGPDlayer *gpl; - + struct ScrArea *sa; struct ARegion *ar; struct View2D *v2d; - + rctf *subrect; /* for using the camera rect within the 3d view */ rctf subrect_data; - + float mat[4][4]; /* transform matrix on the strokes (introduced in [b770964]) */ } GP_SpaceConversion; -/** - * Check whether a given stroke segment is inside a circular brush +/** + * Check whether a given stroke segment is inside a circular brush * * \param mval The current screen-space coordinates (midpoint) of the brush * \param mvalo The previous screen-space coordinates (midpoint) of the brush (NOT CURRENTLY USED) @@ -81,7 +81,7 @@ bool gp_stroke_inside_circle(const int mval[2], const int UNUSED(mvalo[2]), /** - * Init settings for stroke point space conversions + * Init settings for stroke point space conversions * * \param[out] r_gsc The space conversion settings struct, populated with necessary params */ @@ -152,17 +152,17 @@ void gpencil_undo_finish(void); /* This struct defines a structure used for quick access */ typedef struct bActListElem { struct bActListElem *next, *prev; - + void *data; /* source data this elem represents */ int type; /* one of the ACTTYPE_* values */ int flag; /* copy of elem's flags for quick access */ int index; /* copy of adrcode where applicable */ - + void *key_data; /* motion data - ipo or ipo-curve */ short datatype; /* type of motion data to expect */ - + struct bActionGroup *grp; /* action group that owns the channel */ - + void *owner; /* will either be an action channel or fake ipo-channel (for keys) */ short ownertype; /* type of owner */ } bActListElem; diff --git a/source/blender/editors/gpencil/gpencil_ops.c b/source/blender/editors/gpencil/gpencil_ops.c index 072ef32a6eb..1d0e0053e90 100644 --- a/source/blender/editors/gpencil/gpencil_ops.c +++ b/source/blender/editors/gpencil/gpencil_ops.c @@ -59,34 +59,34 @@ static void ed_keymap_gpencil_general(wmKeyConfig *keyconf) { wmKeyMap *keymap = WM_keymap_find(keyconf, "Grease Pencil", 0, 0); wmKeyMapItem *kmi; - + /* Draw --------------------------------------- */ /* draw */ kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_draw", LEFTMOUSE, KM_PRESS, 0, DKEY); RNA_enum_set(kmi->ptr, "mode", GP_PAINTMODE_DRAW); RNA_boolean_set(kmi->ptr, "wait_for_input", false); - + /* draw - straight lines */ kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_draw", LEFTMOUSE, KM_PRESS, KM_CTRL, DKEY); RNA_enum_set(kmi->ptr, "mode", GP_PAINTMODE_DRAW_STRAIGHT); RNA_boolean_set(kmi->ptr, "wait_for_input", false); - + /* draw - poly lines */ kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_draw", LEFTMOUSE, KM_PRESS, KM_ALT, DKEY); RNA_enum_set(kmi->ptr, "mode", GP_PAINTMODE_DRAW_POLY); RNA_boolean_set(kmi->ptr, "wait_for_input", false); - + /* erase */ kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_draw", RIGHTMOUSE, KM_PRESS, 0, DKEY); RNA_enum_set(kmi->ptr, "mode", GP_PAINTMODE_ERASER); RNA_boolean_set(kmi->ptr, "wait_for_input", false); - + /* Viewport Tools ------------------------------- */ - + /* Enter EditMode */ kmi = WM_keymap_add_item(keymap, "WM_OT_context_toggle", TABKEY, KM_PRESS, 0, DKEY); RNA_string_set(kmi->ptr, "data_path", "gpencil_data.use_stroke_edit_mode"); - + /* Pie Menu - For standard tools */ WM_keymap_add_menu_pie(keymap, "GPENCIL_PIE_tool_palette", QKEY, KM_PRESS, 0, DKEY); WM_keymap_add_menu_pie(keymap, "GPENCIL_PIE_settings_palette", WKEY, KM_PRESS, 0, DKEY); @@ -106,89 +106,89 @@ static void ed_keymap_gpencil_editing(wmKeyConfig *keyconf) { wmKeyMap *keymap = WM_keymap_find(keyconf, "Grease Pencil Stroke Edit Mode", 0, 0); wmKeyMapItem *kmi; - + /* set poll callback - so that this keymap only gets enabled when stroke editmode is enabled */ keymap->poll = gp_stroke_editmode_poll; - + /* ----------------------------------------------- */ - + /* Exit EditMode */ kmi = WM_keymap_add_item(keymap, "WM_OT_context_toggle", TABKEY, KM_PRESS, 0, 0); RNA_string_set(kmi->ptr, "data_path", "gpencil_data.use_stroke_edit_mode"); - + /* Selection ------------------------------------- */ /* select all */ kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_all", AKEY, KM_PRESS, 0, 0); RNA_enum_set(kmi->ptr, "action", SEL_TOGGLE); - + kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_all", IKEY, KM_PRESS, KM_CTRL, 0); RNA_enum_set(kmi->ptr, "action", SEL_INVERT); - + /* circle select */ WM_keymap_add_item(keymap, "GPENCIL_OT_select_circle", CKEY, KM_PRESS, 0, 0); - + /* border select */ WM_keymap_add_item(keymap, "GPENCIL_OT_select_border", BKEY, KM_PRESS, 0, 0); - + /* lasso select */ kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_lasso", EVT_TWEAK_A, KM_ANY, KM_CTRL, 0); RNA_boolean_set(kmi->ptr, "deselect", false); kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select_lasso", EVT_TWEAK_A, KM_ANY, KM_SHIFT | KM_CTRL, 0); RNA_boolean_set(kmi->ptr, "deselect", true); - + /* normal select */ WM_keymap_add_item(keymap, "GPENCIL_OT_select", SELECTMOUSE, KM_PRESS, 0, 0); - + kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select", SELECTMOUSE, KM_PRESS, KM_SHIFT, 0); RNA_boolean_set(kmi->ptr, "extend", true); RNA_boolean_set(kmi->ptr, "toggle", true); - + /* whole stroke select */ kmi = WM_keymap_add_item(keymap, "GPENCIL_OT_select", SELECTMOUSE, KM_PRESS, KM_ALT, 0); RNA_boolean_set(kmi->ptr, "entire_strokes", true); - + /* select linked */ WM_keymap_add_item(keymap, "GPENCIL_OT_select_linked", LKEY, KM_PRESS, KM_CTRL, 0); - + /* select more/less */ WM_keymap_add_item(keymap, "GPENCIL_OT_select_more", PADPLUSKEY, KM_PRESS, KM_CTRL, 0); WM_keymap_add_item(keymap, "GPENCIL_OT_select_less", PADMINUS, KM_PRESS, KM_CTRL, 0); - - + + /* Editing ----------------------------------------- */ - + /* duplicate and move selected points */ WM_keymap_add_item(keymap, "GPENCIL_OT_duplicate_move", DKEY, KM_PRESS, KM_SHIFT, 0); - + /* delete */ WM_keymap_add_item(keymap, "GPENCIL_OT_delete", XKEY, KM_PRESS, 0, 0); - - + + /* Transform Tools */ kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_translate", GKEY, KM_PRESS, 0, 0); RNA_boolean_set(kmi->ptr, "gpencil_strokes", true); - + kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_translate", EVT_TWEAK_S, KM_ANY, 0, 0); RNA_boolean_set(kmi->ptr, "gpencil_strokes", true); - + kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_rotate", RKEY, KM_PRESS, 0, 0); RNA_boolean_set(kmi->ptr, "gpencil_strokes", true); - + kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_resize", SKEY, KM_PRESS, 0, 0); RNA_boolean_set(kmi->ptr, "gpencil_strokes", true); - + kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_mirror", MKEY, KM_PRESS, KM_CTRL, 0); RNA_boolean_set(kmi->ptr, "gpencil_strokes", true); - + kmi = WM_keymap_add_item(keymap, "TRANSFORM_OT_bend", WKEY, KM_PRESS, KM_SHIFT, 0); RNA_boolean_set(kmi->ptr, "gpencil_strokes", true); - + WM_keymap_add_item(keymap, "TRANSFORM_OT_tosphere", SKEY, KM_PRESS, KM_ALT | KM_SHIFT, 0); RNA_boolean_set(kmi->ptr, "gpencil_strokes", true); - + WM_keymap_add_item(keymap, "TRANSFORM_OT_shear", SKEY, KM_PRESS, KM_ALT | KM_CTRL | KM_SHIFT, 0); RNA_boolean_set(kmi->ptr, "gpencil_strokes", true); - + /* Proportional Editing */ ED_keymap_proportional_cycle(keyconf, keymap); ED_keymap_proportional_editmode(keyconf, keymap, true); @@ -207,37 +207,37 @@ void ED_keymap_gpencil(wmKeyConfig *keyconf) void ED_operatortypes_gpencil(void) { /* Drawing ----------------------- */ - + WM_operatortype_append(GPENCIL_OT_draw); - + /* Editing (Strokes) ------------ */ - + WM_operatortype_append(GPENCIL_OT_select); WM_operatortype_append(GPENCIL_OT_select_all); WM_operatortype_append(GPENCIL_OT_select_circle); WM_operatortype_append(GPENCIL_OT_select_border); WM_operatortype_append(GPENCIL_OT_select_lasso); - + WM_operatortype_append(GPENCIL_OT_select_linked); WM_operatortype_append(GPENCIL_OT_select_more); WM_operatortype_append(GPENCIL_OT_select_less); - + WM_operatortype_append(GPENCIL_OT_duplicate); WM_operatortype_append(GPENCIL_OT_delete); - + /* Editing (Buttons) ------------ */ - + WM_operatortype_append(GPENCIL_OT_data_add); WM_operatortype_append(GPENCIL_OT_data_unlink); - + WM_operatortype_append(GPENCIL_OT_layer_add); WM_operatortype_append(GPENCIL_OT_layer_remove); WM_operatortype_append(GPENCIL_OT_layer_move); - + WM_operatortype_append(GPENCIL_OT_active_frame_delete); - + WM_operatortype_append(GPENCIL_OT_convert); - + /* Editing (Time) --------------- */ } diff --git a/source/blender/editors/gpencil/gpencil_paint.c b/source/blender/editors/gpencil/gpencil_paint.c index 67b0a67b6fb..b85e71de189 100644 --- a/source/blender/editors/gpencil/gpencil_paint.c +++ b/source/blender/editors/gpencil/gpencil_paint.c @@ -27,6 +27,7 @@ * \ingroup edgpencil */ + #include #include #include @@ -78,16 +79,16 @@ /* Temporary 'Stroke' Operation data */ typedef struct tGPsdata { Scene *scene; /* current scene from context */ - + wmWindow *win; /* window where painting originated */ ScrArea *sa; /* area where painting originated */ ARegion *ar; /* region where painting originated */ View2D *v2d; /* needed for GP_STROKE_2DSPACE */ rctf *subrect; /* for using the camera rect within the 3d view */ rctf subrect_data; - + GP_SpaceConversion gsc; /* settings to pass to gp_points_to_xy() */ - + PointerRNA ownerPtr; /* pointer to owner of gp-datablock */ bGPdata *gpd; /* gp-datablock layer comes from */ bGPDlayer *gpl; /* layer we're working on */ @@ -95,16 +96,16 @@ typedef struct tGPsdata { short status; /* current status of painting */ short paintmode; /* mode for painting */ - + int mval[2]; /* current mouse-position */ int mvalo[2]; /* previous recorded mouse-position */ - + float pressure; /* current stylus pressure */ float opressure; /* previous stylus pressure */ - + short radius; /* radius of influence for eraser */ short flags; /* flags that can get set during runtime */ - + /* 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. @@ -116,9 +117,9 @@ typedef struct tGPsdata { float imat[4][4]; /* inverted transformation matrix applying when converting coords from screen-space * to region space */ float mat[4][4]; - + float custom_color[4]; /* custom color - hack for enforcing a particular color for track/mask editing */ - + void *erasercursor; /* radial cursor data for drawing eraser */ } tGPsdata; @@ -194,7 +195,7 @@ static int gpencil_draw_poll(bContext *C) else { CTX_wm_operator_poll_msg_set(C, "Active region not set"); } - + return 0; } @@ -215,13 +216,13 @@ static void gp_get_3d_reference(tGPsdata *p, float vec[3]) { View3D *v3d = p->sa->spacedata.first; const float *fp = ED_view3d_cursor3d_get(p->scene, v3d); - + /* the reference point used depends on the owner... */ #if 0 /* XXX: disabled for now, since we can't draw relative to the owner yet */ if (p->ownerPtr.type == &RNA_Object) { Object *ob = (Object *)p->ownerPtr.data; - - /* active Object + + /* active Object * - use relative distance of 3D-cursor from object center */ sub_v3_v3v3(vec, fp, ob->loc); @@ -241,24 +242,24 @@ static bool gp_stroke_filtermval(tGPsdata *p, const int mval[2], int pmval[2]) { int dx = abs(mval[0] - pmval[0]); int dy = abs(mval[1] - pmval[1]); - + /* if buffer is empty, just let this go through (i.e. so that dots will work) */ if (p->gpd->sbuffer_size == 0) 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 */ else if ((dx > MIN_MANHATTEN_PX) && (dy > MIN_MANHATTEN_PX)) 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 * - 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) return true; - + /* mouse 'didn't move' */ else return false; @@ -269,7 +270,7 @@ static bool gp_stroke_filtermval(tGPsdata *p, const int mval[2], int pmval[2]) static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3], float *depth) { bGPdata *gpd = p->gpd; - + /* in 3d-space - pt->x/y/z are 3 side-by-side floats */ if (gpd->sbuffer_sflag & GP_STROKE_3DSPACE) { if (gpencil_project_check(p) && (ED_view3d_autodist_simple(p->ar, mval, out, 0, depth))) { @@ -282,7 +283,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3] float rvec[3], dvec[3]; float mval_f[2] = {UNPACK2(mval)}; float zfac; - + /* Current method just converts each point in screen-coordinates to * 3D-coordinates using the 3D-cursor as reference. In general, this * works OK, but it could of course be improved. @@ -291,7 +292,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3] * - investigate using nearest point(s) on a previous stroke as * reference point instead or as offset, for easier stroke matching */ - + gp_get_3d_reference(p, rvec); zfac = ED_view3d_calc_zfac(p->ar->regiondata, rvec, NULL); @@ -305,13 +306,13 @@ static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3] } } } - + /* 2d - on 'canvas' (assume that p->v2d is set) */ else if ((gpd->sbuffer_sflag & GP_STROKE_2DSPACE) && (p->v2d)) { UI_view2d_region_to_view(p->v2d, mval[0], mval[1], &out[0], &out[1]); mul_v3_m4v3(out, p->imat, out); } - + /* 2d - relative to screen (viewport area) */ else { if (p->subrect == NULL) { /* normal 3D view */ @@ -337,26 +338,26 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, if (gpd->sbuffer_size == 0) { /* first point in buffer (start point) */ pt = (tGPspoint *)(gpd->sbuffer); - + /* store settings */ copy_v2_v2_int(&pt->x, mval); pt->pressure = pressure; pt->time = (float)(curtime - p->inittime); - + /* increment buffer size */ gpd->sbuffer_size++; } else { - /* normally, we just reset the endpoint to the latest value + /* normally, we just reset the endpoint to the latest value * - assume that pointers for this are always valid... */ pt = ((tGPspoint *)(gpd->sbuffer) + 1); - + /* store settings */ copy_v2_v2_int(&pt->x, mval); pt->pressure = pressure; pt->time = (float)(curtime - p->inittime); - + /* if this is just the second point we've added, increment the buffer size * so that it will be drawn properly... * otherwise, just leave it alone, otherwise we get problems @@ -364,7 +365,7 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, if (gpd->sbuffer_size != 2) gpd->sbuffer_size = 2; } - + /* can keep carrying on this way :) */ return GP_STROKEADD_NORMAL; } @@ -372,18 +373,18 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, /* check if still room in buffer */ if (gpd->sbuffer_size >= GP_STROKE_BUFFER_MAX) return GP_STROKEADD_OVERFLOW; - + /* get pointer to destination point */ pt = ((tGPspoint *)(gpd->sbuffer) + gpd->sbuffer_size); - + /* store settings */ copy_v2_v2_int(&pt->x, mval); pt->pressure = pressure; pt->time = (float)(curtime - p->inittime); - + /* increment counters */ gpd->sbuffer_size++; - + /* check if another operation can still occur */ if (gpd->sbuffer_size == GP_STROKE_BUFFER_MAX) return GP_STROKEADD_FULL; @@ -393,12 +394,12 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, else if (p->paintmode == GP_PAINTMODE_DRAW_POLY) { /* get pointer to destination point */ pt = (tGPspoint *)(gpd->sbuffer); - + /* store settings */ copy_v2_v2_int(&pt->x, mval); pt->pressure = pressure; pt->time = (float)(curtime - p->inittime); - + /* 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 * during mouse slide, e.g.) @@ -406,15 +407,15 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, if (gp_stroke_added_check(p)) { bGPDstroke *gps = p->gpf->strokes.last; bGPDspoint *pts; - + /* first time point is adding to temporary buffer -- need to allocate new point in stroke */ if (gpd->sbuffer_size == 0) { gps->points = MEM_reallocN(gps->points, sizeof(bGPDspoint) * (gps->totpoints + 1)); gps->totpoints++; } - + pts = &gps->points[gps->totpoints - 1]; - + /* special case for poly lines: normally, * depth is needed only when creating new stroke from buffer, * but poly lines are converting to stroke instantly, @@ -422,26 +423,26 @@ static short gp_stroke_addpoint(tGPsdata *p, const int mval[2], float pressure, */ if (gpencil_project_check(p)) { View3D *v3d = p->sa->spacedata.first; - + view3d_region_operator_needs_opengl(p->win, p->ar); ED_view3d_autodist_init(p->scene, p->ar, v3d, (p->gpd->flag & GP_DATA_DEPTH_STROKE) ? 1 : 0); } - + /* convert screen-coordinates to appropriate coordinates (and store them) */ gp_stroke_convertcoords(p, &pt->x, &pts->x, NULL); - + /* copy pressure and time */ pts->pressure = pt->pressure; pts->time = pt->time; } - + /* increment counters */ if (gpd->sbuffer_size == 0) gpd->sbuffer_size++; - + return GP_STROKEADD_NORMAL; } - + /* return invalid state for now... */ return GP_STROKEADD_INVALID; } @@ -452,21 +453,21 @@ static void gp_stroke_smooth(tGPsdata *p) bGPdata *gpd = p->gpd; tGPspoint *spt, tmp_spt[3]; int i = 0, cmx = gpd->sbuffer_size; - + /* only smooth if smoothing is enabled, and we're not doing a straight line */ if (!(U.gp_settings & GP_PAINT_DOSMOOTH) || ELEM(p->paintmode, GP_PAINTMODE_DRAW_STRAIGHT, GP_PAINTMODE_DRAW_POLY)) return; - + /* don't try if less than 2 points in buffer */ if ((cmx <= 2) || (gpd->sbuffer == NULL)) return; - - /* Calculate smoothing coordinates using weighted-averages + + /* Calculate smoothing coordinates using weighted-averages * WARNING: we do NOT smooth first and last points (to avoid shrinkage) */ spt = (tGPspoint *)gpd->sbuffer; - - /* This (tmp_spt) small array stores the last two points' original coordinates, + + /* 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; @@ -476,16 +477,16 @@ static void gp_stroke_smooth(tGPsdata *p) const tGPspoint *pa = (i - 1 > 0) ? (&tmp_spt[(i - 2) % 3]) : (pb); const tGPspoint *pd = pc + 1; const tGPspoint *pe = (i + 2 < cmx) ? (pc + 2) : (pd); - + /* 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); spt->y = (int)(0.1 * pa->y + 0.2 * pb->y + 0.4 * pc->y + 0.2 * pd->y + 0.1 * pe->y); } } -/* simplify a stroke (in buffer) before storing it +/* simplify a stroke (in buffer) before storing it * - applies a reverse Chaikin filter * - code adapted from etch-a-ton branch (editarmature_sketch.c) */ @@ -496,23 +497,23 @@ static void gp_stroke_simplify(tGPsdata *p) short num_points = gpd->sbuffer_size; short flag = gpd->sbuffer_sflag; short i, j; - + /* only simplify if simplification is enabled, and we're not doing a straight line */ if (!(U.gp_settings & GP_PAINT_DOSIMPLIFY) || (p->paintmode == GP_PAINTMODE_DRAW_STRAIGHT)) return; - + /* don't simplify if less than 4 points in buffer */ if ((num_points <= 4) || (old_points == NULL)) return; - - /* clear buffer (but don't free mem yet) so that we can write to it + + /* clear buffer (but don't free mem yet) so that we can write to it * - firstly set sbuffer to NULL, so a new one is allocated * - secondly, reset flag after, as it gets cleared auto */ gpd->sbuffer = NULL; gp_session_validatebuffer(p); gpd->sbuffer_sflag = flag; - + /* macro used in loop to get position of new point * - used due to the mixture of datatypes in use here */ @@ -523,39 +524,39 @@ static void gp_stroke_simplify(tGPsdata *p) pressure += old_points[offs].pressure * sfac; \ time += old_points[offs].time * sfac; \ } (void)0 - + /* 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); for (i = 0, j = 0; i < num_points; i++) { if (i - j == 3) { float co[2], pressure, time; int mco[2]; - + /* initialize values */ co[0] = 0.0f; co[1] = 0.0f; pressure = 0.0f; time = 0.0f; - + /* using macro, calculate new point */ GP_SIMPLIFY_AVPOINT(j, -0.25f); GP_SIMPLIFY_AVPOINT(j + 1, 0.75f); GP_SIMPLIFY_AVPOINT(j + 2, 0.75f); GP_SIMPLIFY_AVPOINT(j + 3, -0.25f); - + /* set values for adding */ mco[0] = (int)co[0]; mco[1] = (int)co[1]; - + /* ignore return values on this... assume to be ok for now */ gp_stroke_addpoint(p, mco, pressure, p->inittime + (double)time); - + j += 2; } } gp_stroke_addpoint(p, &old_points[num_points - 1].x, old_points[num_points - 1].pressure, p->inittime + (double)old_points[num_points - 1].time); - + /* free old buffer */ MEM_freeN(old_points); } @@ -571,22 +572,22 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) int i, totelem; /* since strokes are so fine, when using their depth we need a margin otherwise they might get missed */ int depth_margin = (p->gpd->flag & GP_DATA_DEPTH_STROKE) ? 4 : 0; - - /* get total number of points to allocate space for + + /* get total number of points to allocate space for * - drawing straight-lines only requires the endpoints */ if (p->paintmode == GP_PAINTMODE_DRAW_STRAIGHT) totelem = (gpd->sbuffer_size >= 2) ? 2 : gpd->sbuffer_size; else totelem = gpd->sbuffer_size; - + /* exit with error if no valid points from this stroke */ if (totelem == 0) { if (G.debug & G_DEBUG) printf("Error: No valid points in stroke buffer to convert (tot=%d)\n", gpd->sbuffer_size); return; } - + /* special case for poly line -- for already added stroke during session * coordinates are getting added to stroke immediately to allow more * interactive behavior @@ -596,46 +597,46 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) return; } } - + /* allocate memory for a new stroke */ gps = MEM_callocN(sizeof(bGPDstroke), "gp_stroke"); - + /* copy appropriate settings for stroke */ gps->totpoints = totelem; gps->thickness = p->gpl->thickness; gps->flag = gpd->sbuffer_sflag; gps->inittime = p->inittime; - + /* 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 */ { /* first point */ ptc = gpd->sbuffer; - + /* convert screen-coordinates to appropriate coordinates (and store them) */ gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); - + /* copy pressure and time */ pt->pressure = ptc->pressure; pt->time = ptc->time; - + pt++; } - + if (totelem == 2) { /* last point if applicable */ ptc = ((tGPspoint *)gpd->sbuffer) + (gpd->sbuffer_size - 1); - + /* convert screen-coordinates to appropriate coordinates (and store them) */ gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); - + /* copy pressure and time */ pt->pressure = ptc->pressure; pt->time = ptc->time; @@ -644,28 +645,28 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) else if (p->paintmode == GP_PAINTMODE_DRAW_POLY) { /* first point */ ptc = gpd->sbuffer; - + /* convert screen-coordinates to appropriate coordinates (and store them) */ gp_stroke_convertcoords(p, &ptc->x, &pt->x, NULL); - + /* copy pressure and time */ pt->pressure = ptc->pressure; pt->time = ptc->time; } else { float *depth_arr = NULL; - + /* get an array of depths, far depths are blended */ if (gpencil_project_check(p)) { int mval[2], mval_prev[2] = {0}; int interp_depth = 0; int found_depth = 0; - + depth_arr = MEM_mallocN(sizeof(float) * gpd->sbuffer_size, "depth_points"); - + for (i = 0, ptc = gpd->sbuffer; i < gpd->sbuffer_size; i++, ptc++, pt++) { copy_v2_v2_int(mval, &ptc->x); - + if ((ED_view3d_autodist_depth(p->ar, mval, depth_margin, depth_arr + i) == 0) && (i && (ED_view3d_autodist_depth_seg(p->ar, mval, mval_prev, depth_margin + 1, depth_arr + i) == 0))) { @@ -674,10 +675,10 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) else { found_depth = true; } - + copy_v2_v2_int(mval_prev, mval); } - + if (found_depth == false) { /* eeh... not much we can do.. :/, ignore depth in this case, use the 3D cursor */ for (i = gpd->sbuffer_size - 1; i >= 0; i--) @@ -688,49 +689,49 @@ static void gp_stroke_newfrombuffer(tGPsdata *p) /* remove all info between the valid endpoints */ int first_valid = 0; int last_valid = 0; - + for (i = 0; i < gpd->sbuffer_size; i++) { if (depth_arr[i] != FLT_MAX) break; } first_valid = i; - + for (i = gpd->sbuffer_size - 1; i >= 0; i--) { if (depth_arr[i] != FLT_MAX) break; } last_valid = i; - + /* invalidate non-endpoints, so only blend between first and last */ for (i = first_valid + 1; i < last_valid; i++) depth_arr[i] = FLT_MAX; - + interp_depth = true; } - + if (interp_depth) { interp_sparse_array(depth_arr, gpd->sbuffer_size, FLT_MAX); } } } - - + + pt = gps->points; - + /* convert all points (normal behavior) */ for (i = 0, ptc = gpd->sbuffer; i < gpd->sbuffer_size && 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); - + /* copy pressure and time */ pt->pressure = ptc->pressure; pt->time = ptc->time; } - + if (depth_arr) MEM_freeN(depth_arr); } - + /* add stroke to frame */ BLI_addtail(&p->gpf->strokes, gps); gp_stroke_added_enable(p); @@ -743,38 +744,38 @@ 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 */ MEM_freeN(pt_tmp); BLI_freelinkN(&gpf->strokes, gps); - + /* 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 */ gps->totpoints--; gps->points = MEM_callocN(sizeof(bGPDspoint) * gps->totpoints, "gp_stroke_points"); memcpy(gps->points, pt_tmp, sizeof(bGPDspoint) * gps->totpoints); - + /* free temp buffer */ MEM_freeN(pt_tmp); - + /* 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 remaining points' delta values. @@ -785,33 +786,33 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i) bGPDspoint *pts; float delta = pt_tmp[1].time; int j; - + gps->inittime += (double)delta; - + pts = gps->points; for (j = 0; j < gps->totpoints; j++, pts++) { pts->time -= delta; } } - + /* free temp buffer */ MEM_freeN(pt_tmp); - + /* 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 */ gsn = MEM_dupallocN(gps); gsn->prev = gsn->next = NULL; BLI_insertlinkafter(&gpf->strokes, gps, gsn); - + gsn->totpoints = gps->totpoints - i; gsn->points = MEM_callocN(sizeof(bGPDspoint) * gsn->totpoints, "gp_stroke_points"); memcpy(gsn->points, pt_tmp + i, sizeof(bGPDspoint) * gsn->totpoints); - + /* We must adjust timings of this new stroke! * 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. @@ -822,23 +823,23 @@ static short gp_stroke_eraser_splitdel(bGPDframe *gpf, bGPDstroke *gps, int i) bGPDspoint *pts; float delta = pt_tmp[i].time; int j; - + gsn->inittime += (double)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"); memcpy(gps->points, pt_tmp, sizeof(bGPDspoint) * i); - + /* free temp buffer */ MEM_freeN(pt_tmp); - + /* nothing left in stroke, so stop */ return 1; } @@ -855,8 +856,7 @@ static float view3d_point_depth(const RegionView3D *rv3d, const float co[3]) } } -static bool gp_stroke_eraser_is_occluded(tGPsdata *p, - const bGPDspoint *pt, const int x, const int y) +static bool gp_stroke_eraser_is_occluded(tGPsdata *p, const bGPDspoint *pt, const int x, const int y) { if ((p->sa->spacetype == SPACE_VIEW3D) && (p->flags & GP_PAINTFLAG_V3D_ERASER_DEPTH)) @@ -887,16 +887,16 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p, bGPDspoint *pt1, *pt2; int x0 = 0, y0 = 0, x1 = 0, y1 = 0; int i; - + if (gps->totpoints == 0) { /* just free stroke */ - if (gps->points) + if (gps->points) MEM_freeN(gps->points); BLI_freelinkN(&gpf->strokes, gps); } else if (gps->totpoints == 1) { gp_point_to_xy(&p->gsc, 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 */ @@ -908,17 +908,17 @@ static void gp_stroke_eraser_dostroke(tGPsdata *p, } } else { - /* loop over the points in the stroke, checking for intersections + /* loop over the points in the stroke, checking for intersections * - an intersection will require the stroke to be split */ for (i = 0; (i + 1) < gps->totpoints; i++) { /* get points to work with */ pt1 = gps->points + i; pt2 = gps->points + i + 1; - + gp_point_to_xy(&p->gsc, gps, pt1, &x0, &y0); gp_point_to_xy(&p->gsc, 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))) @@ -947,7 +947,7 @@ static void gp_stroke_doeraser(tGPsdata *p) bGPDframe *gpf = p->gpf; bGPDstroke *gps, *gpn; rcti rect; - + /* rect is rectangle of eraser */ rect.xmin = p->mval[0] - p->radius; rect.ymin = p->mval[1] - p->radius; @@ -977,7 +977,7 @@ static void gp_stroke_doeraser(tGPsdata *p) static void gp_session_validatebuffer(tGPsdata *p) { bGPdata *gpd = p->gpd; - + /* clear memory of buffer (or allocate it if starting a new session) */ if (gpd->sbuffer) { /* printf("\t\tGP - reset sbuffer\n"); */ @@ -987,10 +987,10 @@ static void gp_session_validatebuffer(tGPsdata *p) /* printf("\t\tGP - allocate sbuffer\n"); */ gpd->sbuffer = MEM_callocN(sizeof(tGPspoint) * GP_STROKE_BUFFER_MAX, "gp_session_strokebuffer"); } - + /* reset indices */ gpd->sbuffer_size = 0; - + /* reset flags */ gpd->sbuffer_sflag = 0; @@ -1004,7 +1004,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) bGPdata **gpd_ptr = NULL; ScrArea *curarea = CTX_wm_area(C); ARegion *ar = CTX_wm_region(C); - + /* make sure the active view (at the starting time) is a 3d-view */ if (curarea == NULL) { p->status = GP_STATUS_ERROR; @@ -1012,27 +1012,27 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) printf("Error: No active view for painting\n"); return 0; } - + /* pass on current scene and window */ p->scene = CTX_data_scene(C); p->win = CTX_wm_window(C); unit_m4(p->imat); unit_m4(p->mat); - + switch (curarea->spacetype) { /* supported views first */ case SPACE_VIEW3D: { /* View3D *v3d = curarea->spacedata.first; */ /* RegionView3D *rv3d = ar->regiondata; */ - - /* set current area + + /* set current area * - must verify that region data is 3D-view (and not something else) */ p->sa = curarea; p->ar = ar; - + if (ar->regiondata == NULL) { p->status = GP_STATUS_ERROR; if (G.debug & G_DEBUG) @@ -1044,7 +1044,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) case SPACE_NODE: { /* SpaceNode *snode = curarea->spacedata.first; */ - + /* set current area */ p->sa = curarea; p->ar = ar; @@ -1054,12 +1054,12 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) case SPACE_SEQ: { SpaceSeq *sseq = curarea->spacedata.first; - + /* set current area */ p->sa = curarea; p->ar = ar; p->v2d = &ar->v2d; - + /* check that gpencil data is allowed to be drawn */ if (sseq->mainb == SEQ_DRAW_SEQUENCE) { p->status = GP_STATUS_ERROR; @@ -1072,7 +1072,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) case SPACE_IMAGE: { /* SpaceImage *sima = curarea->spacedata.first; */ - + /* set the current area */ p->sa = curarea; p->ar = ar; @@ -1082,30 +1082,30 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) case SPACE_CLIP: { SpaceClip *sc = curarea->spacedata.first; - + /* set the current area */ p->sa = curarea; p->ar = ar; p->v2d = &ar->v2d; - + invert_m4_m4(p->imat, sc->unistabmat); - + /* custom color for new layer */ p->custom_color[0] = 1.0f; p->custom_color[1] = 0.0f; p->custom_color[2] = 0.5f; p->custom_color[3] = 0.9f; - + if (sc->gpencil_src == SC_GPENCIL_SRC_TRACK) { MovieClip *clip = ED_space_clip_get_clip(sc); int framenr = ED_space_clip_get_clip_frame_number(sc); MovieTrackingTrack *track = BKE_tracking_track_get_active(&clip->tracking); MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr); - + p->imat[3][0] -= marker->pos[0]; p->imat[3][1] -= marker->pos[1]; } - + invert_m4_m4(p->mat, p->imat); copy_m4_m4(p->gsc.mat, p->mat); break; @@ -1119,7 +1119,7 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) return 0; } } - + /* get gp-data */ gpd_ptr = ED_gpencil_data_get_pointers(C, &p->ownerPtr); if (gpd_ptr == NULL) { @@ -1134,17 +1134,17 @@ static int gp_session_initdata(bContext *C, tGPsdata *p) *gpd_ptr = gpencil_data_addnew("GPencil"); p->gpd = *gpd_ptr; } - + if (ED_gpencil_session_active() == 0) { /* initialize undo stack, * also, existing undo stack would make buffer drawn */ gpencil_undo_init(p->gpd); } - + /* clear out buffer (stored in gp-data), in case something contaminated it */ gp_session_validatebuffer(p); - + return 1; } @@ -1157,7 +1157,7 @@ static tGPsdata *gp_session_initpaint(bContext *C) p = MEM_callocN(sizeof(tGPsdata), "GPencil Drawing Data"); gp_session_initdata(C, p); - + /* return context data for running paint operator */ return p; } @@ -1166,18 +1166,18 @@ static tGPsdata *gp_session_initpaint(bContext *C) static void gp_session_cleanup(tGPsdata *p) { bGPdata *gpd = (p) ? p->gpd : NULL; - + /* error checking */ if (gpd == NULL) return; - + /* free stroke buffer */ if (gpd->sbuffer) { /* printf("\t\tGP - free sbuffer\n"); */ MEM_freeN(gpd->sbuffer); gpd->sbuffer = NULL; } - + /* clear flags */ gpd->sbuffer_size = 0; gpd->sbuffer_sflag = 0; @@ -1186,12 +1186,12 @@ static void gp_session_cleanup(tGPsdata *p) /* init new stroke */ static void gp_paint_initstroke(tGPsdata *p, short paintmode) -{ +{ /* get active layer (or add a new one if non-existent) */ p->gpl = gpencil_layer_getactive(p->gpd); if (p->gpl == NULL) { p->gpl = gpencil_layer_addnew(p->gpd, "GP_Layer", 1); - + if (p->custom_color[3]) copy_v3_v3(p->gpl->color, p->custom_color); } @@ -1201,7 +1201,7 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) printf("Error: Cannot paint on locked layer\n"); return; } - + /* get active frame (add a new one if not matching frame) */ p->gpf = gpencil_layer_getframe(p->gpl, p->scene->r.cfra, 1); if (p->gpf == NULL) { @@ -1212,7 +1212,7 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) } else p->gpf->flag |= GP_FRAME_PAINT; - + /* set 'eraser' for this stroke if using eraser */ p->paintmode = paintmode; if (p->paintmode == GP_PAINTMODE_ERASER) { @@ -1228,14 +1228,14 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) /* set 'initial run' flag, which is only used to denote when a new stroke is starting */ p->flags |= GP_PAINTFLAG_FIRSTRUN; - + /* when drawing in the camera view, in 2D space, set the subrect */ if (!(p->gpd->flag & GP_DATA_VIEWALIGN)) { if (p->sa->spacetype == SPACE_VIEW3D) { View3D *v3d = p->sa->spacedata.first; RegionView3D *rv3d = p->ar->regiondata; - + /* for camera view set the subrect */ if (rv3d->persp == RV3D_CAMOB) { ED_view3d_calc_camera_border(p->scene, p->ar, v3d, rv3d, &p->subrect_data, true); /* no shift */ @@ -1243,21 +1243,21 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) } } } - + /* init stroke point space-conversion settings... */ p->gsc.gpd = p->gpd; p->gsc.gpl = p->gpl; - + p->gsc.sa = p->sa; p->gsc.ar = p->ar; p->gsc.v2d = p->v2d; - + p->gsc.subrect_data = p->subrect_data; p->gsc.subrect = p->subrect; - + copy_m4_m4(p->gsc.mat, p->mat); - - + + /* check if points will need to be made in view-aligned space */ if (p->gpd->flag & GP_DATA_VIEWALIGN) { switch (p->sa->spacetype) { @@ -1279,7 +1279,7 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) case SPACE_IMAGE: { SpaceImage *sima = (SpaceImage *)p->sa->spacedata.first; - + /* only set these flags if the image editor doesn't have an image active, * otherwise user will be confused by strokes not appearing after they're drawn * @@ -1307,29 +1307,29 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode) /* finish off a stroke (clears buffer, but doesn't finish the paint operation) */ static void gp_paint_strokeend(tGPsdata *p) { - /* for surface sketching, need to set the right OpenGL context stuff so that + /* 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)) { View3D *v3d = p->sa->spacedata.first; - + /* need to restore the original projection settings before packing up */ view3d_region_operator_needs_opengl(p->win, p->ar); ED_view3d_autodist_init(p->scene, p->ar, v3d, (p->gpd->flag & GP_DATA_DEPTH_STROKE) ? 1 : 0); } - + /* check if doing eraser or not */ if ((p->gpd->sbuffer_sflag & GP_STROKE_ERASER) == 0) { /* smooth stroke before transferring? */ gp_stroke_smooth(p); - + /* simplify stroke before transferring? */ gp_stroke_simplify(p); - + /* transfer stroke to frame */ gp_stroke_newfrombuffer(p); } - + /* clean up buffer now */ gp_session_validatebuffer(p); } @@ -1344,7 +1344,7 @@ static void gp_paint_cleanup(tGPsdata *p) /* finish off a stroke */ gp_paint_strokeend(p); } - + /* "unlock" frame */ if (p->gpf) p->gpf->flag &= ~GP_FRAME_PAINT; @@ -1356,15 +1356,15 @@ static void gp_paint_cleanup(tGPsdata *p) static void gpencil_draw_eraser(bContext *UNUSED(C), int x, int y, void *p_ptr) { tGPsdata *p = (tGPsdata *)p_ptr; - + if (p->paintmode == GP_PAINTMODE_ERASER) { glPushMatrix(); - + glTranslatef((float)x, (float)y, 0.0f); - + glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); - + glColor4ub(255, 100, 100, 20); glutil_draw_filled_arc(0.0, M_PI * 2.0, p->radius, 40); @@ -1372,11 +1372,11 @@ static void gpencil_draw_eraser(bContext *UNUSED(C), int x, int y, void *p_ptr) glColor4ub(255, 100, 100, 200); glutil_draw_lined_arc(0.0, M_PI * 2.0, p->radius, 40); - + setlinestyle(0); glDisable(GL_BLEND); glDisable(GL_LINE_SMOOTH); - + glPopMatrix(); } } @@ -1391,7 +1391,7 @@ static void gpencil_draw_toggle_eraser_cursor(bContext *C, tGPsdata *p, short en } else if (enable) { /* enable cursor */ - p->erasercursor = WM_paint_cursor_activate(CTX_wm_manager(C), + p->erasercursor = WM_paint_cursor_activate(CTX_wm_manager(C), NULL, /* XXX */ gpencil_draw_eraser, p); } @@ -1403,33 +1403,33 @@ static void gpencil_draw_toggle_eraser_cursor(bContext *C, tGPsdata *p, short en static void gpencil_draw_exit(bContext *C, wmOperator *op) { tGPsdata *p = op->customdata; - + /* clear undo stack */ gpencil_undo_finish(); - + /* restore cursor to indicate end of drawing */ WM_cursor_modal_restore(CTX_wm_window(C)); - + /* don't assume that operator data exists at all */ if (p) { /* 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(C, p, false); - + /* if successful, store the new eraser size to be used again next time */ if (p->status == GP_STATUS_DONE) U.gp_eraser = p->radius; } - + /* cleanup */ gp_paint_cleanup(p); gp_session_cleanup(p); - + /* finally, free the temp data */ MEM_freeN(p); } - + op->customdata = NULL; } @@ -1446,7 +1446,7 @@ static int gpencil_draw_init(bContext *C, wmOperator *op) { tGPsdata *p; int paintmode = RNA_enum_get(op->ptr, "mode"); - + /* check context */ p = op->customdata = gp_session_initpaint(C); if ((p == NULL) || (p->status == GP_STATUS_ERROR)) { @@ -1454,17 +1454,17 @@ static int gpencil_draw_init(bContext *C, wmOperator *op) gpencil_draw_exit(C, op); return 0; } - + /* init painting data */ gp_paint_initstroke(p, paintmode); if (p->status == GP_STATUS_ERROR) { gpencil_draw_exit(C, op); return 0; } - + /* radius for eraser circle is defined in userprefs now */ p->radius = U.gp_eraser; - + /* everything is now setup ok */ return 1; } @@ -1482,7 +1482,7 @@ static void gpencil_draw_status_indicators(tGPsdata *p) if (GPENCIL_SKETCH_SESSIONS_ON(p->scene)) ED_area_headerprint(p->sa, IFACE_("Grease Pencil: Drawing/erasing stroke... Release to end stroke")); break; - + case GP_STATUS_IDLING: /* print status info */ switch (p->paintmode) { @@ -1498,13 +1498,13 @@ static void gpencil_draw_status_indicators(tGPsdata *p) ED_area_headerprint(p->sa, IFACE_("Grease Pencil Freehand Session: Hold and drag LMB to draw | " "ESC/Enter to end")); break; - + default: /* unhandled future cases */ ED_area_headerprint(p->sa, IFACE_("Grease Pencil Session: ESC/Enter to end")); break; } break; - + case GP_STATUS_ERROR: case GP_STATUS_DONE: /* clear status string */ @@ -1522,7 +1522,7 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p) if (p->paintmode == GP_PAINTMODE_ERASER) { /* do 'live' erasing now */ gp_stroke_doeraser(p); - + /* store used values */ p->mvalo[0] = p->mval[0]; p->mvalo[1] = p->mval[1]; @@ -1532,14 +1532,14 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p) else if (gp_stroke_filtermval(p, p->mval, p->mvalo)) { /* try to add point */ short ok = gp_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); /* And start a new one!!! Else, projection errors! */ gp_paint_initstroke(p, p->paintmode); - + /* start a new stroke, starting from previous point */ /* XXX Must manually reset inittime... */ /* XXX We only need to reuse previous point if overflow! */ @@ -1556,12 +1556,12 @@ static void gpencil_draw_apply(wmOperator *op, tGPsdata *p) /* the painting operation cannot continue... */ BKE_report(op->reports, RPT_ERROR, "Cannot paint stroke"); p->status = GP_STATUS_ERROR; - + if (G.debug & G_DEBUG) printf("Error: Grease-Pencil Paint - Add Point Invalid\n"); return; } - + /* store used values */ p->mvalo[0] = p->mval[0]; p->mvalo[1] = p->mval[1]; @@ -1577,57 +1577,57 @@ static void gpencil_draw_apply_event(wmOperator *op, const 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->tablet_data) { wmTabletData *wmtab = event->tablet_data; - + tablet = (wmtab->Active != EVT_TABLET_NONE); p->pressure = wmtab->Pressure; - + /* if (wmtab->Active == EVT_TABLET_ERASER) */ /* TODO... this should get caught by the keymaps which call drawing in the first place */ } else p->pressure = 1.0f; - + /* fill in stroke data (not actually used directly by gpencil_draw_apply) */ RNA_collection_add(op->ptr, "stroke", &itemptr); - + mousef[0] = p->mval[0]; mousef[1] = p->mval[1]; RNA_float_set_array(&itemptr, "mouse", mousef); RNA_float_set(&itemptr, "pressure", p->pressure); RNA_boolean_set(&itemptr, "is_start", (p->flags & GP_PAINTFLAG_FIRSTRUN)); - + /* special exception for start of strokes (i.e. maybe for just a dot) */ if (p->flags & GP_PAINTFLAG_FIRSTRUN) { p->flags &= ~GP_PAINTFLAG_FIRSTRUN; - + p->mvalo[0] = p->mval[0]; 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... */ if (tablet && (p->pressure >= 0.99f)) return; } - + RNA_float_set(&itemptr, "time", p->curtime - p->inittime); - + /* apply the current latest drawing point */ gpencil_draw_apply(op, p); - + /* force refresh */ ED_region_tag_redraw(p->ar); /* just active area for now, since doing whole screen is too slow */ } @@ -1638,9 +1638,9 @@ static void gpencil_draw_apply_event(wmOperator *op, const wmEvent *event) static int gpencil_draw_exec(bContext *C, wmOperator *op) { tGPsdata *p = NULL; - + /* printf("GPencil - Starting Re-Drawing\n"); */ - + /* try to initialize context data needed while drawing */ if (!gpencil_draw_init(C, op)) { if (op->customdata) MEM_freeN(op->customdata); @@ -1649,25 +1649,25 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op) } else p = op->customdata; - + /* printf("\tGP - Start redrawing stroke\n"); */ - + /* loop over the stroke RNA elements recorded (i.e. progress of mouse movement), * setting the relevant values in context at each step, then applying */ RNA_BEGIN (op->ptr, itemptr, "stroke") { float mousef[2]; - + /* printf("\t\tGP - stroke elem\n"); */ - + /* get relevant data for this point from stroke */ RNA_float_get_array(&itemptr, "mouse", mousef); p->mval[0] = (int)mousef[0]; p->mval[1] = (int)mousef[1]; p->pressure = RNA_float_get(&itemptr, "pressure"); p->curtime = (double)RNA_float_get(&itemptr, "time") + p->inittime; - + if (RNA_boolean_get(&itemptr, "is_start")) { /* if first-run flag isn't set already (i.e. not true first stroke), * then we must terminate the previous one first before continuing @@ -1678,30 +1678,30 @@ static int gpencil_draw_exec(bContext *C, wmOperator *op) gp_paint_initstroke(p, p->paintmode); } } - + /* if first run, set previous data too */ if (p->flags & GP_PAINTFLAG_FIRSTRUN) { p->flags &= ~GP_PAINTFLAG_FIRSTRUN; - + p->mvalo[0] = p->mval[0]; p->mvalo[1] = p->mval[1]; p->opressure = p->pressure; p->ocurtime = p->curtime; } - + /* apply this data as necessary now (as per usual) */ gpencil_draw_apply(op, p); } RNA_END; - + /* printf("\tGP - done\n"); */ - + /* cleanup */ gpencil_draw_exit(C, op); - + /* refreshes */ WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL); - + /* done */ return OPERATOR_FINISHED; } @@ -1713,13 +1713,13 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event { tGPsdata *p = NULL; wmWindow *win = CTX_wm_window(C); - + if (G.debug & G_DEBUG) printf("GPencil - Starting Drawing\n"); - + /* try to initialize context data needed while drawing */ if (!gpencil_draw_init(C, op)) { - if (op->customdata) + if (op->customdata) MEM_freeN(op->customdata); if (G.debug & G_DEBUG) printf("\tGP - no valid data\n"); @@ -1737,19 +1737,19 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event if (p->paintmode == GP_PAINTMODE_ERASER) { gpencil_draw_toggle_eraser_cursor(C, p, true); } - + /* set cursor */ if (p->paintmode == GP_PAINTMODE_ERASER) WM_cursor_modal_set(win, BC_CROSSCURSOR); /* XXX need a better cursor */ else WM_cursor_modal_set(win, BC_PAINTBRUSHCURSOR); - + /* only start drawing immediately if we're allowed to do so... */ if (RNA_boolean_get(op->ptr, "wait_for_input") == false) { /* hotkey invoked - start drawing */ /* printf("\tGP - set first spot\n"); */ p->status = GP_STATUS_PAINTING; - + /* handle the initial drawing - i.e. for just doing a simple dot */ gpencil_draw_apply_event(op, event); } @@ -1757,7 +1757,7 @@ static int gpencil_draw_invoke(bContext *C, wmOperator *op, const wmEvent *event /* toolbar invoked - don't start drawing yet... */ /* printf("\tGP - hotkey invoked... waiting for click-drag\n"); */ } - + WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL); /* add a modal handler for this operator, so that we can then draw continuous strokes */ WM_event_add_modal_handler(C, op); @@ -1774,7 +1774,7 @@ static bool 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) */ @@ -1782,20 +1782,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; } @@ -1821,7 +1821,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) { tGPsdata *p = op->customdata; 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; * ------------------------------- @@ -1847,10 +1847,10 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) estate = OPERATOR_RUNNING_MODAL; } } - + //printf("\tGP - handle modal event...\n"); - - /* exit painting mode (and/or end current stroke) + + /* exit painting mode (and/or end current stroke) * NOTE: cannot do RIGHTMOUSE (as is standard for canceling) as that would break polyline [#32647] */ if (ELEM(event->type, RETKEY, PADENTER, ESCKEY, SPACEKEY)) { @@ -1859,8 +1859,8 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) p->status = GP_STATUS_DONE; estate = OPERATOR_FINISHED; } - - /* toggle painting mode upon mouse-button movement + + /* toggle painting mode upon mouse-button movement * - LEFTMOUSE = standard drawing (all) / straight line drawing (all) / polyline (toolbox only) * - RIGHTMOUSE = polyline (hotkey) / eraser (all) * (Disabling RIGHTMOUSE case here results in bugs like [#32647]) @@ -1869,22 +1869,22 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) /* if painting, end stroke */ if (p->status == GP_STATUS_PAINTING) { int sketch = 0; - - /* basically, this should be mouse-button up = end stroke + + /* basically, this should be mouse-button up = end stroke * BUT what happens next depends on whether we 'painting sessions' is enabled */ sketch |= GPENCIL_SKETCH_SESSIONS_ON(p->scene); /* polyline drawing is also 'sketching' -- all knots should be added during one session */ sketch |= (p->paintmode == GP_PAINTMODE_DRAW_POLY); - + if (sketch) { /* end stroke only, and then wait to resume painting soon */ /* printf("\t\tGP - end stroke only\n"); */ gpencil_stroke_end(op); - + /* we've just entered idling state, so this event was processed (but no others yet) */ estate = OPERATOR_RUNNING_MODAL; - + /* stroke could be smoothed, send notifier to refresh screen */ WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL); } @@ -1897,7 +1897,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) else if (event->val == KM_PRESS) { /* not painting, so start stroke (this should be mouse-button down) */ p = gpencil_stroke_begin(C, op); - + if (p->status == GP_STATUS_ERROR) { estate = OPERATOR_CANCELLED; } @@ -1906,7 +1906,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) p->status = GP_STATUS_IDLING; } } - + /* handle mode-specific events */ if (p->status == GP_STATUS_PAINTING) { /* handle painting mouse-movements? */ @@ -1914,7 +1914,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) /* handle drawing event */ /* printf("\t\tGP - add point\n"); */ gpencil_draw_apply_event(op, event); - + /* finish painting operation if anything went wrong just now */ if (p->status == GP_STATUS_ERROR) { printf("\t\t\t\tGP - add error done!\n"); @@ -1939,23 +1939,23 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) case PADPLUSKEY: p->radius += 5; break; - + case WHEELUPMOUSE: /* smaller */ case PADMINUS: p->radius -= 5; - - if (p->radius < 0) + + if (p->radius < 0) p->radius = 0; break; } - + /* force refresh */ ED_region_tag_redraw(p->ar); /* just active area for now, since doing whole screen is too slow */ - + /* event handled, so just tag as running modal */ estate = OPERATOR_RUNNING_MODAL; } - /* there shouldn't be any other events, but just in case there are, let's swallow them + /* there shouldn't be any other events, but just in case there are, let's swallow them * (i.e. to prevent problems with undo) */ else { @@ -1963,14 +1963,14 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) estate = OPERATOR_RUNNING_MODAL; } } - + /* gpencil modal operator stores area, which can be removed while using it (like fullscreen) */ if (0 == gpencil_area_exists(C, p->sa)) estate = OPERATOR_CANCELLED; else /* update status indicators - cursor, header, etc. */ gpencil_draw_status_indicators(p); - + /* process last operations before exiting */ switch (estate) { case OPERATOR_FINISHED: @@ -1978,11 +1978,11 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) gpencil_draw_exit(C, op); WM_event_add_notifier(C, NC_GPENCIL | NA_EDITED, NULL); break; - + case OPERATOR_CANCELLED: gpencil_draw_exit(C, op); break; - + case OPERATOR_RUNNING_MODAL | OPERATOR_PASS_THROUGH: /* event doesn't need to be handled */ #if 0 @@ -1991,7 +1991,7 @@ static int gpencil_draw_modal(bContext *C, wmOperator *op, const wmEvent *event) #endif break; } - + /* return status code */ return estate; } @@ -2012,21 +2012,21 @@ void GPENCIL_OT_draw(wmOperatorType *ot) ot->name = "Grease Pencil Draw"; ot->idname = "GPENCIL_OT_draw"; 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; - + /* flags */ ot->flag = OPTYPE_UNDO | OPTYPE_BLOCKING; - + /* settings for drawing */ ot->prop = RNA_def_enum(ot->srna, "mode", prop_gpencil_drawmodes, 0, "Mode", "Way to interpret mouse movements"); RNA_def_collection_runtime(ot->srna, "stroke", &RNA_OperatorStrokeElement, "Stroke", ""); - + /* NOTE: wait for input is enabled by default, so that all UI code can work properly without needing users to know about this */ RNA_def_boolean(ot->srna, "wait_for_input", true, "Wait for Input", "Wait for first click instead of painting immediately"); } diff --git a/source/blender/editors/gpencil/gpencil_undo.c b/source/blender/editors/gpencil/gpencil_undo.c index b1bbeabbd55..ed84f75863e 100644 --- a/source/blender/editors/gpencil/gpencil_undo.c +++ b/source/blender/editors/gpencil/gpencil_undo.c @@ -29,6 +29,7 @@ * \ingroup edgpencil */ + #include #include @@ -133,12 +134,12 @@ void gpencil_undo_push(bGPdata *gpd) while (undo_node) { bGPundonode *next_node = undo_node->next; - + /* HACK: animdata wasn't duplicated, so it shouldn't be freed here, - * or else the real copy will segfault when accessed + * or else the real copy will segfault when accessed */ undo_node->gpd->adt = NULL; - + BKE_gpencil_free(undo_node->gpd); MEM_freeN(undo_node->gpd); @@ -163,10 +164,10 @@ void gpencil_undo_finish(void) while (undo_node) { /* HACK: animdata wasn't duplicated, so it shouldn't be freed here, - * or else the real copy will segfault when accessed + * or else the real copy will segfault when accessed */ undo_node->gpd->adt = NULL; - + BKE_gpencil_free(undo_node->gpd); MEM_freeN(undo_node->gpd); -- cgit v1.2.3