Merge branch 'master' into blender2.8
[blender.git] / source / blender / editors / gpencil / drawgpencil.c
index f091609da49931ab4a0b12187f975aa4ef3183c9..11881a4a019d3e938064bc417c96a30c94bed7c0 100644 (file)
 
 #include "WM_api.h"
 
-#include "BIF_gl.h"
 #include "BIF_glutil.h"
 
+#include "GPU_immediate.h"
+#include "GPU_draw.h"
+
 #include "ED_gpencil.h"
 #include "ED_screen.h"
 #include "ED_view3d.h"
@@ -92,99 +94,198 @@ typedef enum eDrawStrokeFlags {
 
 
 /* thickness above which we should use special drawing */
+#if 0
 #define GP_DRAWTHICKNESS_SPECIAL    3
+#endif
+
+/* conversion utility (float --> normalized unsigned byte) */
+#define F2UB(x) (unsigned char)(255.0f * x)
 
 /* ----- Tool Buffer Drawing ------ */
-/* helper function to set color of buffer point */
-static void gp_set_tpoint_color(tGPspoint *pt, float ink[4])
+/* helper functions to set color of buffer point */
+
+static void gp_set_tpoint_varying_color(const tGPspoint *pt, const float ink[4], unsigned attrib_id)
 {
        float alpha = ink[3] * pt->strength;
        CLAMP(alpha, GPENCIL_STRENGTH_MIN, 1.0f);
-       glColor4f(ink[0], ink[1], ink[2], alpha);
+       immAttrib4ub(attrib_id, F2UB(ink[0]), F2UB(ink[1]), F2UB(ink[2]), F2UB(alpha));
 }
 
-/* helper function to set color of point */
-static void gp_set_point_color(bGPDspoint *pt, float ink[4])
+static void gp_set_point_uniform_color(const bGPDspoint *pt, const float ink[4])
 {
        float alpha = ink[3] * pt->strength;
        CLAMP(alpha, GPENCIL_STRENGTH_MIN, 1.0f);
-       glColor4f(ink[0], ink[1], ink[2], alpha);
+       immUniform4f("color", ink[0], ink[1], ink[2], alpha);
 }
 
-/* helper function to set color and point */
-static void gp_set_color_and_tpoint(tGPspoint *pt, float ink[4])
+static void gp_set_point_varying_color(const bGPDspoint *pt, const float ink[4], unsigned attrib_id)
 {
-       gp_set_tpoint_color(pt, ink);
-       glVertex2iv(&pt->x);
+       float alpha = ink[3] * pt->strength;
+       CLAMP(alpha, GPENCIL_STRENGTH_MIN, 1.0f);
+       immAttrib4ub(attrib_id, F2UB(ink[0]), F2UB(ink[1]), F2UB(ink[2]), F2UB(alpha));
+}
+
+/* draw fills for buffer stroke */
+static void gp_draw_stroke_buffer_fill(const tGPspoint *points, int totpoints, float ink[4])
+{
+       if (totpoints < 3) {
+               return;
+       }
+       int tot_triangles = totpoints - 2;
+       /* allocate memory for temporary areas */
+       unsigned int(*tmp_triangles)[3] = MEM_mallocN(sizeof(*tmp_triangles) * tot_triangles, "GP Stroke buffer temp triangulation");
+       float(*points2d)[2] = MEM_mallocN(sizeof(*points2d) * totpoints, "GP Stroke buffer temp 2d points");
+
+       /* Convert points to array and triangulate
+       * Here a cache is not used because while drawing the information changes all the time, so the cache
+       * would be recalculated constantly, so it is better to do direct calculation for each function call
+       */
+       for (int i = 0; i < totpoints; i++) {
+               const tGPspoint *pt = &points[i];
+               points2d[i][0] = pt->x;
+               points2d[i][1] = pt->y;
+       }
+       BLI_polyfill_calc((const float(*)[2])points2d, (unsigned int)totpoints, 0, (unsigned int(*)[3])tmp_triangles);
+
+       /* draw triangulation data */
+       if (tot_triangles > 0) {
+               VertexFormat *format = immVertexFormat();
+               unsigned int pos = VertexFormat_add_attrib(format, "pos", COMP_I32, 2, CONVERT_INT_TO_FLOAT);
+               unsigned int color = VertexFormat_add_attrib(format, "color", COMP_U8, 4, NORMALIZE_INT_TO_FLOAT);
+
+               immBindBuiltinProgram(GPU_SHADER_2D_SMOOTH_COLOR);
+
+               /* Draw all triangles for filling the polygon */
+               immBegin(PRIM_TRIANGLES, tot_triangles * 3);
+               /* TODO: use batch instead of immediate mode, to share vertices */
+
+               const tGPspoint *pt;
+               for (int i = 0; i < tot_triangles; i++) {
+                       /* vertex 1 */
+                       pt = &points[tmp_triangles[i][0]];
+                       gp_set_tpoint_varying_color(pt, ink, color);
+                       immVertex2iv(pos, &pt->x);
+                       /* vertex 2 */
+                       pt = &points[tmp_triangles[i][1]];
+                       gp_set_tpoint_varying_color(pt, ink, color);
+                       immVertex2iv(pos, &pt->x);
+                       /* vertex 3 */
+                       pt = &points[tmp_triangles[i][2]];
+                       gp_set_tpoint_varying_color(pt, ink, color);
+                       immVertex2iv(pos, &pt->x);
+               }
+
+               immEnd();
+               immUnbindProgram();
+       }
+
+       /* clear memory */
+       if (tmp_triangles) {
+               MEM_freeN(tmp_triangles);
+       }
+       if (points2d) {
+               MEM_freeN(points2d);
+       }
 }
 
 /* draw stroke defined in buffer (simple ogl lines/points for now, as dotted lines) */
-static void gp_draw_stroke_buffer(tGPspoint *points, int totpoints, short thickness,
-                                  short dflag, short sflag, float ink[4])
+static void gp_draw_stroke_buffer(const tGPspoint *points, int totpoints, short thickness,
+                                  short dflag, short sflag, float ink[4], float fill_ink[4])
 {
-       tGPspoint *pt;
-       int i;
-       
+       int draw_points = 0;
+
        /* error checking */
        if ((points == NULL) || (totpoints <= 0))
                return;
-       
+
        /* check if buffer can be drawn */
        if (dflag & (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_ONLYV2D))
                return;
-       
+
+       if (sflag & GP_STROKE_ERASER) {
+               /* don't draw stroke at all! */
+               return;
+       }
+
+       VertexFormat *format = immVertexFormat();
+       unsigned int pos = VertexFormat_add_attrib(format, "pos", COMP_I32, 2, CONVERT_INT_TO_FLOAT);
+       unsigned int color = VertexFormat_add_attrib(format, "color", COMP_U8, 4, NORMALIZE_INT_TO_FLOAT);
+
+       const tGPspoint *pt = points;
+
        if (totpoints == 1) {
                /* if drawing a single point, draw it larger */
                glPointSize((float)(thickness + 2) * points->pressure);
-               glBegin(GL_POINTS);
-
-               gp_set_color_and_tpoint(points, ink);
-               glEnd();
-       }
-       else if (sflag & GP_STROKE_ERASER) {
-               /* don't draw stroke at all! */
+               immBindBuiltinProgram(GPU_SHADER_3D_POINT_FIXED_SIZE_VARYING_COLOR);
+               immBegin(PRIM_POINTS, 1);
+               gp_set_tpoint_varying_color(pt, ink, color);
+               immVertex2iv(pos, &pt->x);
        }
        else {
                float oldpressure = points[0].pressure;
-               
+
                /* draw stroke curve */
                if (G.debug & G_DEBUG) setlinestyle(2);
-               
+
                glLineWidth(max_ff(oldpressure * thickness, 1.0));
-               glBegin(GL_LINE_STRIP);
-               
-               for (i = 0, pt = points; i < totpoints && pt; i++, pt++) {
+               immBindBuiltinProgram(GPU_SHADER_2D_SMOOTH_COLOR);
+               immBeginAtMost(PRIM_LINE_STRIP, totpoints);
+
+               /* TODO: implement this with a geometry shader to draw one continuous tapered stroke */
+
+               for (int i = 0; i < totpoints; i++, pt++) {
                        /* if there was a significant pressure change, stop the curve, change the thickness of the stroke,
                         * and continue drawing again (since line-width cannot change in middle of GL_LINE_STRIP)
                         */
                        if (fabsf(pt->pressure - oldpressure) > 0.2f) {
-                               glEnd();
+                               /* need to have 2 points to avoid immEnd assert error */
+                               if (draw_points < 2) {
+                                       gp_set_tpoint_varying_color(pt - 1, ink, color);
+                                       immVertex2iv(pos, &(pt - 1)->x);
+                               }
+
+                               immEnd();
+                               draw_points = 0;
+
                                glLineWidth(max_ff(pt->pressure * thickness, 1.0f));
-                               glBegin(GL_LINE_STRIP);
-                               
+                               immBeginAtMost(PRIM_LINE_STRIP, totpoints - i + 1);
+
                                /* need to roll-back one point to ensure that there are no gaps in the stroke */
                                if (i != 0) { 
-                                       gp_set_color_and_tpoint((pt - 1), ink);
+                                       gp_set_tpoint_varying_color(pt - 1, ink, color);
+                                       immVertex2iv(pos, &(pt - 1)->x);
+                                       ++draw_points;
                                }
-                               
-                               /* now the point we want... */
-                               gp_set_color_and_tpoint(pt, ink);
-                               
-                               oldpressure = pt->pressure;
-                       }
-                       else {
-                               gp_set_color_and_tpoint(pt, ink);
+
+                               oldpressure = pt->pressure; /* reset our threshold */
                        }
+
+                       /* now the point we want */
+                       gp_set_tpoint_varying_color(pt, ink, color);
+                       immVertex2iv(pos, &pt->x);
+                       ++draw_points;
+               }
+               /* need to have 2 points to avoid immEnd assert error */
+               if (draw_points < 2) {
+                       gp_set_tpoint_varying_color(pt - 1, ink, color);
+                       immVertex2iv(pos, &(pt - 1)->x);
                }
-               glEnd();
 
                if (G.debug & G_DEBUG) setlinestyle(0);
        }
+
+       immEnd();
+       immUnbindProgram();
+
+       // draw fill
+       if (fill_ink[3] > GPENCIL_ALPHA_OPACITY_THRESH) {
+               gp_draw_stroke_buffer_fill(points, totpoints, fill_ink);
+       }
 }
 
 /* --------- 2D Stroke Drawing Helpers --------- */
 /* change in parameter list */
-static void gp_calc_2d_stroke_fxy(float pt[3], short sflag, int offsx, int offsy, int winx, int winy, float r_co[2])
+static void gp_calc_2d_stroke_fxy(const float pt[3], short sflag, int offsx, int offsy, int winx, int winy, float r_co[2])
 {
        if (sflag & GP_STROKE_2DSPACE) {
                r_co[0] = pt[0];
@@ -210,203 +311,141 @@ static void gp_calc_2d_stroke_fxy(float pt[3], short sflag, int offsx, int offsy
 /* draw a 2D buffer stroke in "volumetric" style
  * NOTE: the stroke buffer doesn't have any coordinate offsets/transforms
  */
-static void gp_draw_stroke_volumetric_buffer(tGPspoint *points, int totpoints, short thickness,
-                                             short dflag, short UNUSED(sflag), float ink[4])
+static void gp_draw_stroke_volumetric_buffer(const tGPspoint *points, int totpoints, short thickness,
+                                             short dflag, const float ink[4])
 {
-       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... */
-               gp_set_tpoint_color(pt, ink);
-               gluDisk(qobj, 0.0,  pt->pressure * thickness, 32, 1);
-               
-               
-               modelview[3][0] = modelview[3][1] = 0.0f;
+
+       VertexFormat *format = immVertexFormat();
+       unsigned int pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 2, KEEP_FLOAT);
+       unsigned int size = VertexFormat_add_attrib(format, "size", COMP_F32, 1, KEEP_FLOAT);
+       unsigned int color = VertexFormat_add_attrib(format, "color", COMP_U8, 4, NORMALIZE_INT_TO_FLOAT);
+
+       immBindBuiltinProgram(GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR);
+       GPU_enable_program_point_size();
+       immBegin(PRIM_POINTS, totpoints);
+
+       const tGPspoint *pt = points;
+       for (int i = 0; i < totpoints; i++, pt++) {
+               gp_set_tpoint_varying_color(pt, ink, color);
+               immAttrib1f(size, pt->pressure * thickness); /* TODO: scale based on view transform (zoom level) */
+               immVertex2f(pos, pt->x, pt->y);
        }
 
-       glPopMatrix();
-       gluDeleteQuadric(qobj);
+       immEnd();
+       immUnbindProgram();
+       GPU_disable_program_point_size();
 }
 
 /* draw a 2D strokes in "volumetric" style */
-static void gp_draw_stroke_volumetric_2d(bGPDspoint *points, int totpoints, short thickness,
-                                         short dflag, short sflag,
+static void gp_draw_stroke_volumetric_2d(const bGPDspoint *points, int totpoints, short thickness,
+                                         short UNUSED(dflag), short sflag,
                                          int offsx, int offsy, int winx, int winy,
-                                         float diff_mat[4][4], float ink[4])
+                                         const float diff_mat[4][4], const float ink[4])
 {
-       GLUquadricObj *qobj = gluNewQuadric();
-       float modelview[4][4];
-       float baseloc[3];
-       float scalefac = 1.0f;
-       
-       bGPDspoint *pt;
-       int i;
-       float fpt[3];
-       
-       /* 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
-        * else assumes 1 unit = 1 pixel. Otherwise, we only get a massive blob.
-        */
-       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++) {
-               /* color of point */
-               gp_set_point_color(pt, ink);
-
-               /* set the transformed position */
+       VertexFormat *format = immVertexFormat();
+       unsigned int pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 2, KEEP_FLOAT);
+       unsigned int size = VertexFormat_add_attrib(format, "size", COMP_F32, 1, KEEP_FLOAT);
+       unsigned int color = VertexFormat_add_attrib(format, "color", COMP_U8, 4, NORMALIZE_INT_TO_FLOAT);
+
+       immBindBuiltinProgram(GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR);
+       GPU_enable_program_point_size();
+       immBegin(PRIM_POINTS, totpoints);
+
+       const bGPDspoint *pt = points;
+       for (int i = 0; i < totpoints; i++, pt++) {
+               /* transform position to 2D */
                float co[2];
-               
+               float fpt[3];
+
                mul_v3_m4v3(fpt, diff_mat, &pt->x);
                gp_calc_2d_stroke_fxy(fpt, 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);
+
+               gp_set_point_varying_color(pt, ink, color);
+               immAttrib1f(size, pt->pressure * thickness); /* TODO: scale based on view transform */
+               immVertex2f(pos, co[0], co[1]);
        }
-       
-       glPopMatrix();
-       gluDeleteQuadric(qobj);
+
+       immEnd();
+       immUnbindProgram();
+       GPU_disable_program_point_size();
 }
 
 /* draw a 3D stroke in "volumetric" style */
 static void gp_draw_stroke_volumetric_3d(
-        bGPDspoint *points, int totpoints, short thickness,
-        short UNUSED(dflag), short UNUSED(sflag), float diff_mat[4][4], float ink[4])
+        const bGPDspoint *points, int totpoints, short thickness,
+        const float ink[4])
 {
-       GLUquadricObj *qobj = gluNewQuadric();
-       
-       float base_modelview[4][4], modelview[4][4];
-       float base_loc[3];
-       
-       bGPDspoint *pt;
-       int i;
-       float fpt[3];
-       
-       /* 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
-        *   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++) {
-               /* color of point */
-               gp_set_point_color(pt, ink);
-
-               mul_v3_m4v3(fpt, diff_mat, &pt->x);
-
-               /* apply translation to base_modelview, so that the translated point is put in the right place */
-               translate_m4(base_modelview, fpt[0], fpt[1], fpt[2]);
-               
-               /* 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);
+       VertexFormat *format = immVertexFormat();
+       unsigned int pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 3, KEEP_FLOAT);
+       unsigned int size = VertexFormat_add_attrib(format, "size", COMP_F32, 1, KEEP_FLOAT);
+       unsigned int color = VertexFormat_add_attrib(format, "color", COMP_U8, 4, NORMALIZE_INT_TO_FLOAT);
+
+       immBindBuiltinProgram(GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR);
+       GPU_enable_program_point_size();
+       immBegin(PRIM_POINTS, totpoints);
+
+       const bGPDspoint *pt = points;
+       for (int i = 0; i < totpoints && pt; i++, pt++) {
+               gp_set_point_varying_color(pt, ink, color);             
+               immAttrib1f(size, pt->pressure * thickness); /* TODO: scale based on view transform */
+               immVertex3fv(pos, &pt->x);                   /* we can adjust size in vertex shader based on view/projection! */
        }
-       
-       glPopMatrix();
-       gluDeleteQuadric(qobj);
+
+       immEnd();
+       immUnbindProgram();
+       GPU_disable_program_point_size();
 }
 
 
 /* --------------- Stroke Fills ----------------- */
 
 /* Get points of stroke always flat to view not affected by camera view or view position */
-static void gp_stroke_2d_flat(bGPDspoint *points, int totpoints, float(*points2d)[2], int *r_direction)
+static void gp_stroke_2d_flat(const bGPDspoint *points, int totpoints, float(*points2d)[2], int *r_direction)
 {
-       bGPDspoint *pt0 = &points[0];
-       bGPDspoint *pt1 = &points[1];
-       bGPDspoint *pt3 = &points[(int)(totpoints * 0.75)];
-       
+       const bGPDspoint *pt0 = &points[0];
+       const bGPDspoint *pt1 = &points[1];
+       const bGPDspoint *pt3 = &points[(int)(totpoints * 0.75)];
+
        float locx[3];
        float locy[3];
        float loc3[3];
        float normal[3];
-       
+
        /* local X axis (p0 -> p1) */
        sub_v3_v3v3(locx, &pt1->x, &pt0->x);
-       
+
        /* point vector at 3/4 */
        sub_v3_v3v3(loc3, &pt3->x, &pt0->x);
-       
+
        /* vector orthogonal to polygon plane */
        cross_v3_v3v3(normal, locx, loc3);
-       
+
        /* local Y axis (cross to normal/x axis) */
        cross_v3_v3v3(locy, normal, locx);
-       
+
        /* Normalize vectors */
        normalize_v3(locx);
        normalize_v3(locy);
-       
+
        /* Get all points in local space */
        for (int i = 0; i < totpoints; i++) {
-               bGPDspoint *pt = &points[i];
+               const bGPDspoint *pt = &points[i];
                float loc[3];
-               
+
                /* Get local space using first point as origin */
                sub_v3_v3v3(loc, &pt->x, &pt0->x);
-               
+
                points2d[i][0] = dot_v3v3(loc, locx);
                points2d[i][1] = dot_v3v3(loc, locy);
        }
-       
+
        /* Concave (-1), Convex (1), or Autodetect (0)? */
        *r_direction = (int)locy[2];
 }
@@ -416,14 +455,14 @@ static void gp_stroke_2d_flat(bGPDspoint *points, int totpoints, float(*points2d
 static void gp_triangulate_stroke_fill(bGPDstroke *gps)
 {
        BLI_assert(gps->totpoints >= 3);
-       
+
        /* allocate memory for temporary areas */
        gps->tot_triangles = gps->totpoints - 2;
        unsigned int (*tmp_triangles)[3] = MEM_mallocN(sizeof(*tmp_triangles) * gps->tot_triangles, "GP Stroke temp triangulation");
        float (*points2d)[2] = MEM_mallocN(sizeof(*points2d) * gps->totpoints, "GP Stroke temp 2d points");
-       
+
        int direction = 0;
-       
+
        /* convert to 2d and triangulate */
        gp_stroke_2d_flat(gps->points, gps->totpoints, points2d, &direction);
        BLI_polyfill_calc((const float(*)[2])points2d, (unsigned int)gps->totpoints, direction, (unsigned int(*)[3])tmp_triangles);
@@ -438,7 +477,7 @@ static void gp_triangulate_stroke_fill(bGPDstroke *gps)
                else {
                        gps->triangles = MEM_recallocN(gps->triangles, sizeof(*gps->triangles) * gps->tot_triangles);
                }
-               
+
                for (int i = 0; i < gps->tot_triangles; i++) {
                        bGPDtriangle *stroke_triangle = &gps->triangles[i];
                        stroke_triangle->v1 = tmp_triangles[i][0];
@@ -450,15 +489,15 @@ static void gp_triangulate_stroke_fill(bGPDstroke *gps)
                /* No triangles needed - Free anything allocated previously */
                if (gps->triangles)
                        MEM_freeN(gps->triangles);
-                       
+
                gps->triangles = NULL;
        }
-       
+
        /* disable recalculation flag */
        if (gps->flag & GP_STROKE_RECALC_CACHES) {
                gps->flag &= ~GP_STROKE_RECALC_CACHES;
        }
-       
+
        /* clear memory */
        if (tmp_triangles) MEM_freeN(tmp_triangles);
        if (points2d) MEM_freeN(points2d);
@@ -468,42 +507,55 @@ static void gp_triangulate_stroke_fill(bGPDstroke *gps)
 /* draw fills for shapes */
 static void gp_draw_stroke_fill(
         bGPdata *gpd, bGPDstroke *gps,
-        int offsx, int offsy, int winx, int winy, float diff_mat[4][4])
+        int offsx, int offsy, int winx, int winy, const float diff_mat[4][4], const float color[4])
 {
-       bGPDpalettecolor *palcolor;
-       int i;
        float fpt[3];
 
        BLI_assert(gps->totpoints >= 3);
 
-       palcolor = ED_gpencil_stroke_getcolor(gpd, gps);
+       bGPDpalettecolor *palcolor = ED_gpencil_stroke_getcolor(gpd, gps);
 
        /* Triangulation fill if high quality flag is enabled */
        if (palcolor->flag & PC_COLOR_HQ_FILL) {
-               bGPDtriangle *stroke_triangle;
-               bGPDspoint *pt;
-
                /* Calculate triangles cache for filling area (must be done only after changes) */
                if ((gps->flag & GP_STROKE_RECALC_CACHES) || (gps->tot_triangles == 0) || (gps->triangles == NULL)) {
                        gp_triangulate_stroke_fill(gps);
                }
-               /* Draw all triangles for filling the polygon (cache must be calculated before) */
                BLI_assert(gps->tot_triangles >= 1);
-               glBegin(GL_TRIANGLES);
-               for (i = 0, stroke_triangle = gps->triangles; i < gps->tot_triangles; i++, stroke_triangle++) {
+
+               unsigned int pos;
+               if (gps->flag & GP_STROKE_3DSPACE) {
+                       pos = VertexFormat_add_attrib(immVertexFormat(), "pos", COMP_F32, 3, KEEP_FLOAT);
+                       immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
+               }
+               else {
+                       pos = VertexFormat_add_attrib(immVertexFormat(), "pos", COMP_F32, 2, KEEP_FLOAT);
+                       immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
+               }
+
+               immUniformColor4fv(color);
+
+               /* Draw all triangles for filling the polygon (cache must be calculated before) */
+               immBegin(PRIM_TRIANGLES, gps->tot_triangles * 3);
+               /* TODO: use batch instead of immediate mode, to share vertices */
+
+               bGPDtriangle *stroke_triangle = gps->triangles;
+               bGPDspoint *pt;
+
+               for (int i = 0; i < gps->tot_triangles; i++, stroke_triangle++) {
                        if (gps->flag & GP_STROKE_3DSPACE) {
                                /* vertex 1 */
                                pt = &gps->points[stroke_triangle->v1];
                                mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                               glVertex3fv(fpt);
+                               immVertex3fv(pos, fpt);
                                /* vertex 2 */
                                pt = &gps->points[stroke_triangle->v2];
                                mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                               glVertex3fv(fpt);
+                               immVertex3fv(pos, fpt);
                                /* vertex 3 */
                                pt = &gps->points[stroke_triangle->v3];
                                mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                               glVertex3fv(fpt);
+                               immVertex3fv(pos, fpt);
                        }
                        else {
                                float co[2];
@@ -511,49 +563,22 @@ static void gp_draw_stroke_fill(
                                pt = &gps->points[stroke_triangle->v1];
                                mul_v3_m4v3(fpt, diff_mat, &pt->x);
                                gp_calc_2d_stroke_fxy(fpt, gps->flag, offsx, offsy, winx, winy, co);
-                               glVertex2fv(co);
+                               immVertex2fv(pos, co);
                                /* vertex 2 */
                                pt = &gps->points[stroke_triangle->v2];
                                mul_v3_m4v3(fpt, diff_mat, &pt->x);
                                gp_calc_2d_stroke_fxy(fpt, gps->flag, offsx, offsy, winx, winy, co);
-                               glVertex2fv(co);
+                               immVertex2fv(pos, co);
                                /* vertex 3 */
                                pt = &gps->points[stroke_triangle->v3];
                                mul_v3_m4v3(fpt, diff_mat, &pt->x);
                                gp_calc_2d_stroke_fxy(fpt, gps->flag, offsx, offsy, winx, winy, co);
-                               glVertex2fv(co);
-                       }
-               }
-               glEnd();
-       }
-       else {
-               /* 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.
-               *
-               * We keep this legacy implementation around despite now having the high quality
-               * fills, as this is necessary for keeping everything working nicely for files
-               * created using old versions of Blender which may have depended on the artifacts
-               * the old fills created.
-               */
-               bGPDspoint *pt;
-
-               glBegin(GL_POLYGON);
-               for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
-                       if (gps->flag & GP_STROKE_3DSPACE) {
-                               mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                               glVertex3fv(fpt);
-                       }
-                       else {
-                               float co[2];
-                               mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                               gp_calc_2d_stroke_fxy(fpt, gps->flag, offsx, offsy, winx, winy, co);
-                               glVertex2fv(co);
+                               immVertex2fv(pos, co);
                        }
                }
 
-               glEnd();
+               immEnd();
+               immUnbindProgram();
        }
 }
 
@@ -561,153 +586,163 @@ static void gp_draw_stroke_fill(
 
 /* draw a given stroke - just a single dot (only one point) */
 static void gp_draw_stroke_point(
-        bGPDspoint *points, short thickness, short dflag, short sflag,
-        int offsx, int offsy, int winx, int winy, float diff_mat[4][4], float ink[4])
+        const bGPDspoint *points, short thickness, short UNUSED(dflag), short sflag,
+        int offsx, int offsy, int winx, int winy, const float diff_mat[4][4], const float ink[4])
 {
-       float fpt[3];
-       bGPDspoint *pt = &points[0];
-
-       /* color of point */
-       gp_set_point_color(pt, ink);
+       const bGPDspoint *pt = points;
 
-       /* set point thickness (since there's only one of these) */
-       glPointSize((float)(thickness + 2) * points->pressure);
-       
        /* get final position using parent matrix */
+       float fpt[3];
        mul_v3_m4v3(fpt, diff_mat, &pt->x);
 
-       /* draw point */
+       VertexFormat *format = immVertexFormat();
+       unsigned int pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 3, KEEP_FLOAT);
+
        if (sflag & GP_STROKE_3DSPACE) {
-               glBegin(GL_POINTS);
-               glVertex3fv(fpt);
-               glEnd();
+               immBindBuiltinProgram(GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA);
        }
        else {
-               float co[2];
-               
-               /* get coordinates of point */
+               immBindBuiltinProgram(GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA);
+
+               /* get 2D coordinates of point */
+               float co[3] = { 0.0f };
                gp_calc_2d_stroke_fxy(fpt, 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
-                */
-               if ((thickness < GP_DRAWTHICKNESS_SPECIAL) ||
-                   ((dflag & GP_DRAWDATA_IEDITHACK) && (sflag & GP_STROKE_2DSPACE)))
-               {
-                       glBegin(GL_POINTS);
-                       glVertex2fv(co);
-                       glEnd();
-               }
-               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);
-                       
-                       /* need to translate drawing position, but must reset after too! */
-                       glTranslate2fv(co);
-                       gluDisk(qobj, 0.0,  thickness, 32, 1);
-                       glTranslatef(-co[0], -co[1], 0.0);
-                       
-                       gluDeleteQuadric(qobj);
-               }
+               copy_v3_v3(fpt, co);
        }
+
+       gp_set_point_uniform_color(pt, ink);
+       /* set point thickness (since there's only one of these) */
+       immUniform1f("size", (float)(thickness + 2) * pt->pressure);
+
+       immBegin(PRIM_POINTS, 1);
+       immVertex3fv(pos, fpt);
+       immEnd();
+
+       immUnbindProgram();
 }
 
 /* draw a given stroke in 3d (i.e. in 3d-space), using simple ogl lines */
-static void gp_draw_stroke_3d(bGPDspoint *points, int totpoints, short thickness, bool debug,
-                              short UNUSED(sflag), float diff_mat[4][4], float ink[4], bool cyclic)
+static void gp_draw_stroke_3d(const bGPDspoint *points, int totpoints, short thickness, bool UNUSED(debug),
+                              short UNUSED(sflag), const float diff_mat[4][4], const float ink[4], bool cyclic)
 {
-       bGPDspoint *pt, *pt2;
        float curpressure = points[0].pressure;
-       int i;
        float fpt[3];
        float cyclic_fpt[3];
+       int draw_points = 0;
+
+       /* if cyclic needs one vertex more */
+       int cyclic_add = 0;
+       if (cyclic) {
+               ++cyclic_add;
+       }
+
+
+       VertexFormat *format = immVertexFormat();
+       unsigned int pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 3, KEEP_FLOAT);
+       unsigned int color = VertexFormat_add_attrib(format, "color", COMP_U8, 4, NORMALIZE_INT_TO_FLOAT);
+
+       immBindBuiltinProgram(GPU_SHADER_3D_SMOOTH_COLOR);
+
+       /* TODO: implement this with a geometry shader to draw one continuous tapered stroke */
 
        /* draw stroke curve */
        glLineWidth(max_ff(curpressure * thickness, 1.0f));
-       glBegin(GL_LINE_STRIP);
-       for (i = 0, pt = points; i < totpoints && pt; i++, pt++) {
-               gp_set_point_color(pt, ink);
+       immBeginAtMost(PRIM_LINE_STRIP, totpoints + cyclic_add);
+       const bGPDspoint *pt = points;
+       for (int i = 0; i < totpoints; i++, pt++) {
+               gp_set_point_varying_color(pt, ink, color);
 
                /* if there was a significant pressure change, stop the curve, change the thickness of the stroke,
                 * and continue drawing again (since line-width cannot change in middle of GL_LINE_STRIP)
                 * Note: we want more visible levels of pressures when thickness is bigger.
                 */
                if (fabsf(pt->pressure - curpressure) > 0.2f / (float)thickness) {
-                       glEnd();
+                       /* if the pressure changes before get at least 2 vertices, need to repeat last point to avoid assert in immEnd() */
+                       if (draw_points < 2) {
+                               const bGPDspoint *pt2 = pt - 1;
+                               mul_v3_m4v3(fpt, diff_mat, &pt2->x);
+                               immVertex3fv(pos, fpt);
+                       }
+                       immEnd();
+                       draw_points = 0;
+
                        curpressure = pt->pressure;
                        glLineWidth(max_ff(curpressure * thickness, 1.0f));
-                       glBegin(GL_LINE_STRIP);
-                       
+                       immBeginAtMost(PRIM_LINE_STRIP, totpoints - i + 1 + cyclic_add);
+
                        /* need to roll-back one point to ensure that there are no gaps in the stroke */
                        if (i != 0) { 
-                               pt2 = pt - 1;
+                               const bGPDspoint *pt2 = pt - 1;
                                mul_v3_m4v3(fpt, diff_mat, &pt2->x);
-                               glVertex3fv(fpt);
+                               gp_set_point_varying_color(pt2, ink, color);
+                               immVertex3fv(pos, fpt);
+                               ++draw_points;
                        }
-                       
-                       /* now the point we want... */
-                       mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                       glVertex3fv(fpt);
                }
-               else {
-                       mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                       glVertex3fv(fpt);
-               }
-               /* saves first point to use in cyclic */
-               if (i == 0) {
+
+               /* now the point we want */
+               mul_v3_m4v3(fpt, diff_mat, &pt->x);
+               immVertex3fv(pos, fpt);
+               ++draw_points;
+
+               if (cyclic && i == 0) {
+                       /* save first point to use in cyclic */
                        copy_v3_v3(cyclic_fpt, fpt);
                }
        }
-       /* if cyclic draw line to first point */
+
        if (cyclic) {
-               glVertex3fv(cyclic_fpt);
+               /* draw line to first point to complete the cycle */
+               immVertex3fv(pos, cyclic_fpt);
+               ++draw_points;
        }
-       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) {
-               glPointSize((float)(thickness + 2));
-               
-               glBegin(GL_POINTS);
-               for (i = 0, pt = points; i < totpoints && pt; i++, pt++) {
-                       mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                       glVertex3fv(fpt);
-               }
-               glEnd();
 
+       /* if less of two points, need to repeat last point to avoid assert in immEnd() */
+       if (draw_points < 2) {
+               const bGPDspoint *pt2 = pt - 1;
+               mul_v3_m4v3(fpt, diff_mat, &pt2->x);
+               gp_set_point_varying_color(pt2, ink, color);
+               immVertex3fv(pos, fpt);
        }
+
+       immEnd();
+       immUnbindProgram();
 }
 
 /* ----- Fancy 2D-Stroke Drawing ------ */
 
 /* draw a given stroke in 2d */
-static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness_s, short dflag, short sflag,
-                              bool debug, int offsx, int offsy, int winx, int winy, float diff_mat[4][4], float ink[4])
+static void gp_draw_stroke_2d(const bGPDspoint *points, int totpoints, short thickness_s, short dflag, short sflag,
+                              bool UNUSED(debug), int offsx, int offsy, int winx, int winy, const float diff_mat[4][4], const float ink[4])
 {
        /* 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;
        }
-       
+
+       /* TODO: fancy++ with the magic of shaders */
+
        /* tessellation code - draw stroke as series of connected quads with connection
         * edges rotated to minimize shrinking artifacts, and rounded endcaps
         */
        {
-               bGPDspoint *pt1, *pt2;
+               const bGPDspoint *pt1, *pt2;
                float s0[2], s1[2];     /* segment 'center' points */
                float pm[2];  /* normal from previous segment. */
                int i;
                float fpt[3];
-               
-               glShadeModel(GL_FLAT);
-               glBegin(GL_QUADS);
+
+               VertexFormat *format = immVertexFormat();
+               unsigned int pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 2, KEEP_FLOAT);
+               unsigned int color = VertexFormat_add_attrib(format, "color", COMP_U8, 4, NORMALIZE_INT_TO_FLOAT);
+
+               immBindBuiltinProgram(GPU_SHADER_2D_FLAT_COLOR);
+#ifdef WITH_GL_PROFILE_COMPAT
+               immBegin(PRIM_QUADS_XXX, (totpoints - 2) * 4 + 12);
 
                /* get x and y coordinates from first point */
                mul_v3_m4v3(fpt, diff_mat, &points->x);
@@ -722,19 +757,19 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
                        /* get x and y coordinates from point2 (point1 has already been computed in previous iteration). */
                        mul_v3_m4v3(fpt, diff_mat, &pt2->x);
                        gp_calc_2d_stroke_fxy(fpt, 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);
-                       
+
                        /* color of point */
-                       gp_set_point_color(pt1, ink);
+                       gp_set_point_varying_color(pt1, ink, color);
 
                        /* if the first segment, start of segment is segment's normal */
                        if (i == 0) {
@@ -745,40 +780,40 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
                                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);
-                               
+
+                               immVertex2fv(pos, t0);
+                               immVertex2fv(pos, 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);
-                               glVertex2fv(t0);
-                               glVertex2fv(t1);
+                               immVertex2fv(pos, t1);
+                               immVertex2fv(pos, t0);
+                               immVertex2fv(pos, t0);
+                               immVertex2fv(pos, t1);
                        }
                        /* if not the first segment, use bisector of angle between segments */
                        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
                                 *  - as basis, use just pthick * bisector gradient
                                 *      - if cross-section not as thick as it should be, add extra padding to fix it
@@ -787,49 +822,48 @@ 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);
+                               immVertex2fv(pos, t1);
+                               immVertex2fv(pos, t0);
+                               immVertex2fv(pos, t0);
+                               immVertex2fv(pos, 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);
-                               
+
                                /* color of point */
-                               gp_set_point_color(pt2, ink);
+                               gp_set_point_varying_color(pt2, ink, color);
 
                                /* 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);
-                               
-                               
+                               immVertex2fv(pos, t1);
+                               immVertex2fv(pos, t0);
+                               immVertex2fv(pos, t0);
+                               immVertex2fv(pos, t1);
+
                                /* draw end cap as last step
                                 *      - make points slightly closer to center (about halfway across)
                                 */
@@ -837,14 +871,14 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
                                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);
