Merge branch 'master' into blender2.8
authorCampbell Barton <ideasman42@gmail.com>
Tue, 29 Aug 2017 09:38:01 +0000 (19:38 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 29 Aug 2017 09:38:01 +0000 (19:38 +1000)
1  2 
source/blender/editors/interface/view2d.c

index fb57902d258ec22c08f21cad4a20bade46aee495,c704c4ae1267e487f55cded8cf857b753dd55860..53cc6607b2eb0368e40749c3cc3339535a9cc8cf
  #include "BKE_screen.h"
  #include "BKE_global.h"
  
 +#include "GPU_immediate.h"
 +#include "GPU_matrix.h"
  
  #include "WM_api.h"
  
 -#include "BIF_gl.h"
 -
  #include "BLF_api.h"
  
  #include "ED_screen.h"
@@@ -1100,6 -1100,9 +1100,6 @@@ void UI_view2d_view_ortho(View2D *v2d
        
        /* set matrix on all appropriate axes */
        wmOrtho2(curmasked.xmin, curmasked.xmax, curmasked.ymin, curmasked.ymax);
 -
 -      /* XXX is this necessary? */
 -      glLoadIdentity();
  }
  
  /**
@@@ -1127,6 -1130,9 +1127,6 @@@ void UI_view2d_view_orthoSpecial(ARegio
                wmOrtho2(curmasked.xmin - xofs, curmasked.xmax - xofs, -yofs, ar->winy - yofs);
        else
                wmOrtho2(-xofs, ar->winx - xofs, curmasked.ymin - yofs, curmasked.ymax - yofs);
 -              
 -      /* XXX is this necessary? */
 -      glLoadIdentity();
  } 
  
  
@@@ -1138,7 -1144,7 +1138,7 @@@ void UI_view2d_view_restore(const bCont
        int height = BLI_rcti_size_y(&ar->winrct) + 1;
        
        wmOrtho2(0.0f, (float)width, 0.0f, (float)height);
 -      glLoadIdentity();
 +      gpuLoadIdentity();
        
        //      ED_region_pixelspace(CTX_wm_region(C));
  }
