diff options
Diffstat (limited to 'source/blender/editors/mask/mask_draw.c')
| -rw-r--r-- | source/blender/editors/mask/mask_draw.c | 470 |
1 files changed, 213 insertions, 257 deletions
diff --git a/source/blender/editors/mask/mask_draw.c b/source/blender/editors/mask/mask_draw.c index 407c19a3860..689a96a3dec 100644 --- a/source/blender/editors/mask/mask_draw.c +++ b/source/blender/editors/mask/mask_draw.c @@ -36,6 +36,7 @@ #include "BLI_math.h" #include "BLI_rect.h" #include "BLI_task.h" +#include "BLI_listbase.h" #include "BKE_context.h" #include "BKE_mask.h" @@ -48,10 +49,13 @@ #include "ED_clip.h" #include "ED_mask.h" /* own include */ #include "ED_space_api.h" -#include "BIF_gl.h" + #include "BIF_glutil.h" -#include "GPU_basic_shader.h" +#include "GPU_immediate.h" +#include "GPU_draw.h" +#include "GPU_shader.h" +#include "GPU_matrix.h" #include "UI_resources.h" #include "UI_view2d.h" @@ -93,40 +97,6 @@ static void mask_spline_feather_color_get(MaskLayer *UNUSED(masklay), MaskSpline r_rgb[3] = 255; } -#if 0 -static void draw_spline_parents(MaskLayer *UNUSED(masklay), MaskSpline *spline) -{ - int i; - MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline); - - if (!spline->tot_point) - return; - - GPU_basic_shader_bind_enable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE); - GPU_basic_shader_line_stipple(1, 0xAAAA); - - glColor3ub(0, 0, 0); - glBegin(GL_LINES); - - for (i = 0; i < spline->tot_point; i++) { - MaskSplinePoint *point = &points_array[i]; - BezTriple *bezt = &point->bezt; - - if (point->parent.id) { - glVertex2f(bezt->vec[1][0], - bezt->vec[1][1]); - - glVertex2f(bezt->vec[1][0] - point->parent.offset[0], - bezt->vec[1][1] - point->parent.offset[1]); - } - } - - glEnd(); - - GPU_basic_shader_bind_disable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE); -} -#endif - static void mask_point_undistort_pos(SpaceClip *sc, float r_co[2], const float co[2]) { BKE_mask_coord_to_movieclip(sc->clip, &sc->user, r_co, co); @@ -134,46 +104,9 @@ static void mask_point_undistort_pos(SpaceClip *sc, float r_co[2], const float c BKE_mask_coord_from_movieclip(sc->clip, &sc->user, r_co, r_co); } -static void draw_circle(const float x, const float y, - const float size, const bool fill, - const float xscale, const float yscale) -{ - static GLuint wire_displist = 0; - static GLuint fill_displist = 0; - GLuint displist = fill ? fill_displist : wire_displist; - - /* Initialize round circle shape. */ - if (displist == 0) { - GLUquadricObj *qobj; - - displist = glGenLists(1); - glNewList(displist, GL_COMPILE); - - qobj = gluNewQuadric(); - gluQuadricDrawStyle(qobj, fill ? GLU_FILL : GLU_SILHOUETTE); - gluDisk(qobj, 0, 0.7, 8, 1); - gluDeleteQuadric(qobj); - - glEndList(); - - if (fill) { - fill_displist = displist; - } - else { - wire_displist = displist; - } - } - - glPushMatrix(); - glTranslatef(x, y, 0.0f); - glScalef(1.0f / xscale * size, 1.0f / yscale * size, 1.0f); - glCallList(displist); - glPopMatrix(); -} - static void draw_single_handle(const MaskLayer *mask_layer, const MaskSplinePoint *point, const eMaskWhichHandle which_handle, const int draw_type, - const float handle_size, const float xscale, const float yscale, + const float handle_size, const float point_pos[2], const float handle_pos[2]) { const BezTriple *bezt = &point->bezt; @@ -190,54 +123,70 @@ static void draw_single_handle(const MaskLayer *mask_layer, const MaskSplinePoin return; } + Gwn_VertFormat *format = immVertexFormat(); + unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT); + const unsigned char rgb_gray[4] = {0x60, 0x60, 0x60, 0xff}; + + immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR); + immUniformColor3ubv(rgb_gray); + /* this could be split into its own loop */ if (draw_type == MASK_DT_OUTLINE) { - const unsigned char rgb_gray[4] = {0x60, 0x60, 0x60, 0xff}; - glLineWidth(3); - glColor4ubv(rgb_gray); - glBegin(GL_LINES); - glVertex2fv(point_pos); - glVertex2fv(handle_pos); - glEnd(); + glLineWidth(3.0f); + immBegin(GWN_PRIM_LINES, 2); + immVertex2fv(pos, point_pos); + immVertex2fv(pos, handle_pos); + immEnd(); } switch (handle_type) { case HD_FREE: - UI_ThemeColor(TH_HANDLE_FREE); + immUniformThemeColor(TH_HANDLE_FREE); break; case HD_AUTO: - UI_ThemeColor(TH_HANDLE_AUTO); + immUniformThemeColor(TH_HANDLE_AUTO); break; case HD_ALIGN: case HD_ALIGN_DOUBLESIDE: - UI_ThemeColor(TH_HANDLE_ALIGN); + immUniformThemeColor(TH_HANDLE_ALIGN); break; } - glLineWidth(1); - glBegin(GL_LINES); - glVertex2fv(point_pos); - glVertex2fv(handle_pos); - glEnd(); + glLineWidth(1.0f); + immBegin(GWN_PRIM_LINES, 2); + immVertex2fv(pos, point_pos); + immVertex2fv(pos, handle_pos); + immEnd(); + immUnbindProgram(); /* draw handle points */ + immBindBuiltinProgram(GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA); + immUniform1f("size", handle_size); + immUniform1f("outlineWidth", 1.5f); + + float point_color[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; /* active color by default */ if (MASKPOINT_ISSEL_HANDLE(point, which_handle)) { - if (point == mask_layer->act_point) - glColor3f(1.0f, 1.0f, 1.0f); - else - UI_ThemeColor(TH_HANDLE_VERTEX_SELECT); + if (point != mask_layer->act_point) { + UI_GetThemeColor3fv(TH_HANDLE_VERTEX_SELECT, point_color); + } } else { - UI_ThemeColor(TH_HANDLE_VERTEX); + UI_GetThemeColor3fv(TH_HANDLE_VERTEX, point_color); } - draw_circle(handle_pos[0], handle_pos[1], handle_size, false, xscale, yscale); + immUniform4fv("outlineColor", point_color); + immUniformColor3fvAlpha(point_color, 0.25f); + + immBegin(GWN_PRIM_POINTS, 1); + immVertex2fv(pos, handle_pos); + immEnd(); + + immUnbindProgram(); } /* return non-zero if spline is selected */ static void draw_spline_points(const bContext *C, MaskLayer *masklay, MaskSpline *spline, - const char draw_flag, const char draw_type, - const float xscale, const float yscale) + const char draw_flag, const char draw_type) { const bool is_spline_sel = (spline->flag & SELECT) && (masklay->restrictflag & MASK_RESTRICT_SELECT) == 0; const bool is_smooth = (draw_flag & MASK_DRAWFLAG_SMOOTH) != 0; @@ -247,7 +196,7 @@ static void draw_spline_points(const bContext *C, MaskLayer *masklay, MaskSpline SpaceClip *sc = CTX_wm_space_clip(C); bool undistort = false; - int i, handle_size, tot_feather_point; + int tot_feather_point; float (*feather_points)[2], (*fp)[2]; float min[2], max[2]; @@ -258,22 +207,24 @@ static void draw_spline_points(const bContext *C, MaskLayer *masklay, MaskSpline undistort = sc->clip && (sc->user.render_flag & MCLIP_PROXY_RENDER_UNDISTORT); /* TODO, add this to sequence editor */ - handle_size = UI_GetThemeValuef(TH_HANDLE_VERTEX_SIZE) * U.pixelsize; - - glPointSize(handle_size); + float handle_size = 2.0f * UI_GetThemeValuef(TH_HANDLE_VERTEX_SIZE) * U.pixelsize; mask_spline_color_get(masklay, spline, is_spline_sel, rgb_spline); + Gwn_VertFormat *format = immVertexFormat(); + unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT); + + immBindBuiltinProgram(GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA); + immUniform1f("size", 0.7f * handle_size); + /* feather points */ feather_points = fp = BKE_mask_spline_feather_points(spline, &tot_feather_point); - for (i = 0; i < spline->tot_point; i++) { + for (int i = 0; i < spline->tot_point; i++) { /* watch it! this is intentionally not the deform array, only check for sel */ MaskSplinePoint *point = &spline->points[i]; - int j; - - for (j = 0; j <= point->tot_uw; j++) { + for (int j = 0; j <= point->tot_uw; j++) { float feather_point[2]; bool sel = false; @@ -291,32 +242,32 @@ static void draw_spline_points(const bContext *C, MaskLayer *masklay, MaskSpline if (sel) { if (point == masklay->act_point) - glColor3f(1.0f, 1.0f, 1.0f); + immUniformColor3f(1.0f, 1.0f, 1.0f); else - UI_ThemeColor(TH_HANDLE_VERTEX_SELECT); + immUniformThemeColor(TH_HANDLE_VERTEX_SELECT); } else { - UI_ThemeColor(TH_HANDLE_VERTEX); + immUniformThemeColor(TH_HANDLE_VERTEX); } - glBegin(GL_POINTS); - glVertex2fv(feather_point); - glEnd(); + immBegin(GWN_PRIM_POINTS, 1); + immVertex2fv(pos, feather_point); + immEnd(); fp++; } } MEM_freeN(feather_points); + immUnbindProgram(); + if (is_smooth) { glEnable(GL_LINE_SMOOTH); - glEnable(GL_BLEND); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } /* control points */ INIT_MINMAX2(min, max); - for (i = 0; i < spline->tot_point; i++) { + for (int i = 0; i < spline->tot_point; i++) { /* watch it! this is intentionally not the deform array, only check for sel */ MaskSplinePoint *point = &spline->points[i]; @@ -339,7 +290,7 @@ static void draw_spline_points(const bContext *C, MaskLayer *masklay, MaskSpline mask_point_undistort_pos(sc, handle, handle); } draw_single_handle(masklay, point, MASK_WHICH_HANDLE_STICK, - draw_type, handle_size, xscale, yscale, vert, handle); + draw_type, handle_size, vert, handle); } else { float handle_left[2], handle_right[2]; @@ -350,53 +301,62 @@ static void draw_spline_points(const bContext *C, MaskLayer *masklay, MaskSpline mask_point_undistort_pos(sc, handle_left, handle_left); } draw_single_handle(masklay, point, MASK_WHICH_HANDLE_LEFT, - draw_type, handle_size, xscale, yscale, vert, handle_left); + draw_type, handle_size, vert, handle_left); draw_single_handle(masklay, point, MASK_WHICH_HANDLE_RIGHT, - draw_type, handle_size, xscale, yscale, vert, handle_right); + draw_type, handle_size, vert, handle_right); } + /* bind program in loop so it does not interfere with draw_single_handle */ + immBindBuiltinProgram(GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_AA); + /* draw CV point */ if (MASKPOINT_ISSEL_KNOT(point)) { if (point == masklay->act_point) - glColor3f(1.0f, 1.0f, 1.0f); + immUniformColor3f(1.0f, 1.0f, 1.0f); else - UI_ThemeColor(TH_HANDLE_VERTEX_SELECT); + immUniformThemeColor(TH_HANDLE_VERTEX_SELECT); } else - UI_ThemeColor(TH_HANDLE_VERTEX); + immUniformThemeColor(TH_HANDLE_VERTEX); + + immBegin(GWN_PRIM_POINTS, 1); + immVertex2fv(pos, vert); + immEnd(); - glBegin(GL_POINTS); - glVertex2fv(vert); - glEnd(); + immUnbindProgram(); minmax_v2v2_v2(min, max, vert); } + if (is_smooth) { + glDisable(GL_LINE_SMOOTH); + } + if (is_spline_sel) { - float x = (min[0] + max[0]) / 2.0f; - float y = (min[1] + max[1]) / 2.0f; - /* TODO(sergey): Remove hardcoded colors. */ + float x = (min[0] + max[0]) * 0.5f; + float y = (min[1] + max[1]) * 0.5f; + + immBindBuiltinProgram(GPU_SHADER_2D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA); + immUniform1f("outlineWidth", 1.5f); + if (masklay->act_spline == spline) { - glColor3ub(255, 255, 255); + immUniformColor3f(1.0f, 1.0f, 1.0f); } else { - glColor3ub(255, 255, 0); + immUniformColor3f(1.0f, 1.0f, 0.0f); } - draw_circle(x, y, 6.0f, true, xscale, yscale); + immUniform4f("outlineColor", 0.0f, 0.0f, 0.0f, 1.0f); + immUniform1f("size", 12.0f); - glColor3ub(0, 0, 0); - draw_circle(x, y, 6.0f, false, xscale, yscale); - } + immBegin(GWN_PRIM_POINTS, 1); + immVertex2f(pos, x, y); + immEnd(); - if (is_smooth) { - glDisable(GL_LINE_SMOOTH); - glDisable(GL_BLEND); + immUnbindProgram(); } } -/* #define USE_XOR */ - static void mask_color_active_tint(unsigned char r_rgb[4], const unsigned char rgb[4], const bool is_active) { if (!is_active) { @@ -410,13 +370,21 @@ static void mask_color_active_tint(unsigned char r_rgb[4], const unsigned char r } } +static void mask_draw_array(unsigned int pos, Gwn_PrimType prim_type, const float (*points)[2], unsigned int vertex_ct) +{ + immBegin(prim_type, vertex_ct); + for (unsigned int i = 0; i < vertex_ct; ++i) { + immVertex2fv(pos, points[i]); + } + immEnd(); +} + static void mask_draw_curve_type(const bContext *C, MaskSpline *spline, float (*orig_points)[2], int tot_point, - const bool is_feather, const bool is_smooth, const bool is_active, + const bool is_feather, const bool is_active, const unsigned char rgb_spline[4], const char draw_type) { - const int draw_method = (spline->flag & MASK_SPLINE_CYCLIC) ? GL_LINE_LOOP : GL_LINE_STRIP; + const Gwn_PrimType draw_method = (spline->flag & MASK_SPLINE_CYCLIC) ? GWN_PRIM_LINE_LOOP : GWN_PRIM_LINE_STRIP; const unsigned char rgb_black[4] = {0x00, 0x00, 0x00, 0xff}; -// const unsigned char rgb_white[4] = {0xff, 0xff, 0xff, 0xff}; unsigned char rgb_tmp[4]; SpaceClip *sc = CTX_wm_space_clip(C); float (*points)[2] = orig_points; @@ -425,65 +393,45 @@ static void mask_draw_curve_type(const bContext *C, MaskSpline *spline, float (* const bool undistort = sc->clip && (sc->user.render_flag & MCLIP_PROXY_RENDER_UNDISTORT); if (undistort) { - int i; - points = MEM_callocN(2 * tot_point * sizeof(float), "undistorthed mask curve"); - for (i = 0; i < tot_point; i++) { + for (int i = 0; i < tot_point; i++) { mask_point_undistort_pos(sc, points[i], orig_points[i]); } } } - glEnableClientState(GL_VERTEX_ARRAY); - glVertexPointer(2, GL_FLOAT, 0, points); + Gwn_VertFormat *format = immVertexFormat(); + unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT); switch (draw_type) { case MASK_DT_OUTLINE: - glLineWidth(3); - - mask_color_active_tint(rgb_tmp, rgb_black, is_active); - glColor4ubv(rgb_tmp); - - glDrawArrays(draw_method, 0, tot_point); + /* TODO(merwin): use fancy line shader here + * probably better with geometry shader (after core profile switch) + */ + immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR); - glLineWidth(1); - mask_color_active_tint(rgb_tmp, rgb_spline, is_active); - glColor4ubv(rgb_tmp); - glDrawArrays(draw_method, 0, tot_point); + glLineWidth(3.0f); - break; + mask_color_active_tint(rgb_tmp, rgb_black, is_active); + immUniformColor4ubv(rgb_tmp); + mask_draw_array(pos, draw_method, points, tot_point); - case MASK_DT_DASH: - default: - GPU_basic_shader_bind_enable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE); - GPU_basic_shader_line_stipple(3, 0xAAAA); + glLineWidth(1.0f); -#ifdef USE_XOR - glEnable(GL_COLOR_LOGIC_OP); - glLogicOp(GL_OR); -#endif mask_color_active_tint(rgb_tmp, rgb_spline, is_active); - glColor4ubv(rgb_tmp); - glEnableClientState(GL_VERTEX_ARRAY); - glVertexPointer(2, GL_FLOAT, 0, points); - glDrawArrays(draw_method, 0, tot_point); - -#ifdef USE_XOR - glDisable(GL_COLOR_LOGIC_OP); -#endif - mask_color_active_tint(rgb_tmp, rgb_black, is_active); - glColor4ubv(rgb_tmp); - GPU_basic_shader_line_stipple(3, 0x5555); - glDrawArrays(draw_method, 0, tot_point); + immUniformColor4ubv(rgb_tmp); + mask_draw_array(pos, draw_method, points, tot_point); - GPU_basic_shader_bind_disable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE); + immUnbindProgram(); break; - case MASK_DT_BLACK: case MASK_DT_WHITE: + immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR); + glLineWidth(1.0f); + if (draw_type == MASK_DT_BLACK) { rgb_tmp[0] = rgb_tmp[1] = rgb_tmp[2] = 0; } else { rgb_tmp[0] = rgb_tmp[1] = rgb_tmp[2] = 255; } /* alpha values seem too low but gl draws many points that compensate for it */ @@ -496,26 +444,39 @@ static void mask_draw_curve_type(const bContext *C, MaskSpline *spline, float (* rgb_tmp[2] = (unsigned char)(((short)rgb_tmp[2] + (short)rgb_spline[2]) / 2); } - if (is_smooth == false && is_feather) { - glEnable(GL_BLEND); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - } - mask_color_active_tint(rgb_tmp, rgb_tmp, is_active); - glColor4ubv(rgb_tmp); + immUniformColor4ubv(rgb_tmp); + mask_draw_array(pos, draw_method, points, tot_point); - glEnableClientState(GL_VERTEX_ARRAY); - glVertexPointer(2, GL_FLOAT, 0, points); - glDrawArrays(draw_method, 0, tot_point); + immUnbindProgram(); + break; - if (is_smooth == false && is_feather) { - glDisable(GL_BLEND); - } + case MASK_DT_DASH: + /* TODO(merwin): use dashed line shader here + * probably better with geometry shader (after core profile switch) + */ +#if 0 + glLineWidth(1.0f); + + GPU_basic_shader_bind_enable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE); + GPU_basic_shader_line_stipple(3, 0xAAAA); + mask_color_active_tint(rgb_tmp, rgb_spline, is_active); + immUniformColor4ubv(rgb_tmp); + mask_draw_array(pos, draw_method, points, tot_point); + + mask_color_active_tint(rgb_tmp, rgb_black, is_active); + immUniformColor4ubv(rgb_tmp); + GPU_basic_shader_line_stipple(3, 0x5555); + mask_draw_array(pos, draw_method, points, tot_point); + + GPU_basic_shader_bind_disable(GPU_SHADER_LINE | GPU_SHADER_STIPPLE); +#endif break; - } - glDisableClientState(GL_VERTEX_ARRAY); + default: + BLI_assert(false); + } if (points != orig_points) MEM_freeN(points); @@ -548,8 +509,6 @@ static void draw_spline_curve(const bContext *C, MaskLayer *masklay, MaskSpline if (is_smooth) { glEnable(GL_LINE_SMOOTH); - glEnable(GL_BLEND); - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); } feather_points = BKE_mask_spline_feather_differentiated_points_with_resolution(spline, &tot_feather_point, resol, (is_fill != false)); @@ -557,26 +516,24 @@ static void draw_spline_curve(const bContext *C, MaskLayer *masklay, MaskSpline /* draw feather */ mask_spline_feather_color_get(masklay, spline, is_spline_sel, rgb_tmp); mask_draw_curve_type(C, spline, feather_points, tot_feather_point, - true, is_smooth, is_active, + true, is_active, rgb_tmp, draw_type); if (!is_fill) { - const float *fp = &diff_points[0][0]; float *fp_feather = &feather_points[0][0]; - float tvec[2]; - int i; BLI_assert(tot_diff_point == tot_feather_point); - for (i = 0; i < tot_diff_point; i++, fp += 2, fp_feather += 2) { + for (int i = 0; i < tot_diff_point; i++, fp += 2, fp_feather += 2) { + float tvec[2]; sub_v2_v2v2(tvec, fp, fp_feather); add_v2_v2v2(fp_feather, fp, tvec); } /* same as above */ mask_draw_curve_type(C, spline, feather_points, tot_feather_point, - true, is_smooth, is_active, + true, is_active, rgb_tmp, draw_type); } @@ -585,21 +542,22 @@ static void draw_spline_curve(const bContext *C, MaskLayer *masklay, MaskSpline /* draw main curve */ mask_spline_color_get(masklay, spline, is_spline_sel, rgb_tmp); mask_draw_curve_type(C, spline, diff_points, tot_diff_point, - false, is_smooth, is_active, + false, is_active, rgb_tmp, draw_type); MEM_freeN(diff_points); - if (draw_flag & MASK_DRAWFLAG_SMOOTH) { + if (is_smooth) { glDisable(GL_LINE_SMOOTH); - glDisable(GL_BLEND); } - - (void)draw_type; } static void draw_masklays(const bContext *C, Mask *mask, const char draw_flag, const char draw_type, - const int width, const int height, const float xscale, const float yscale) + const int width, const int height) { + glEnable(GL_BLEND); + glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA); + GPU_enable_program_point_size(); + MaskLayer *masklay; int i; @@ -616,11 +574,9 @@ static void draw_masklays(const bContext *C, Mask *mask, const char draw_flag, c /* draw curve itself first... */ draw_spline_curve(C, masklay, spline, draw_flag, draw_type, is_active, width, height); -// draw_spline_parents(masklay, spline); - if (!(masklay->restrictflag & MASK_RESTRICT_SELECT)) { /* ...and then handles over the curve so they're nicely visible */ - draw_spline_points(C, masklay, spline, draw_flag, draw_type, xscale, yscale); + draw_spline_points(C, masklay, spline, draw_flag, draw_type); } /* show undeform for testing */ @@ -629,33 +585,29 @@ static void draw_masklays(const bContext *C, Mask *mask, const char draw_flag, c spline->points_deform = NULL; draw_spline_curve(C, masklay, spline, draw_flag, draw_type, is_active, width, height); -// draw_spline_parents(masklay, spline); - draw_spline_points(C, masklay, spline, draw_flag, draw_type, xscale, yscale); + draw_spline_points(C, masklay, spline, draw_flag, draw_type); spline->points_deform = back; } } } + + GPU_disable_program_point_size(); + glDisable(GL_BLEND); } void ED_mask_draw(const bContext *C, const char draw_flag, const char draw_type) { ScrArea *sa = CTX_wm_area(C); - ARegion *ar = CTX_wm_region(C); - Mask *mask = CTX_data_edit_mask(C); int width, height; - float aspx, aspy; - float xscale, yscale; if (!mask) return; ED_mask_get_size(sa, &width, &height); - ED_mask_get_aspect(sa, ar, &aspx, &aspy); - UI_view2d_scale_get(&ar->v2d, &xscale, &yscale); - draw_masklays(C, mask, draw_flag, draw_type, width, height, xscale * aspx, yscale * aspy); + draw_masklays(C, mask, draw_flag, draw_type, width, height); } static float *mask_rasterize(Mask *mask, const int width, const int height) @@ -733,28 +685,26 @@ void ED_mask_draw_region(Mask *mask, ARegion *ar, } if (draw_flag & MASK_DRAWFLAG_OVERLAY) { + float red[4] = {1.0f, 0.0f, 0.0f, 0.0f}; float *buffer = mask_rasterize(mask, width, height); - int format; - if (overlay_mode == MASK_OVERLAY_ALPHACHANNEL) { - glColor3f(1.0f, 1.0f, 1.0f); - format = GL_LUMINANCE; - } - else { + if (overlay_mode != MASK_OVERLAY_ALPHACHANNEL) { /* More blending types could be supported in the future. */ glEnable(GL_BLEND); - glBlendFunc(GL_DST_COLOR, GL_SRC_ALPHA); - format = GL_ALPHA; + glBlendFunc(GL_DST_COLOR, GL_ZERO); } - glPushMatrix(); - glTranslatef(x, y, 0); - glScalef(zoomx, zoomy, 0); + gpuPushMatrix(); + gpuTranslate2f(x, y); + gpuScale2f(zoomx, zoomy); if (stabmat) { - glMultMatrixf(stabmat); + gpuMultMatrix(stabmat); } - glaDrawPixelsTex(0.0f, 0.0f, width, height, format, GL_FLOAT, GL_NEAREST, buffer); - glPopMatrix(); + IMMDrawPixelsTexState state = immDrawPixelsTexSetup(GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR); + GPU_shader_uniform_vector(state.shader, GPU_shader_get_uniform(state.shader, "shuffle"), 4, 1, red); + immDrawPixelsTex(&state, 0.0f, 0.0f, width, height, GL_RED, GL_FLOAT, GL_NEAREST, buffer, 1.0f, 1.0f, NULL); + + gpuPopMatrix(); if (overlay_mode != MASK_OVERLAY_ALPHACHANNEL) { glDisable(GL_BLEND); @@ -764,26 +714,26 @@ void ED_mask_draw_region(Mask *mask, ARegion *ar, } /* apply transformation so mask editing tools will assume drawing from the origin in normalized space */ - glPushMatrix(); - glTranslatef(x + xofs, y + yofs, 0); - glScalef(zoomx, zoomy, 0); + gpuPushMatrix(); + gpuTranslate2f(x + xofs, y + yofs); + gpuScale2f(zoomx, zoomy); if (stabmat) { - glMultMatrixf(stabmat); + gpuMultMatrix(stabmat); } - glScalef(maxdim, maxdim, 0); + gpuScale2f(maxdim, maxdim); if (do_draw_cb) { ED_region_draw_cb_draw(C, ar, REGION_DRAW_PRE_VIEW); } /* draw! */ - draw_masklays(C, mask, draw_flag, draw_type, width, height, maxdim * zoomx, maxdim * zoomy); + draw_masklays(C, mask, draw_flag, draw_type, width, height); if (do_draw_cb) { ED_region_draw_cb_draw(C, ar, REGION_DRAW_POST_VIEW); } - glPopMatrix(); + gpuPopMatrix(); } void ED_mask_draw_frames(Mask *mask, ARegion *ar, const int cfra, const int sfra, const int efra) @@ -792,25 +742,31 @@ void ED_mask_draw_frames(Mask *mask, ARegion *ar, const int cfra, const int sfra MaskLayer *masklay = BKE_mask_layer_active(mask); - glBegin(GL_LINES); - glColor4ub(255, 175, 0, 255); - if (masklay) { - MaskLayerShape *masklay_shape; - - for (masklay_shape = masklay->splines_shapes.first; - masklay_shape; - masklay_shape = masklay_shape->next) - { - int frame = masklay_shape->frame; - - /* draw_keyframe(i, CFRA, sfra, framelen, 1); */ - int height = (frame == cfra) ? 22 : 10; - int x = (frame - sfra) * framelen; - glVertex2i(x, 0); - glVertex2i(x, height); + unsigned int num_lines = BLI_listbase_count(&masklay->splines_shapes); + + if (num_lines > 0) { + unsigned int pos = GWN_vertformat_attr_add(immVertexFormat(), "pos", GWN_COMP_I32, 2, GWN_FETCH_INT_TO_FLOAT); + + immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR); + immUniformColor4ub(255, 175, 0, 255); + + immBegin(GWN_PRIM_LINES, 2 * num_lines); + + for (MaskLayerShape *masklay_shape = masklay->splines_shapes.first; + masklay_shape; + masklay_shape = masklay_shape->next) + { + int frame = masklay_shape->frame; + + /* draw_keyframe(i, CFRA, sfra, framelen, 1); */ + int height = (frame == cfra) ? 22 : 10; + int x = (frame - sfra) * framelen; + immVertex2i(pos, x, 0); + immVertex2i(pos, x, height); + } + immEnd(); + immUnbindProgram(); } } - - glEnd(); } |