+
+                               immVertex2fv(pos, t1);
+                               immVertex2fv(pos, t0);
                        }
                        
                        /* store computed point2 coordinates as point1 ones of next segment. */
@@ -852,27 +886,10 @@ static void gp_draw_stroke_2d(bGPDspoint *points, int totpoints, short thickness
                        /* store stroke's 'natural' normal for next stroke to use */
                        copy_v2_v2(pm, m2);
                }
-               
-               glEnd();
-               glShadeModel(GL_SMOOTH);
-       }
-       
-       /* draw debug points of curve on top? (original stroke points) */
-       if (debug) {
-               bGPDspoint *pt;
-               int i;
-               float fpt[3];
+#endif
 
-               glPointSize((float)(thickness_s + 2));
-               
-               glBegin(GL_POINTS);
-               for (i = 0, pt = points; i < totpoints && pt; i++, pt++) {
-                       float co[2];
-                       mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                       gp_calc_2d_stroke_fxy(fpt, sflag, offsx, offsy, winx, winy, co);
-                       glVertex2fv(co);
-               }
-               glEnd();
+               immEnd();
+               immUnbindProgram();
        }
 }
 
@@ -887,41 +904,41 @@ 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;
 }
 
 /* draw a set of strokes */
 static void gp_draw_strokes(
-        bGPdata *gpd, bGPDframe *gpf, int offsx, int offsy, int winx, int winy, int dflag,
+        bGPdata *gpd, const bGPDframe *gpf, int offsx, int offsy, int winx, int winy, int dflag,
         bool debug, short lthick, const float opacity, const float tintcolor[4],
-        const bool onion, const bool custonion, float diff_mat[4][4])
+        const bool onion, const bool custonion, const float diff_mat[4][4])
 {
-       bGPDstroke *gps;
        float tcolor[4];
        float tfill[4];
        short sthickness;
        float ink[4];
 
-       for (gps = gpf->strokes.first; gps; gps = gps->next) {
+       GPU_enable_program_point_size();
+
+       for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
                /* check if stroke can be drawn */
                if (gp_can_draw_stroke(gps, dflag) == false) {
                        continue;
@@ -939,6 +956,10 @@ static void gp_draw_strokes(
                /* calculate thickness */
                sthickness = gps->thickness + lthick;
 
+               if (sthickness <= 0) {
+                       continue;
+               }
+
                /* check which stroke-drawer to use */
                if (dflag & GP_DRAWDATA_ONLY3D) {
                        const int no_xray = (dflag & GP_DRAWDATA_NO_XRAY);
@@ -952,10 +973,6 @@ static void gp_draw_strokes(
                                /* first arg is normally rv3d->dist, but this isn't
                                 * available here and seems to work quite well without */
                                bglPolygonOffset(1.0f, 1.0f);
-#if 0
-                               glEnable(GL_POLYGON_OFFSET_LINE);
-                               glPolygonOffset(-1.0f, -1.0f);
-#endif
                        }
 
                        /* 3D Fill */
@@ -965,19 +982,20 @@ static void gp_draw_strokes(
                                interp_v3_v3v3(tfill, palcolor->fill, tintcolor, tintcolor[3]);
                                tfill[3] = palcolor->fill[3] * opacity;
                                if (tfill[3] > GPENCIL_ALPHA_OPACITY_THRESH) {
+                                       const float *color;
                                        if (!onion) {
-                                               glColor4fv(tfill);
+                                               color = tfill;
                                        }
                                        else {
                                                if (custonion) {
-                                                       glColor4fv(tintcolor);
+                                                       color = tintcolor;
                                                }
                                                else {
                                                        ARRAY_SET_ITEMS(tfill, UNPACK3(palcolor->fill), tintcolor[3]);
-                                                       glColor4fv(tfill);
+                                                       color = tfill;
                                                }
                                        }
-                                       gp_draw_stroke_fill(gpd, gps, offsx, offsy, winx, winy, diff_mat);
+                                       gp_draw_stroke_fill(gpd, gps, offsx, offsy, winx, winy, diff_mat, color);
                                }
                        }
 
@@ -999,7 +1017,7 @@ static void gp_draw_strokes(
                        }
                        if (palcolor->flag & PC_COLOR_VOLUMETRIC) {
                                /* volumetric stroke drawing */
-                               gp_draw_stroke_volumetric_3d(gps->points, gps->totpoints, sthickness, dflag, gps->flag, diff_mat, ink);
+                               gp_draw_stroke_volumetric_3d(gps->points, gps->totpoints, sthickness, ink);
                        }
                        else {
                                /* 3D Lines - OpenGL primitives-based */
@@ -1017,10 +1035,6 @@ static void gp_draw_strokes(
                                glDisable(GL_DEPTH_TEST);
 
                                bglPolygonOffset(0.0, 0.0);
-#if 0
-                               glDisable(GL_POLYGON_OFFSET_LINE);
-                               glPolygonOffset(0, 0);
-#endif
                        }
                }
                else {
@@ -1030,20 +1044,21 @@ static void gp_draw_strokes(
                                interp_v3_v3v3(tfill, palcolor->fill, tintcolor, tintcolor[3]);
                                tfill[3] = palcolor->fill[3] * opacity;
                                if (tfill[3] > GPENCIL_ALPHA_OPACITY_THRESH) {
+                                       const float *color;
                                        if (!onion) {
-                                               glColor4fv(tfill);
+                                               color = tfill;
                                        }
                                        else {
                                                if (custonion) {
-                                                       glColor4fv(tintcolor);
+                                                       color = tintcolor;
                                                }
                                                else {
                                                        ARRAY_SET_ITEMS(tfill, palcolor->fill[0], palcolor->fill[1], palcolor->fill[2],
                                                                        tintcolor[3]);
-                                                       glColor4fv(tfill);
+                                                       color = tfill;
                                                }
                                        }
-                                       gp_draw_stroke_fill(gpd, gps, offsx, offsy, winx, winy, diff_mat);
+                                       gp_draw_stroke_fill(gpd, gps, offsx, offsy, winx, winy, diff_mat, color);
                                }
                        }
 
@@ -1081,15 +1096,15 @@ static void gp_draw_strokes(
                        }
                }
        }
+
+       GPU_disable_program_point_size();
 }
 
 /* Draw selected verts for strokes being edited */
 static void gp_draw_strokes_edit(
-        bGPdata *gpd, bGPDframe *gpf, int offsx, int offsy, int winx, int winy, short dflag,
-        short lflag, float diff_mat[4][4], float alpha)
+        bGPdata *gpd, const bGPDframe *gpf, int offsx, int offsy, int winx, int winy, short dflag,
+        short lflag, const float diff_mat[4][4], float alpha)
 {
-       bGPDstroke *gps;
-       
        /* if alpha 0 do not draw */
        if (alpha == 0.0f)
                return;
@@ -1103,36 +1118,28 @@ static void gp_draw_strokes_edit(
                        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);
-#if 0
-                       glEnable(GL_POLYGON_OFFSET_LINE);
-                       glPolygonOffset(-1.0f, -1.0f);
-#endif
                }
        }
-       
-       
-       /* draw stroke verts */
-       for (gps = gpf->strokes.first; gps; gps = gps->next) {
-               bGPDspoint *pt;
-               float vsize, bsize;
-               int i;
-               float fpt[3];
 
+       GPU_enable_program_point_size();
+
+       /* draw stroke verts */
+       for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
                /* 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;
-               
+
                /* verify palette color lock */
                {
                        bGPDpalettecolor *palcolor = ED_gpencil_stroke_getcolor(gpd, gps);
@@ -1151,7 +1158,8 @@ static void gp_draw_strokes_edit(
                 *   they stand out more.
                 * - We use the theme setting for size of the unselected verts
                 */
-               bsize = UI_GetThemeValuef(TH_GP_VERTEX_SIZE);
+               float bsize = UI_GetThemeValuef(TH_GP_VERTEX_SIZE);
+               float vsize;
                if ((int)bsize > 8) {
                        vsize = 10.0f;
                        bsize = 8.0f;
@@ -1159,89 +1167,83 @@ static void gp_draw_strokes_edit(
                else {
                        vsize = bsize + 2;
                }
-               
-               /* First Pass: Draw all the verts (i.e. these become the unselected state) */
+
                /* for now, we assume that the base color of the points is not too close to the real color */
                /* set color using palette */
                bGPDpalettecolor *palcolor = ED_gpencil_stroke_getcolor(gpd, gps);
-               glColor3fv(palcolor->color);
 
-               glPointSize(bsize);
-               
-               glBegin(GL_POINTS);
-               for (i = 0, pt = gps->points; i < gps->totpoints && pt; i++, pt++) {
+               float selectColor[4];
+               UI_GetThemeColor3fv(TH_GP_VERTEX_SELECT, selectColor);
+               selectColor[3] = alpha;
+
+               VertexFormat *format = immVertexFormat();
+               unsigned int pos; /* specified later */
+               unsigned int size = VertexFormat_add_attrib(format, "size", COMP_F32, 1, KEEP_FLOAT);
+               unsigned int color = VertexFormat_add_attrib(format, "color", COMP_F32, 3, KEEP_FLOAT);
+
+               if (gps->flag & GP_STROKE_3DSPACE) {
+                       pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 3, KEEP_FLOAT);
+                       immBindBuiltinProgram(GPU_SHADER_3D_POINT_VARYING_SIZE_VARYING_COLOR);
+               }
+               else {
+                       pos = VertexFormat_add_attrib(format, "pos", COMP_F32, 2, KEEP_FLOAT);
+                       immBindBuiltinProgram(GPU_SHADER_2D_POINT_VARYING_SIZE_VARYING_COLOR);
+               }
+
+               immBegin(PRIM_POINTS, gps->totpoints);
+
+               /* Draw start and end point differently if enabled stroke direction hint */
+               bool show_direction_hint = (gpd->flag & GP_DATA_SHOW_DIRECTION) && (gps->totpoints > 1);
+
+               /* Draw all the stroke points (selected or not) */
+               bGPDspoint *pt = gps->points;
+               float fpt[3];
+               for (int i = 0; i < gps->totpoints; i++, pt++) {
+                       /* size and color first */
+                       if (show_direction_hint && i == 0) {
+                               /* start point in green bigger */
+                               immAttrib3f(color, 0.0f, 1.0f, 0.0f);
+                               immAttrib1f(size, vsize + 4);
+                       }
+                       else if (show_direction_hint && (i == gps->totpoints - 1)) {
+                               /* end point in red smaller */
+                               immAttrib3f(color, 1.0f, 0.0f, 0.0f);
+                               immAttrib1f(size, vsize + 1);
+                       }
+                       else if (pt->flag & GP_SPOINT_SELECT) {
+                               immAttrib3fv(color, selectColor);
+                               immAttrib1f(size, vsize);
+                       }
+                       else {
+                               immAttrib3fv(color, palcolor->color);
+                               immAttrib1f(size, bsize);
+                       }
+
+                       /* then position */
                        if (gps->flag & GP_STROKE_3DSPACE) {
                                mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                               glVertex3fv(fpt);
+                               immVertex3fv(pos, fpt);
                        }
                        else {
                                float co[2];
                                mul_v3_m4v3(fpt, diff_mat, &pt->x);
                                gp_calc_2d_stroke_fxy(fpt, gps->flag, offsx, offsy, winx, winy, co);
-                               glVertex2fv(co);
+                               immVertex2fv(pos, co);
                        }
                }
-               glEnd();
-               
-               
-               /* Second Pass: Draw only verts which are selected */
-               float curColor[4];
-               UI_GetThemeColor3fv(TH_GP_VERTEX_SELECT, curColor);
-               glColor4f(curColor[0], curColor[1], curColor[2], alpha);
 
-               glPointSize(vsize);
-               
-               glBegin(GL_POINTS);
-               for (i = 0, pt = gps->points; i < gps->totpoints && pt; i++, pt++) {
-                       if (pt->flag & GP_SPOINT_SELECT) {
-                               if (gps->flag & GP_STROKE_3DSPACE) {
-                                       mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                                       glVertex3fv(fpt);
-                               }
-                               else {
-                                       float co[2];
-                                       
-                                       mul_v3_m4v3(fpt, diff_mat, &pt->x);
-                                       gp_calc_2d_stroke_fxy(fpt, gps->flag, offsx, offsy, winx, winy, co);
-                                       glVertex2fv(co);
-                               }
-                       }
-               }
-               glEnd();
-
-               /* Draw start and end point if enabled stroke direction hint */
-               if ((gpd->flag & GP_DATA_SHOW_DIRECTION) && (gps->totpoints > 1)) {
-                       bGPDspoint *p;
-                       
-                       glPointSize(vsize + 4);
-                       glBegin(GL_POINTS);
-
-                       /* start point in green bigger */
-                       glColor3f(0.0f, 1.0f, 0.0f);
-                       p = &gps->points[0];
-                       mul_v3_m4v3(fpt, diff_mat, &p->x);
-                       glVertex3fv(fpt);
-                       glEnd();
-
-                       /* end point in red smaller */
-                       glPointSize(vsize + 1);
-                       glBegin(GL_POINTS);
-
-                       glColor3f(1.0f, 0.0f, 0.0f);
-                       p = &gps->points[gps->totpoints - 1];
-                       mul_v3_m4v3(fpt, diff_mat, &p->x);
-                       glVertex3fv(fpt);
-                       glEnd();
-               }
+               immEnd();
+               immUnbindProgram();
        }
-       
-       
+
+       GPU_disable_program_point_size();
+
        /* 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);
@@ -1255,8 +1257,8 @@ static void gp_draw_strokes_edit(
 
 /* draw onion-skinning for a layer */
 static void gp_draw_onionskins(
-        bGPdata *gpd, bGPDlayer *gpl, bGPDframe *gpf, int offsx, int offsy, int winx, int winy,
-        int UNUSED(cfra), int dflag, bool debug, float diff_mat[4][4])
+        bGPdata *gpd, const bGPDlayer *gpl, const bGPDframe *gpf, int offsx, int offsy, int winx, int winy,
+        int UNUSED(cfra), int dflag, bool debug, const float diff_mat[4][4])
 {
        const float default_color[3] = {UNPACK3(U.gpencil_new_layer_col)};
        const float alpha = 1.0f;
@@ -1269,17 +1271,14 @@ static void gp_draw_onionskins(
        else {
                copy_v3_v3(color, default_color);
        }
-       
+
        if (gpl->gstep > 0) {
-               bGPDframe *gf;
-               float fac;
-               
                /* draw previous frames first */
-               for (gf = gpf->prev; gf; gf = gf->prev) {
+               for (bGPDframe *gf = gpf->prev; gf; gf = gf->prev) {
                        /* check if frame is drawable */
                        if ((gpf->framenum - gf->framenum) <= gpl->gstep) {
                                /* alpha decreases with distance from curframe index */
-                               fac = 1.0f - ((float)(gpf->framenum - gf->framenum) / (float)(gpl->gstep + 1));
+                               float fac = 1.0f - ((float)(gpf->framenum - gf->framenum) / (float)(gpl->gstep + 1));
                                color[3] = alpha * fac * 0.66f;
                                gp_draw_strokes(gpd, gf, offsx, offsy, winx, winy, dflag, debug, gpl->thickness, 1.0f, color,
                                                true, gpl->flag & GP_LAYER_GHOST_PREVCOL, diff_mat);
@@ -1299,8 +1298,7 @@ static void gp_draw_onionskins(
        else {
                /* don't draw - disabled */
        }
-       
-       
+
        /* 2) Now draw next frames */
        if (gpl->flag & GP_LAYER_GHOST_NEXTCOL) {
                copy_v3_v3(color, gpl->gcolor_next);
@@ -1308,17 +1306,14 @@ static void gp_draw_onionskins(
        else {
                copy_v3_v3(color, default_color);
        }
-       
+
        if (gpl->gstep_next > 0) {
-               bGPDframe *gf;
-               float fac;
-               
                /* now draw next frames */
-               for (gf = gpf->next; gf; gf = gf->next) {
+               for (bGPDframe *gf = gpf->next; gf; gf = gf->next) {
                        /* check if frame is drawable */
                        if ((gf->framenum - gpf->framenum) <= gpl->gstep_next) {
                                /* alpha decreases with distance from curframe index */
-                               fac = 1.0f - ((float)(gf->framenum - gpf->framenum) / (float)(gpl->gstep_next + 1));
+                               float fac = 1.0f - ((float)(gf->framenum - gpf->framenum) / (float)(gpl->gstep_next + 1));
                                color[3] = alpha * fac * 0.66f;
                                gp_draw_strokes(gpd, gf, offsx, offsy, winx, winy, dflag, debug, gpl->thickness, 1.0f, color,
                                                true, gpl->flag & GP_LAYER_GHOST_NEXTCOL, diff_mat);
@@ -1338,7 +1333,6 @@ static void gp_draw_onionskins(
        else {
                /* don't draw - disabled */
        }
-       
 }
 
 /* draw interpolate strokes (used only while operator is running) */
@@ -1376,29 +1370,27 @@ void ED_gp_draw_interpolation(tGPDinterpolate *tgpi, const int type)
 
 /* loop over gpencil data layers, drawing them */
 static void gp_draw_data_layers(
-        bGPDbrush *brush, float alpha, bGPdata *gpd,
+        const bGPDbrush *brush, float alpha, bGPdata *gpd,
         int offsx, int offsy, int winx, int winy, int cfra, int dflag)
 {
-       bGPDlayer *gpl;
        float diff_mat[4][4];
 
-       for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
-               bGPDframe *gpf;
+       for (bGPDlayer *gpl = gpd->layers.first; gpl; gpl = gpl->next) {
                /* calculate parent position */
                ED_gpencil_parent_location(gpl, diff_mat);
 
-               bool debug = (gpl->flag & GP_LAYER_DRAWDEBUG) ? true : false;
+               bool debug = (gpl->flag & GP_LAYER_DRAWDEBUG);
                short lthick = brush->thickness + gpl->thickness;
-               
+
                /* don't draw layer if hidden */
                if (gpl->flag & GP_LAYER_HIDE)
                        continue;
-               
+
                /* get frame to draw */
-               gpf = BKE_gpencil_layer_getframe(gpl, cfra, 0);
+               bGPDframe *gpf = BKE_gpencil_layer_getframe(gpl, cfra, 0);
                if (gpf == NULL)
                        continue;
-               
+
                /* set basic stroke thickness */
                glLineWidth(lthick);
                
@@ -1410,10 +1402,10 @@ static void gp_draw_data_layers(
                        if (condition) dflag |= (draw_flag_value);      \
                        else           dflag &= ~(draw_flag_value);     \
                } (void)0
-               
+
                /* xray... */
                GP_DRAWFLAG_APPLY((gpl->flag & GP_LAYER_NO_XRAY), GP_DRAWDATA_NO_XRAY);
-               
+
                /* volumetric strokes... */
                GP_DRAWFLAG_APPLY((gpl->flag & GP_LAYER_VOLUMETRIC), GP_DRAWDATA_VOLUMETRIC);
 
@@ -1437,11 +1429,11 @@ static void gp_draw_data_layers(
                         */
                        gp_draw_onionskins(gpd, gpl, gpf, offsx, offsy, winx, winy, cfra, dflag, debug, diff_mat);
                }
-               
+
                /* draw the strokes already in active frame */
                gp_draw_strokes(gpd, gpf, offsx, offsy, winx, winy, dflag, debug, gpl->thickness,
                                gpl->opacity, gpl->tintcolor, false, false, diff_mat);
-               
+
                /* Draw verts of selected strokes
                 *  - when doing OpenGL renders, we don't want to be showing these, as that ends up flickering
                 *      - locked layers can't be edited, so there's no point showing these verts
@@ -1456,16 +1448,13 @@ static void gp_draw_data_layers(
                {
                        gp_draw_strokes_edit(gpd, gpf, offsx, offsy, winx, winy, dflag, gpl->flag, diff_mat, alpha);
                }
-               
+
                /* Check if may need to draw the active stroke cache, only if this layer is the active layer
                 * that is being edited. (Stroke buffer is currently stored in gp-data)
                 */
                if (ED_gpencil_session_active() && (gpl->flag & GP_LAYER_ACTIVE) &&
                    (gpf->flag & GP_FRAME_PAINT))
                {
-                       /* Set color for drawing buffer stroke - since this may not be set yet */
-                       // glColor4fv(gpl->color);
-                       
                        /* Buffer stroke needs to be drawn with a different linestyle
                         * to help differentiate them from normal strokes.
                         * 
@@ -1474,89 +1463,84 @@ static void gp_draw_data_layers(
                         */
                        if (gpd->sflag & PC_COLOR_VOLUMETRIC) {
                                gp_draw_stroke_volumetric_buffer(gpd->sbuffer, gpd->sbuffer_size, lthick,
-                                                                dflag, gpd->sbuffer_sflag, gpd->scolor);
+                                                                dflag, gpd->scolor);
                        }
                        else {
-                               gp_draw_stroke_buffer(gpd->sbuffer, gpd->sbuffer_size, lthick, dflag, gpd->sbuffer_sflag, gpd->scolor);
+                               gp_draw_stroke_buffer(gpd->sbuffer, gpd->sbuffer_size, lthick, dflag, gpd->sbuffer_sflag, gpd->scolor, gpd->sfill);
                        }
                }
        }
 }
 
 /* draw a short status message in the top-right corner */
-static void gp_draw_status_text(bGPdata *gpd, ARegion *ar)
+static void gp_draw_status_text(const bGPdata *gpd, ARegion *ar)
 {
        rcti rect;
-       
+
        /* Cannot draw any status text when drawing OpenGL Renders */
        if (G.f & G_RENDER_OGL)
                return;
-       
+
        /* Get bounds of region - Necessary to avoid problems with region overlap */
        ED_region_visible_rect(ar, &rect);
-       
+
        /* for now, this should only be used to indicate when we are in stroke editmode */
        if (gpd->flag & GP_DATA_STROKE_EDITMODE) {
                const char *printable = IFACE_("GPencil Stroke Editing");
                float       printable_size[2];
-               int xco, yco;
-               
-               BLF_width_and_height_default(printable, BLF_DRAW_STR_DUMMY_MAX, &printable_size[0], &printable_size[1]);
-               
-               xco = (rect.xmax - U.widget_unit) - (int)printable_size[0];
-               yco = (rect.ymax - U.widget_unit);
+
+               int font_id = BLF_default();
+
+               BLF_width_and_height(font_id, printable, BLF_DRAW_STR_DUMMY_MAX, &printable_size[0], &printable_size[1]);
                
+               int xco = (rect.xmax - U.widget_unit) - (int)printable_size[0];
+               int yco = (rect.ymax - U.widget_unit);
+
                /* text label */
-               UI_ThemeColor(TH_TEXT_HI);
+               UI_FontThemeColor(font_id, TH_TEXT_HI);
 #ifdef WITH_INTERNATIONAL
                BLF_draw_default(xco, yco, 0.0f, printable, BLF_DRAW_STR_DUMMY_MAX);
 #else
                BLF_draw_default_ascii(xco, yco, 0.0f, printable, BLF_DRAW_STR_DUMMY_MAX);
 #endif
-               
+
                /* grease pencil icon... */
                // XXX: is this too intrusive?
                glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_BLEND);
-               
+
                xco -= U.widget_unit;
                yco -= (int)printable_size[1] / 2;
 
                UI_icon_draw(xco, yco, ICON_GREASEPENCIL);
-               
+
                glDisable(GL_BLEND);
        }
 }
 
 /* draw grease-pencil datablock */
 static void gp_draw_data(
-        bGPDbrush *brush, float alpha, bGPdata *gpd,
+        const bGPDbrush *brush, float alpha, bGPdata *gpd,
         int offsx, int offsy, int winx, int winy, int cfra, int dflag)
 {
-       /* reset line drawing style (in case previous user didn't reset) */
-       setlinestyle(0);
-       
        /* turn on smooth lines (i.e. anti-aliasing) */
        glEnable(GL_LINE_SMOOTH);
-       
+
        /* XXX: turn on some way of ensuring that the polygon edges get smoothed 
         *      GL_POLYGON_SMOOTH is nasty and shouldn't be used, as it ends up
         *      creating internal white rays due to the ways it accumulates stuff
         */
-       
+
        /* turn on alpha-blending */
        glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
        glEnable(GL_BLEND);
-       
+
        /* draw! */
        gp_draw_data_layers(brush, alpha, gpd, offsx, offsy, winx, winy, cfra, dflag);
-       
+
        /* turn off alpha blending, then smooth lines */
        glDisable(GL_BLEND); // alpha blending
        glDisable(GL_LINE_SMOOTH); // smooth lines
-       
-       /* restore initial gl conditions */
-       glColor4f(0, 0, 0, 1);
 }
 
 /* if we have strokes for scenes (3d view)/clips (movie clip editor)
@@ -1591,7 +1575,7 @@ static void gp_draw_data_all(Scene *scene, bGPdata *gpd, int offsx, int offsy, i
                        }
                }
        }
-       
+
        /* scene/clip data has already been drawn, only object/track data is drawn here
         * if gpd_source == gpd, we don't have any object/track data and we can skip */
        if (gpd_source == NULL || (gpd_source && gpd_source != gpd)) {
@@ -1617,28 +1601,27 @@ void ED_gpencil_draw_2dimage(const bContext *C)
        ScrArea *sa = CTX_wm_area(C);
        ARegion *ar = CTX_wm_region(C);
        Scene *scene = CTX_data_scene(C);
-       bGPdata *gpd;
+
        int offsx, offsy, sizex, sizey;
        int dflag = GP_DRAWDATA_NOSTATUS;
-       
-       gpd = ED_gpencil_data_get_active(C); // XXX
+
+       bGPdata *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;
                }
@@ -1649,7 +1632,7 @@ 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
                         */
@@ -1661,77 +1644,74 @@ void ED_gpencil_draw_2dimage(const bContext *C)
                        offsy = 0;
                        sizex = ar->winx;
                        sizey = ar->winy;
-                       
+
                        dflag |= GP_DRAWDATA_ONLYI2D;
                        break;
        }
-       
+
        if (ED_screen_animation_playing(wm)) {
                /* don't show onionskins during animation playback/scrub (i.e. it obscures the poses)
                 * OpenGL Renders (i.e. final output), or depth buffer (i.e. not real strokes)
                 */
                dflag |= GP_DRAWDATA_NO_ONIONS;
        }
-       
-       
+
        /* 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
- * Note: this gets called twice - first time with onlyv2d=1 to draw 'canvas' strokes,
- * second time with onlyv2d=0 for screen-aligned strokes */
+ * Note: this gets called twice - first time with onlyv2d=true to draw 'canvas' strokes,
+ * second time with onlyv2d=false for screen-aligned strokes */
 void ED_gpencil_draw_view2d(const bContext *C, bool onlyv2d)
 {
        wmWindowManager *wm = CTX_wm_manager(C);
        ScrArea *sa = CTX_wm_area(C);
        ARegion *ar = CTX_wm_region(C);
        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
+       bGPdata *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);
        if (ED_screen_animation_playing(wm)) dflag |= GP_DRAWDATA_NO_ONIONS;
-       
+
        gp_draw_data_all(scene, gpd, 0, 0, ar->winx, ar->winy, CFRA, dflag, sa->spacetype);
-       
+
        /* draw status text (if in screen/pixel-space) */
-       if (onlyv2d == false) {
+       if (!onlyv2d) {
                gp_draw_status_text(gpd, ar);
        }
 }
 
 /* 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 */
+ * Note: this gets called twice - first time with only3d=true to draw 3d-strokes,
+ * second time with only3d=false for screen-aligned strokes */
 void ED_gpencil_draw_view3d(wmWindowManager *wm, Scene *scene, View3D *v3d, ARegion *ar, bool only3d)
 {
-       bGPdata *gpd;
        int dflag = 0;
        RegionView3D *rv3d = ar->regiondata;
        int offsx,  offsy,  winx,  winy;
-       
+
        /* check that we have grease-pencil stuff to draw */
-       gpd = ED_gpencil_data_get_active_v3d(scene, v3d);
+       bGPdata *gpd = ED_gpencil_data_get_active_v3d(scene, v3d);
        if (gpd == NULL) return;
-       
+
        /* when rendering to the offscreen buffer we don't want to
         * deal with the camera border, otherwise map the coords to the camera border. */
        if ((rv3d->persp == RV3D_CAMOB) && !(G.f & G_RENDER_OGL)) {
                rctf rectf;
                ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &rectf, true); /* no shift */
-               
+
                offsx = iroundf(rectf.xmin);
                offsy = iroundf(rectf.ymin);
                winx  = iroundf(rectf.xmax - rectf.xmin);
@@ -1743,7 +1723,7 @@ void ED_gpencil_draw_view3d(wmWindowManager *wm, Scene *scene, View3D *v3d, AReg
                winx  = ar->winx;
                winy  = ar->winy;
        }
-       
+
        /* set flags */
        if (only3d) {
                /* 3D strokes/3D space:
@@ -1752,28 +1732,27 @@ void ED_gpencil_draw_view3d(wmWindowManager *wm, Scene *scene, View3D *v3d, AReg
                 */
                dflag |= (GP_DRAWDATA_ONLY3D | GP_DRAWDATA_NOSTATUS);
        }
-       
+
        if (v3d->flag2 & V3D_RENDER_OVERRIDE) {
                /* don't draw status text when "only render" flag is set */
                dflag |= GP_DRAWDATA_NOSTATUS;
        }
-       
+
        if ((wm == NULL) || ED_screen_animation_playing(wm)) {
                /* don't show onionskins during animation playback/scrub (i.e. it obscures the poses)
                 * OpenGL Renders (i.e. final output), or depth buffer (i.e. not real strokes)
                 */
                dflag |= GP_DRAWDATA_NO_ONIONS;
        }
-       
+
        /* draw it! */
-       gp_draw_data_all(scene, gpd, offsx, offsy, winx, winy, CFRA, dflag, v3d->spacetype);
-       
+       gp_draw_data_all(scene, gpd, offsx, offsy, winx, winy, CFRA, dflag, v3d->spacetype);    
 }
 
 void ED_gpencil_draw_ex(Scene *scene, bGPdata *gpd, int winx, int winy, const int cfra, const char spacetype)
 {
        int dflag = GP_DRAWDATA_NOSTATUS | GP_DRAWDATA_ONLYV2D;
-       
+
        gp_draw_data_all(scene, gpd, 0, 0, winx, winy, cfra, dflag, spacetype);
 }