@@@ -1292,45 -1298,12 +1292,45 @@@ void UI_view2d_grid_draw(View2D *v2d, V
  {
        float vec1[2], vec2[2];
        int a, step;
 +      int vertical_minor_step = (BLI_rcti_size_x(&v2d->mask) + 1) / (U.v2d_min_gridsize * UI_DPI_FAC),
 +              horizontal_major_step = (BLI_rcti_size_y(&v2d->mask) + 1) / (U.v2d_min_gridsize * UI_DPI_FAC);
 +      unsigned char grid_line_color[3];
        
        /* check for grid first, as it may not exist */
        if (grid == NULL)
                return;
  
 -      glBegin(GL_LINES);
 +      /* Count the needed vertices for the gridlines */
 +      unsigned vertex_count = 0;
 +      if (flag & V2D_VERTICAL_LINES) {
 +              /* vertical lines */
 +              vertex_count += 2 * vertical_minor_step;                /* minor gridlines */
 +              vertex_count += 2 * (vertical_minor_step + 2);  /* major gridlines */
 +      }
 +      if (flag & V2D_HORIZONTAL_LINES) {
 +              /* horizontal lines */
 +              vertex_count += 2 * (horizontal_major_step + 1);        /* major gridlines */
 +
 +              /* fine lines */
 +              if (flag & V2D_HORIZONTAL_FINELINES)
 +                      vertex_count += 2 * (horizontal_major_step + 1);
 +      }
 +      /* axes */
 +      if (flag & V2D_HORIZONTAL_AXIS)
 +              vertex_count += 2;
 +      if (flag & V2D_VERTICAL_AXIS)
 +              vertex_count += 2;
 +
 +      /* If there is nothing to render, exit early */
 +      if (vertex_count == 0)
 +              return;
 +
 +      Gwn_VertFormat *format = immVertexFormat();
 +      unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
 +      unsigned int color = GWN_vertformat_attr_add(format, "color", GWN_COMP_U8, 3, GWN_FETCH_INT_TO_FLOAT_UNIT);
 +
 +      immBindBuiltinProgram(GPU_SHADER_2D_FLAT_COLOR);
 +      immBegin(GWN_PRIM_LINES, vertex_count);
  
        /* vertical lines */
        if (flag & V2D_VERTICAL_LINES) {
                vec2[1] = v2d->cur.ymax;
                
                /* minor gridlines */
 -              step = (BLI_rcti_size_x(&v2d->mask) + 1) / (U.v2d_min_gridsize * UI_DPI_FAC);
 -              UI_ThemeColor(TH_GRID);
 -              
 -              for (a = 0; a < step; a++) {
 -                      glVertex2fv(vec1);
 -                      glVertex2fv(vec2);
 -                      
 -                      vec2[0] = vec1[0] += grid->dx;
 +              step = vertical_minor_step;
 +              if (step != 0) {
 +                      UI_GetThemeColor3ubv(TH_GRID, grid_line_color);
 +      
 +                      for (a = 0; a < step; a++) {
 +                              immSkipAttrib(color);
 +                              immVertex2fv(pos, vec1);
 +                              immAttrib3ubv(color, grid_line_color);
 +                              immVertex2fv(pos, vec2);
 +                              
 +                              vec2[0] = vec1[0] += grid->dx;
 +                      }
                }
                
                /* major gridlines */
                vec2[0] = vec1[0] -= 0.5f * grid->dx;
 -              UI_ThemeColorShade(TH_GRID, 16);
 +
 +              UI_GetThemeColorShade3ubv(TH_GRID, 16, grid_line_color);
                
                step++;
                for (a = 0; a <= step; a++) {
 -                      glVertex2fv(vec1);
 -                      glVertex2fv(vec2);
 +                      immSkipAttrib(color);
 +                      immVertex2fv(pos, vec1);
 +                      immAttrib3ubv(color, grid_line_color);
 +                      immVertex2fv(pos, vec2);
                        
                        vec2[0] = vec1[0] -= grid->dx;
                }
                vec1[0] = grid->startx;
                vec2[0] = v2d->cur.xmax;
                
 -              step = (BLI_rcti_size_y(&v2d->mask) + 1) / (U.v2d_min_gridsize * UI_DPI_FAC);
 -              
 -              UI_ThemeColor(TH_GRID);
 +              step = horizontal_major_step;
 +      
 +              UI_GetThemeColor3ubv(TH_GRID, grid_line_color);
 +
                for (a = 0; a <= step; a++) {
 -                      glVertex2fv(vec1);
 -                      glVertex2fv(vec2);
 +                      immSkipAttrib(color);
 +                      immVertex2fv(pos, vec1);
 +                      immAttrib3ubv(color, grid_line_color);
 +                      immVertex2fv(pos, vec2);
                        
                        vec2[1] = vec1[1] += grid->dy;
                }
                step++;
                
                if (flag & V2D_HORIZONTAL_FINELINES) {
 -                      UI_ThemeColorShade(TH_GRID, 16);
 +                      UI_GetThemeColorShade3ubv(TH_GRID, 16, grid_line_color);
                        for (a = 0; a < step; a++) {
 -                              glVertex2fv(vec1);
 -                              glVertex2fv(vec2);
 +                              immSkipAttrib(color);
 +                              immVertex2fv(pos, vec1);
 +                              immAttrib3ubv(color, grid_line_color);
 +                              immVertex2fv(pos, vec2);
                                
                                vec2[1] = vec1[1] -= grid->dy;
                        }
        }
        
        /* Axes are drawn as darker lines */
 -      UI_ThemeColorShade(TH_GRID, -50);
 +      UI_GetThemeColorShade3ubv(TH_GRID, -50, grid_line_color);
        
        /* horizontal axis */
        if (flag & V2D_HORIZONTAL_AXIS) {
                vec2[0] = v2d->cur.xmax;
                vec1[1] = vec2[1] = 0.0f;
                
 -              glVertex2fv(vec1);
 -              glVertex2fv(vec2);
 +              immSkipAttrib(color);
 +              immVertex2fv(pos, vec1);
 +              immAttrib3ubv(color, grid_line_color);
 +              immVertex2fv(pos, vec2);
        }
        
        /* vertical axis */
                vec2[1] = v2d->cur.ymax;
                vec1[0] = vec2[0] = 0.0f;
                
 -              glVertex2fv(vec1);
 -              glVertex2fv(vec2);
 +              immSkipAttrib(color);
 +              immVertex2fv(pos, vec1);
 +              immAttrib3ubv(color, grid_line_color);
 +              immVertex2fv(pos, vec2);
        }
  
 -      glEnd();
 +      immEnd();
 +      immUnbindProgram();
  }
  
  /* Draw a constant grid in given 2d-region */
  void UI_view2d_constant_grid_draw(View2D *v2d)
  {
 -      float start, step = 25.0f;
 -
 -      UI_ThemeColorShade(TH_BACK, -10);
 +      float start_x, start_y, step = 25.0f;
 +      int count_x, count_y;
        
 -      start = v2d->cur.xmin - (float)fmod(v2d->cur.xmin, step);
 +      start_x = v2d->cur.xmin;
 +      if (start_x < 0.0)
 +              start_x += -(float)fmod(v2d->cur.xmin, step);
 +      else
 +              start_x += (step - (float)fmod(v2d->cur.xmin, step));
 +
 +      if (start_x > v2d->cur.xmax)
 +              count_x = 0;
 +      else
 +              count_x = (v2d->cur.xmax - start_x) / step + 1;
 +
 +      start_y = v2d->cur.ymin;
 +      if (start_y < 0.0)
 +              start_y += -(float)fmod(v2d->cur.ymin, step);
 +      else
 +              start_y += (step - (float)fabs(fmod(v2d->cur.ymin, step)));
 +
 +      if (start_y > v2d->cur.ymax)
 +              count_y = 0;
 +      else
 +              count_y = (v2d->cur.ymax - start_y) / step + 1;
        
 -      glBegin(GL_LINES);
 -      for (; start < v2d->cur.xmax; start += step) {
 -              glVertex2f(start, v2d->cur.ymin);
 -              glVertex2f(start, v2d->cur.ymax);
 -      }
 +      if (count_x > 0 || count_y > 0) {
 +              Gwn_VertFormat *format = immVertexFormat();
 +              unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
 +              unsigned int color = GWN_vertformat_attr_add(format, "color", GWN_COMP_F32, 3, GWN_FETCH_FLOAT);
 +              float theme_color[3];
  
 -      start = v2d->cur.ymin - (float)fmod(v2d->cur.ymin, step);
 -      for (; start < v2d->cur.ymax; start += step) {
 -              glVertex2f(v2d->cur.xmin, start);
 -              glVertex2f(v2d->cur.xmax, start);
 -      }
 +              UI_GetThemeColorShade3fv(TH_BACK, -10, theme_color);
 +              
 +              immBindBuiltinProgram(GPU_SHADER_2D_FLAT_COLOR);
 +              immBegin(GWN_PRIM_LINES, count_x * 2 + count_y * 2 + 4);
 +              
 +              immAttrib3fv(color, theme_color);
 +              for (int i = 0; i < count_x ; start_x += step, i++) {
 +                      immVertex2f(pos, start_x, v2d->cur.ymin);
 +                      immVertex2f(pos, start_x, v2d->cur.ymax);
 +              }
 +
 +              for (int i = 0; i < count_y; start_y += step, i++) {
 +                      immVertex2f(pos, v2d->cur.xmin, start_y);
 +                      immVertex2f(pos, v2d->cur.xmax, start_y);
 +              }
        
 -      /* X and Y axis */
 -      UI_ThemeColorShade(TH_BACK, -18);
 -      glVertex2f(0.0f, v2d->cur.ymin);
 -      glVertex2f(0.0f, v2d->cur.ymax);
 -      glVertex2f(v2d->cur.xmin, 0.0f);
 -      glVertex2f(v2d->cur.xmax, 0.0f);
 +              /* X and Y axis */
 +              UI_GetThemeColorShade3fv(TH_BACK, -18, theme_color);
 +              
 +              immAttrib3fv(color, theme_color);
 +              immVertex2f(pos, 0.0f, v2d->cur.ymin);
 +              immVertex2f(pos, 0.0f, v2d->cur.ymax);
 +              immVertex2f(pos, v2d->cur.xmin, 0.0f);
 +              immVertex2f(pos, v2d->cur.xmax, 0.0f);
        
 -      glEnd();
 +              immEnd();
 +              immUnbindProgram();
 +      }
  }
  
  /* Draw a multi-level grid in given 2d-region */
  void UI_view2d_multi_grid_draw(View2D *v2d, int colorid, float step, int level_size, int totlevels)
  {
 +      /* Exit if there is nothing to draw */
 +      if (totlevels == 0)
 +              return;
 +
        int offset = -10;
        float lstep = step;
 -      int level;
 +      unsigned char grid_line_color[3];
 +
 +      /* Make an estimate of at least how many vertices will be needed */
 +      unsigned vertex_count = 4;
 +      vertex_count += 2 * ((int)((v2d->cur.xmax - v2d->cur.xmin) / lstep) + 1);
 +      vertex_count += 2 * ((int)((v2d->cur.ymax - v2d->cur.ymin) / lstep) + 1);
 +
 +      Gwn_VertFormat *format = immVertexFormat();
 +      unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
 +      unsigned int color = GWN_vertformat_attr_add(format, "color", GWN_COMP_U8, 3, GWN_FETCH_INT_TO_FLOAT_UNIT);
  
        glLineWidth(1.0f);
 -      for (level = 0; level < totlevels; ++level) {
 -              int i;
 -              float start;
 -              
 -              UI_ThemeColorShade(colorid, offset);
 +
 +      immBindBuiltinProgram(GPU_SHADER_2D_FLAT_COLOR);
 +      immBeginAtMost(GWN_PRIM_LINES, vertex_count);
 +
 +      for (int level = 0; level < totlevels; ++level) {
 +              UI_GetThemeColorShade3ubv(colorid, offset, grid_line_color);
                
 -              i = (v2d->cur.xmin >= 0.0f ? -(int)(-v2d->cur.xmin / lstep) : (int)(v2d->cur.xmin / lstep));
 -              start = i * lstep;
 +              int i = (int)(v2d->cur.xmin / lstep);
 +              if (v2d->cur.xmin > 0.0f)
 +                      i++;
 +              float start = i * lstep;
                
 -              glBegin(GL_LINES);
                for (; start < v2d->cur.xmax; start += lstep, ++i) {
                        if (i == 0 || (level < totlevels - 1 && i % level_size == 0))
                                continue;
 -                      glVertex2f(start, v2d->cur.ymin);
 -                      glVertex2f(start, v2d->cur.ymax);
 +
 +                      immSkipAttrib(color);
 +                      immVertex2f(pos, start, v2d->cur.ymin);
 +                      immAttrib3ubv(color, grid_line_color);
 +                      immVertex2f(pos, start, v2d->cur.ymax);
                }
                
 -              i = (v2d->cur.ymin >= 0.0f ? -(int)(-v2d->cur.ymin / lstep) : (int)(v2d->cur.ymin / lstep));
 +              i = (int)(v2d->cur.ymin / lstep);
 +              if (v2d->cur.ymin > 0.0f)
 +                      i++;
                start = i * lstep;
                
                for (; start < v2d->cur.ymax; start += lstep, ++i) {
                        if (i == 0 || (level < totlevels - 1 && i % level_size == 0))
                                continue;
 -                      glVertex2f(v2d->cur.xmin, start);
 -                      glVertex2f(v2d->cur.xmax, start);
 +
 +                      immSkipAttrib(color);
 +                      immVertex2f(pos, v2d->cur.xmin, start);
 +                      immAttrib3ubv(color, grid_line_color);
 +                      immVertex2f(pos, v2d->cur.xmax, start);
                }
                
 -              /* X and Y axis */
 -              UI_ThemeColorShade(colorid, offset - 8);
 -              glVertex2f(0.0f, v2d->cur.ymin);
 -              glVertex2f(0.0f, v2d->cur.ymax);
 -              glVertex2f(v2d->cur.xmin, 0.0f);
 -              glVertex2f(v2d->cur.xmax, 0.0f);
 -              
 -              glEnd();
 -              
                lstep *= level_size;
                offset -= 6;
        }
 +
 +      /* X and Y axis */
 +      UI_GetThemeColorShade3ubv(colorid, -18 + ((totlevels - 1) * -6) , grid_line_color);
 +
 +      immSkipAttrib(color);
 +      immVertex2f(pos, 0.0f, v2d->cur.ymin);
 +      immAttrib3ubv(color, grid_line_color);
 +      immVertex2f(pos, 0.0f, v2d->cur.ymax);
 +
 +      immSkipAttrib(color);
 +      immVertex2f(pos, v2d->cur.xmin, 0.0f);
 +      immAttrib3ubv(color, grid_line_color);
 +      immVertex2f(pos, v2d->cur.xmax, 0.0f);
 +
 +      immEnd();
 +      immUnbindProgram();
  }
  
  /* the price we pay for not exposting structs :( */
@@@ -1800,10 -1693,6 +1800,10 @@@ void UI_view2d_scrollers_draw(const bCo
        Scene *scene = CTX_data_scene(C);
        rcti vert, hor;
        int scroll = view2d_scroll_mapped(v2d->scroll);
 +      unsigned char scrollers_back_color[4];
 +
 +      /* Color for scrollbar backs */
 +      UI_GetThemeColor4ubv(TH_BACK, scrollers_back_color);
        
        /* make copies of rects for less typing */
        vert = vs->vert;
                uiWidgetColors wcol = btheme->tui.wcol_scroll;
                rcti slider;
                int state;
 -              unsigned char col[4];
                
                slider.xmin = vs->hor_min;
                slider.xmax = vs->hor_max;
                }
                
                /* clean rect behind slider, but not with transparent background */
 -              UI_GetThemeColor4ubv(TH_BACK, col);
 -              if (col[3] == 255) {
 -                      glColor3ub(col[0], col[1], col[2]);
 -                      glRecti(v2d->hor.xmin, v2d->hor.ymin, v2d->hor.xmax, v2d->hor.ymax);
 +              if (scrollers_back_color[3] == 255) {
 +                      Gwn_VertFormat *format = immVertexFormat();
 +                      unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_I32, 2, GWN_FETCH_INT_TO_FLOAT);
 +
 +                      immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
 +
 +                      immUniformColor3ubv(scrollers_back_color);
 +                      immRecti(pos, v2d->hor.xmin, v2d->hor.ymin, v2d->hor.xmax, v2d->hor.ymax);
 +
 +                      immUnbindProgram();
                }
                
                UI_draw_widget_scroll(&wcol, &hor, &slider, state);
                
                /* scale indicators */
                if ((scroll & V2D_SCROLL_SCALE_HORIZONTAL) && (vs->grid)) {
 +                      const int font_id = BLF_default();
                        View2DGrid *grid = vs->grid;
                        float fac, dfac, fac2, val;
                        
                        dfac = dfac * BLI_rcti_size_x(&hor);
                        
                        /* set starting value, and text color */
 -                      UI_ThemeColor(TH_TEXT);
 +                      UI_FontThemeColor(font_id, TH_TEXT);
                        val = grid->startx;
                        
                        /* if we're clamping to whole numbers only, make sure entries won't be repeated */
                        }
                        if (vs->xunits == V2D_UNIT_FRAMES)
                                grid->powerx = 1;
 -                      
 +
                        /* draw numbers in the appropriate range */
                        if (dfac > 0.0f) {
                                float h = 0.1f * UI_UNIT_Y + (float)(hor.ymin);
                uiWidgetColors wcol = btheme->tui.wcol_scroll;
                rcti slider;
                int state;
 -              unsigned char col[4];
                
                slider.xmin = vert.xmin;
                slider.xmax = vert.xmax;
                }
                
                /* clean rect behind slider, but not with transparent background */
 -              UI_GetThemeColor4ubv(TH_BACK, col);
 -              if (col[3] == 255) {
 -                      glColor3ub(col[0], col[1], col[2]);
 -                      glRecti(v2d->vert.xmin, v2d->vert.ymin, v2d->vert.xmax, v2d->vert.ymax);
 +              if (scrollers_back_color[3] == 255) {
 +                      Gwn_VertFormat *format = immVertexFormat();
 +                      unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_I32, 2, GWN_FETCH_INT_TO_FLOAT);
 +
 +                      immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
 +
 +                      immUniformColor3ubv(scrollers_back_color);
 +                      immRecti(pos, v2d->vert.xmin, v2d->vert.ymin, v2d->vert.xmax, v2d->vert.ymax);
 +
 +                      immUnbindProgram();
                }
                
                UI_draw_widget_scroll(&wcol, &vert, &slider, state);
                        dfac = dfac     * BLI_rcti_size_y(&vert);
                        
                        /* set starting value, and text color */
 -                      UI_ThemeColor(TH_TEXT);
 +                      const int font_id = BLF_default();
 +                      UI_FontThemeColor(font_id, TH_TEXT);
                        val = grid->starty;
                        
                        /* if vertical clamping (to whole numbers) is used (i.e. in Sequencer), apply correction */
                                
                        /* draw vertical steps */
                        if (dfac > 0.0f) {
 -                              
 -                              BLF_rotation_default(M_PI_2);
 -                              BLF_enable_default(BLF_ROTATION);
 +                              BLF_rotation(font_id, M_PI_2);
 +                              BLF_enable(font_id, BLF_ROTATION);
  
                                for (; fac < vert.ymax - 10; fac += dfac, val += grid->dy) {
                                        
                                        scroll_printstr(scene, (float)(vert.xmax) - 2.0f, fac, val, grid->powery, vs->yunits, 'v');
                                }
                                
 -                              BLF_disable_default(BLF_ROTATION);
 +                              BLF_disable(font_id, BLF_ROTATION);
                        }
                }
        }
@@@ -2260,6 -2138,14 +2260,14 @@@ void UI_view2d_view_to_region_rcti(View
        clamp_rctf_to_rcti(rect_dst, &rect_tmp);
  }
  
+ void UI_view2d_view_to_region_m4(View2D *v2d, float matrix[4][4])
+ {
+       rctf mask;
+       unit_m4(matrix);
+       BLI_rctf_rcti_copy(&mask, &v2d->mask);
+       BLI_rctf_transform_calc_m4_pivot_min(&v2d->cur, &mask, matrix);
+ }
  bool UI_view2d_view_to_region_rcti_clip(View2D *v2d, const rctf *rect_src, rcti *rect_dst)
  {
        const float cur_size[2]  = {BLI_rctf_size_x(&v2d->cur),  BLI_rctf_size_y(&v2d->cur)};
@@@ -2514,8 -2400,7 +2522,8 @@@ void UI_view2d_text_cache_draw(ARegion 
        int col_pack_prev = 0;
  
        /* investigate using BLF_ascender() */
 -      const float default_height = g_v2d_strings ? BLF_height_default("28", 3) : 0.0f;
 +      const int font_id = BLF_default();
 +      const float default_height = g_v2d_strings ? BLF_height(font_id, "28", 3) : 0.0f;
  
        wmOrtho2_region_pixelspace(ar);
  
                if (yofs < 1) yofs = 1;
  
                if (col_pack_prev != v2s->col.pack) {
 -                      glColor3ubv(v2s->col.ub);
 +                      BLF_color3ubv(font_id, v2s->col.ub);
                        col_pack_prev = v2s->col.pack;
                }
  
                        BLF_draw_default((float)(v2s->mval[0] + xofs), (float)(v2s->mval[1] + yofs), 0.0,
                                          v2s->str, BLF_DRAW_STR_DUMMY_MAX);
                else {
 -                      BLF_clipping_default(v2s->rect.xmin - 4, v2s->rect.ymin - 4, v2s->rect.xmax + 4, v2s->rect.ymax + 4);
 -                      BLF_enable_default(BLF_CLIPPING);
 +                      BLF_enable(font_id, BLF_CLIPPING);
 +                      BLF_clipping(font_id, v2s->rect.xmin - 4, v2s->rect.ymin - 4, v2s->rect.xmax + 4, v2s->rect.ymax + 4);
                        BLF_draw_default(v2s->rect.xmin + xofs, v2s->rect.ymin + yofs, 0.0f,
                                         v2s->str, BLF_DRAW_STR_DUMMY_MAX);
 -                      BLF_disable_default(BLF_CLIPPING);
 +                      BLF_disable(font_id, BLF_CLIPPING);
                }
        }
        g_v2d_strings = NULL;
                BLI_memarena_free(g_v2d_strings_arena);
                g_v2d_strings_arena = NULL;
        }
 -
 -      // glMatrixMode(GL_PROJECTION);
 -      // glPopMatrix();
 -      // glMatrixMode(GL_MODELVIEW);
 -      // glPopMatrix();
  }