blender
/
blender
129
398
Fork 572
Code Issues 6.2k Pull Requests 747 Projects 19 Wiki Activity

UI: Optimize the area border drawing 

It is was not really a bottleneck but it was triggering my OCD when 1/3rd
of the drawcalls in a normal scene were basically only caused by this.
This commit is contained in:
Clément Foucault 2018-08-23 22:29:29 +02:00
parent fb7fc3be19
commit 34b3d6e2f8
5 changed files with 165 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

164
source/blender/editors/screen/screen_draw.c
View File

@ -24,12 +24,14 @@
#include "ED_screen.h"
#include "GPU_batch_presets.h"
#include "GPU_framebuffer.h"
#include "GPU_immediate.h"
#include "GPU_matrix.h"
#include "GPU_state.h"
#include "BLI_math.h"
#include "BLI_rect.h"
#include "WM_api.h"
#include "WM_types.h"
@ -214,7 +216,85 @@ static void draw_join_shape(ScrArea *sa, char dir, unsigned int pos)
}
}
#define CORNER_RESOLUTION 10
#define CORNER_RESOLUTION 9
static void do_vert_pair(GPUVertBuf *vbo, uint pos, uint *vidx, int corner, int i)
{
float inter[2], exter[2];
inter[0] = cosf((corner * 2.0f * M_PI / 4.0f) + (i * M_PI_2 / (CORNER_RESOLUTION - 1.0f)));
inter[1] = sinf((corner * 2.0f * M_PI / 4.0f) + (i * M_PI_2 / (CORNER_RESOLUTION - 1.0f)));
/* Snap point to edge */
float div = 1.0f / max_ff(fabsf(inter[0]), fabsf(inter[1]));
mul_v2_v2fl(exter, inter, div);
exter[0] = roundf(exter[0]);
exter[1] = roundf(exter[1]);
if (i == 0 || i == (CORNER_RESOLUTION - 1)) {
copy_v2_v2(inter, exter);
}
/* Line width is 20% of the entire corner size. */
const float line_width = 0.2f;
mul_v2_fl(inter, 1.0f - line_width);
mul_v2_fl(exter, 1.0f + line_width);
switch (corner) {
case 0:
add_v2_v2(inter, (float[2]){-1.0f, -1.0f});
add_v2_v2(exter, (float[2]){-1.0f, -1.0f});
break;
case 1:
add_v2_v2(inter, (float[2]){1.0f, -1.0f});
add_v2_v2(exter, (float[2]){1.0f, -1.0f});
break;
case 2:
add_v2_v2(inter, (float[2]){1.0f, 1.0f});
add_v2_v2(exter, (float[2]){1.0f, 1.0f});
break;
case 3:
add_v2_v2(inter, (float[2]){-1.0f, 1.0f});
add_v2_v2(exter, (float[2]){-1.0f, 1.0f});
break;
}
GPU_vertbuf_attr_set(vbo, pos, (*vidx)++, inter);
GPU_vertbuf_attr_set(vbo, pos, (*vidx)++, exter);
}
static GPUBatch *batch_screen_edges_get(int *corner_len)
{
static GPUBatch *screen_edges_batch = NULL;
if (screen_edges_batch == NULL) {
GPUVertFormat format = {0};
uint pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
GPU_vertbuf_data_alloc(vbo, CORNER_RESOLUTION * 2 * 4 * 8 + 2);
uint vidx = 0;
/* Note jitter is applied in the shader. */
for (int jit = 0; jit < 8; ++jit) {
for (int corner = 0; corner < 4; ++corner) {
for (int c = 0; c < CORNER_RESOLUTION; ++c) {
do_vert_pair(vbo, pos, &vidx, corner, c);
}
}
}
/* close the loop */
do_vert_pair(vbo, pos, &vidx, 0, 0);
screen_edges_batch = GPU_batch_create_ex(GPU_PRIM_TRI_STRIP, vbo, NULL, GPU_BATCH_OWNS_VBO);
gpu_batch_presets_register(screen_edges_batch);
}
if (corner_len) {
*corner_len = CORNER_RESOLUTION * 2;
}
return screen_edges_batch;
}
static void drawscredge_corner_geometry(
int sizex, int sizey,
int corner_x, int corner_y,
@ -373,59 +453,47 @@ static void scrarea_draw_shape_light(ScrArea *sa, char UNUSED(dir), unsigned int
immRectf(pos, sa->v1->vec.x, sa->v1->vec.y, sa->v3->vec.x, sa->v3->vec.y);
}
static void drawscredge_area_draw(int sizex, int sizey, short x1, short y1, short x2, short y2, unsigned int pos)
static void drawscredge_area_draw(int sizex, int sizey, short x1, short y1, short x2, short y2, float edge_thickness)
{
int count = 0;
if (x2 < sizex - 1) count += 2;
if (x1 > 0) count += 2;
if (y2 < sizey - 1) count += 2;
if (y1 > 0) count += 2;
if (count == 0) {
return;
}
immBegin(GPU_PRIM_LINES, count);
rctf rect;
BLI_rctf_init(&rect, (float)x1, (float)x2, (float)y1, (float)y2);
/* right border area */
if (x2 < sizex - 1) {
immVertex2f(pos, x2, y1);
immVertex2f(pos, x2, y2);
if (x2 >= sizex - 1) {
rect.xmax += edge_thickness * 0.5f;
}
/* left border area */
if (x1 > 0) { /* otherwise it draws the emboss of window over */
immVertex2f(pos, x1, y1);
immVertex2f(pos, x1, y2);
if (x1 <= 0) { /* otherwise it draws the emboss of window over */
rect.xmin -= edge_thickness * 0.5f;
}
/* top border area */
if (y2 < sizey - 1) {
immVertex2f(pos, x1, y2);
immVertex2f(pos, x2, y2);
if (y2 >= sizey - 1) {
rect.ymax += edge_thickness * 0.5f;
}
/* bottom border area */
if (y1 > 0) {
immVertex2f(pos, x1, y1);
immVertex2f(pos, x2, y1);
if (y1 <= 0) {
rect.ymin -= edge_thickness * 0.5f;
}
immEnd();
GPUBatch *batch = batch_screen_edges_get(NULL);
GPU_batch_uniform_4fv(batch, "rect", (float *)&rect);
GPU_batch_draw(batch);
}
/**
* \brief Screen edges drawing.
*/
static void drawscredge_area(ScrArea *sa, int sizex, int sizey, unsigned int pos)
static void drawscredge_area(ScrArea *sa, int sizex, int sizey, float edge_thickness)
{
short x1 = sa->v1->vec.x;
short y1 = sa->v1->vec.y;
short x2 = sa->v3->vec.x;
short y2 = sa->v3->vec.y;
drawscredge_area_draw(sizex, sizey, x1, y1, x2, y2, pos);
drawscredge_area_draw(sizex, sizey, x1, y1, x2, y2, edge_thickness);
}
/**
@ -436,34 +504,38 @@ void ED_screen_draw_edges(wmWindow *win)
bScreen *screen = WM_window_get_active_screen(win);
const int winsize_x = WM_window_pixels_x(win);
const int winsize_y = WM_window_pixels_y(win);
float col[4], corner_scale, edge_thickness;
int verts_per_corner = 0;
ScrArea *sa;
uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
UI_GetThemeColor4fv(TH_EDITOR_OUTLINE, col);
col[3] = 1.0f / 8.0f;
corner_scale = U.pixelsize * 8.0f;
edge_thickness = corner_scale * 0.21f;
/* Note: first loop only draws if U.pixelsize > 1, skip otherwise */
if (U.pixelsize > 1.0f) {
/* FIXME: doesn't our glLineWidth already scale by U.pixelsize? */
GPU_line_width((2.0f * U.pixelsize) - 1);
immUniformThemeColor(TH_EDITOR_OUTLINE);
GPU_blend(true);
for (sa = screen->areabase.first; sa; sa = sa->next) {
drawscredge_area(sa, winsize_x, winsize_y, pos);
}
}
GPU_line_width(1);
immUniformThemeColor(TH_EDITOR_OUTLINE);
/* Transparent pass (for AA). */
GPUBatch *batch = batch_screen_edges_get(&verts_per_corner);
GPU_batch_program_set_builtin(batch, GPU_SHADER_2D_AREA_EDGES);
GPU_batch_uniform_1i(batch, "cornerLen", verts_per_corner);
GPU_batch_uniform_1f(batch, "scale", corner_scale);
GPU_batch_uniform_4fv(batch, "color", col);
for (sa = screen->areabase.first; sa; sa = sa->next) {
drawscredge_area(sa, winsize_x, winsize_y, pos);
drawscredge_area(sa, winsize_x, winsize_y, edge_thickness);
}
immUnbindProgram();
GPU_blend(false);
/* Opaque pass. */
corner_scale -= 2.0f;
edge_thickness = corner_scale * 0.2f;
GPU_batch_uniform_1f(batch, "scale", corner_scale);
for (sa = screen->areabase.first; sa; sa = sa->next) {
drawscredge_corner(sa, winsize_x, winsize_y);
drawscredge_area(sa, winsize_x, winsize_y, edge_thickness);
}
screen->do_draw = false;

1
source/blender/gpu/CMakeLists.txt
View File

@ -141,6 +141,7 @@ data_to_c_simple(shaders/gpu_shader_flat_color_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_flat_color_alpha_test_0_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_flat_id_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_2D_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_2D_area_borders_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_2D_widget_base_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_2D_widget_base_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_2D_widget_shadow_vert.glsl SRC)

1
source/blender/gpu/GPU_shader.h
View File

@ -351,6 +351,7 @@ typedef enum GPUBuiltinShader {
GPU_SHADER_GPENCIL_STROKE,
GPU_SHADER_GPENCIL_FILL,
/* specialized for widget drawing */
GPU_SHADER_2D_AREA_EDGES,
GPU_SHADER_2D_WIDGET_BASE,
GPU_SHADER_2D_WIDGET_BASE_INST,
GPU_SHADER_2D_WIDGET_SHADOW,

3
source/blender/gpu/intern/gpu_shader.c
View File

@ -63,6 +63,7 @@ extern char datatoc_gpu_shader_simple_lighting_smooth_color_alpha_frag_glsl[];
extern char datatoc_gpu_shader_flat_color_frag_glsl[];
extern char datatoc_gpu_shader_flat_color_alpha_test_0_frag_glsl[];
extern char datatoc_gpu_shader_flat_id_frag_glsl[];
extern char datatoc_gpu_shader_2D_area_borders_vert_glsl[];
extern char datatoc_gpu_shader_2D_vert_glsl[];
extern char datatoc_gpu_shader_2D_flat_color_vert_glsl[];
extern char datatoc_gpu_shader_2D_smooth_color_uniform_alpha_vert_glsl[];
@ -878,6 +879,8 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
datatoc_gpu_shader_flat_color_frag_glsl,
datatoc_gpu_shader_instance_edges_variying_color_geom_glsl},
[GPU_SHADER_2D_AREA_EDGES] = { datatoc_gpu_shader_2D_area_borders_vert_glsl,
datatoc_gpu_shader_uniform_color_frag_glsl},
[GPU_SHADER_2D_WIDGET_BASE] = { datatoc_gpu_shader_2D_widget_base_vert_glsl,
datatoc_gpu_shader_2D_widget_base_frag_glsl},
[GPU_SHADER_2D_WIDGET_BASE_INST] = { datatoc_gpu_shader_2D_widget_base_vert_glsl,

42
source/blender/gpu/shaders/gpu_shader_2D_area_borders_vert.glsl Normal file
View File

@ -0,0 +1,42 @@
uniform mat4 ModelViewProjectionMatrix;
uniform vec4 rect;
uniform int cornerLen;
uniform float scale;
in vec2 pos;
const vec2 jitter_ofs[8] = vec2[8](
vec2( 0.468813, -0.481430), vec2(-0.155755, -0.352820),
vec2( 0.219306, -0.238501), vec2(-0.393286, -0.110949),
vec2(-0.024699, 0.013908), vec2( 0.343805, 0.147431),
vec2(-0.272855, 0.269918), vec2( 0.095909, 0.388710)
);
void main()
{
int corner_id = (gl_VertexID / cornerLen) % 4;
int jitter_id = gl_VertexID / (cornerLen * 4) % 8;
vec2 final_pos = pos * scale;
if (corner_id == 0)
final_pos += rect.yw; /* top right */
else if (corner_id == 1)
final_pos += rect.xw; /* top left */
else if (corner_id == 2)
final_pos += rect.xz; /* bottom left */
else
final_pos += rect.yz; /* bottom right */
/* Only jitter verts inside the corner (not the one shared with the edges). */
if ((gl_VertexID % cornerLen) % (cornerLen - 2) != 0) {
/* Only jitter intern verts not boundaries. */
if ((gl_VertexID % 2) == 0) {
final_pos += jitter_ofs[jitter_id];
}
}
gl_Position = (ModelViewProjectionMatrix * vec4(final_pos, 0.0, 1.0));
}