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

Code cleanup: stop using rectangle textures in window draw, simplify code.

This commit is contained in:
Brecht Van Lommel 2018-02-13 18:09:58 +01:00
parent afb213f876
commit e9b1163162
8 changed files with 63 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -142,13 +142,13 @@ data_to_c_simple(shaders/gpu_shader_2D_line_dashed_geom.glsl SRC)
data_to_c_simple(shaders/gpu_shader_2D_smooth_color_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_2D_smooth_color_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_2D_image_vert.glsl SRC)
data_to_c_simple(shaders/gpu_shader_image_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_image_linear_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_image_shuffle_color_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_image_mask_uniform_color_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_image_modulate_alpha_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_image_alpha_color_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_image_color_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_image_rect_modulate_alpha_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_image_depth_linear_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_image_interlace_frag.glsl SRC)
data_to_c_simple(shaders/gpu_shader_3D_image_vert.glsl SRC)

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

@ -113,8 +113,10 @@ typedef enum GPUBuiltinShader {
GPU_SHADER_2D_UNIFORM_COLOR,
GPU_SHADER_2D_FLAT_COLOR,
GPU_SHADER_2D_SMOOTH_COLOR,
GPU_SHADER_2D_IMAGE,
GPU_SHADER_2D_IMAGE_COLOR,
GPU_SHADER_2D_IMAGE_ALPHA_COLOR,
GPU_SHADER_2D_IMAGE_ALPHA,
GPU_SHADER_2D_CHECKER,
GPU_SHADER_2D_DIAG_STRIPES,
/* for simple 3D drawing */
@ -131,7 +133,6 @@ typedef enum GPUBuiltinShader {
GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR,
GPU_SHADER_2D_IMAGE_MASK_UNIFORM_COLOR,
GPU_SHADER_3D_IMAGE_MODULATE_ALPHA,
GPU_SHADER_3D_IMAGE_RECT_MODULATE_ALPHA,
GPU_SHADER_3D_IMAGE_DEPTH,
/* stereo 3d */
GPU_SHADER_2D_IMAGE_INTERLACE,

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

@ -68,6 +68,7 @@ extern char datatoc_gpu_shader_2D_smooth_color_frag_glsl[];
extern char datatoc_gpu_shader_2D_image_vert_glsl[];
extern char datatoc_gpu_shader_3D_image_vert_glsl[];
extern char datatoc_gpu_shader_image_frag_glsl[];
extern char datatoc_gpu_shader_image_linear_frag_glsl[];
extern char datatoc_gpu_shader_image_color_frag_glsl[];
extern char datatoc_gpu_shader_image_alpha_color_frag_glsl[];
@ -75,7 +76,6 @@ extern char datatoc_gpu_shader_image_shuffle_color_frag_glsl[];
extern char datatoc_gpu_shader_image_interlace_frag_glsl[];
extern char datatoc_gpu_shader_image_mask_uniform_color_frag_glsl[];
extern char datatoc_gpu_shader_image_modulate_alpha_frag_glsl[];
extern char datatoc_gpu_shader_image_rect_modulate_alpha_frag_glsl[];
extern char datatoc_gpu_shader_image_depth_linear_frag_glsl[];
extern char datatoc_gpu_shader_3D_vert_glsl[];
extern char datatoc_gpu_shader_3D_normal_vert_glsl[];
@ -710,8 +710,6 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
datatoc_gpu_shader_image_mask_uniform_color_frag_glsl },
[GPU_SHADER_3D_IMAGE_MODULATE_ALPHA] = { datatoc_gpu_shader_3D_image_vert_glsl,
datatoc_gpu_shader_image_modulate_alpha_frag_glsl },
[GPU_SHADER_3D_IMAGE_RECT_MODULATE_ALPHA] = { datatoc_gpu_shader_3D_image_vert_glsl,
datatoc_gpu_shader_image_rect_modulate_alpha_frag_glsl },
[GPU_SHADER_3D_IMAGE_DEPTH] = { datatoc_gpu_shader_3D_image_vert_glsl,
datatoc_gpu_shader_image_depth_linear_frag_glsl },
@ -728,10 +726,14 @@ GPUShader *GPU_shader_get_builtin_shader(GPUBuiltinShader shader)
datatoc_gpu_shader_2D_smooth_color_frag_glsl },
[GPU_SHADER_2D_IMAGE_LINEAR_TO_SRGB] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_linear_frag_glsl },
[GPU_SHADER_2D_IMAGE] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_frag_glsl },
[GPU_SHADER_2D_IMAGE_COLOR] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_color_frag_glsl },
[GPU_SHADER_2D_IMAGE_ALPHA_COLOR] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_alpha_color_frag_glsl },
[GPU_SHADER_2D_IMAGE_ALPHA] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_modulate_alpha_frag_glsl },
[GPU_SHADER_2D_IMAGE_SHUFFLE_COLOR] = { datatoc_gpu_shader_2D_image_vert_glsl,
datatoc_gpu_shader_image_shuffle_color_frag_glsl },
[GPU_SHADER_3D_UNIFORM_COLOR] = { datatoc_gpu_shader_3D_vert_glsl, datatoc_gpu_shader_uniform_color_frag_glsl },

4
source/blender/gpu/shaders/gpu_shader_image_rect_modulate_alpha_frag.glsl → source/blender/gpu/shaders/gpu_shader_image_frag.glsl
View File

@ -2,11 +2,9 @@
in vec2 texCoord_interp;
out vec4 fragColor;
uniform float alpha;
uniform sampler2DRect image;
uniform sampler2D image;
void main()
{
fragColor = texture(image, texCoord_interp);
fragColor.a *= alpha;
}

4
source/blender/gpu/shaders/gpu_shader_image_interlace_frag.glsl
View File

@ -8,8 +8,8 @@ in vec2 texCoord_interp;
out vec4 fragColor;
uniform int interlace_id;
uniform sampler2DRect image_a;
uniform sampler2DRect image_b;
uniform sampler2D image_a;
uniform sampler2D image_b;
bool interlace()
{

66
source/blender/windowmanager/intern/wm_draw.c
View File

@ -430,15 +430,8 @@ static void wm_draw_triple_fail(bContext *C, wmWindow *win)
static bool wm_triple_gen_textures(wmWindow *win, wmDrawTriple *triple)
{
/* compute texture sizes */
triple->x = WM_window_pixels_x(win);
triple->y = WM_window_pixels_y(win);
#if USE_TEXTURE_RECTANGLE
/* GL_TEXTURE_RECTANGLE is part of GL 3.1 so we can use it soon without runtime checks */
triple->target = GL_TEXTURE_RECTANGLE;
#else
triple->target = GL_TEXTURE_2D;
#endif
const int sizex = WM_window_pixels_x(win);
const int sizey = WM_window_pixels_y(win);
/* generate texture names */
glGenTextures(1, &triple->bind);
@ -447,29 +440,25 @@ static bool wm_triple_gen_textures(wmWindow *win, wmDrawTriple *triple)
* there is only one texture in use, which may not be the case */
const GLint maxsize = GPU_max_texture_size();
if (triple->x > maxsize || triple->y > maxsize) {
if (sizex > maxsize || sizey > maxsize) {
printf("WM: failed to allocate texture for triple buffer drawing "
"(texture too large for graphics card).\n");
return false;
}
/* setup actual texture */
glBindTexture(triple->target, triple->bind);
glBindTexture(GL_TEXTURE_2D, triple->bind);
/* no mipmaps */
#if USE_TEXTURE_RECTANGLE
/* already has no mipmaps */
#else
glTexParameteri(triple->target, GL_TEXTURE_MAX_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
/* GL_TEXTURE_BASE_LEVEL = 0 by default */
#endif
glTexParameteri(triple->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(triple->target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(triple->target, 0, GL_RGB8, triple->x, triple->y, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, sizex, sizey, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glBindTexture(triple->target, 0);
glBindTexture(GL_TEXTURE_2D, 0);
return true;
}
@ -480,19 +469,10 @@ void wm_triple_draw_textures(wmWindow *win, wmDrawTriple *triple, float alpha)
const int sizey = WM_window_pixels_y(win);
/* wmOrtho for the screen has this same offset */
float ratiox = sizex;
float ratioy = sizey;
float halfx = GLA_PIXEL_OFS;
float halfy = GLA_PIXEL_OFS;
#if USE_TEXTURE_RECTANGLE
/* texture rectangle has unnormalized coordinates */
#else
ratiox /= triple->x;
ratioy /= triple->y;
halfx /= triple->x;
halfy /= triple->y;
#endif
const float ratiox = 1.0f;
const float ratioy = 1.0f;
const float halfx = GLA_PIXEL_OFS / sizex;
const float halfy = GLA_PIXEL_OFS / sizey;
Gwn_VertFormat *format = immVertexFormat();
unsigned int texcoord = GWN_vertformat_attr_add(format, "texCoord", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
@ -500,16 +480,10 @@ void wm_triple_draw_textures(wmWindow *win, wmDrawTriple *triple, float alpha)
const int activeTex = 7; /* arbitrary */
glActiveTexture(GL_TEXTURE0 + activeTex);
glBindTexture(triple->target, triple->bind);
glBindTexture(GL_TEXTURE_2D, triple->bind);
immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_ALPHA);
#if USE_TEXTURE_RECTANGLE
immBindBuiltinProgram(GPU_SHADER_3D_IMAGE_RECT_MODULATE_ALPHA);
#else
immBindBuiltinProgram(GPU_SHADER_3D_IMAGE_MODULATE_ALPHA);
/* TODO: make pure 2D version
* and a 2D_IMAGE (replace, not modulate) version for when alpha = 1.0
*/
#endif
immUniform1f("alpha", alpha);
immUniform1i("image", activeTex);
@ -530,7 +504,7 @@ void wm_triple_draw_textures(wmWindow *win, wmDrawTriple *triple, float alpha)
immEnd();
immUnbindProgram();
glBindTexture(triple->target, 0);
glBindTexture(GL_TEXTURE_2D, 0);
if (activeTex != 0)
glActiveTexture(GL_TEXTURE0);
}
@ -540,10 +514,10 @@ static void wm_triple_copy_textures(wmWindow *win, wmDrawTriple *triple)
const int sizex = WM_window_pixels_x(win);
const int sizey = WM_window_pixels_y(win);
glBindTexture(triple->target, triple->bind);
glBindTexture(GL_TEXTURE_2D, triple->bind);
/* what is GL_READ_BUFFER right now? */
glCopyTexSubImage2D(triple->target, 0, 0, 0, 0, 0, sizex, sizey);
glBindTexture(triple->target, 0);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, sizex, sizey);
glBindTexture(GL_TEXTURE_2D, 0);
}
static void wm_draw_region_blend(wmWindow *win, ARegion *ar, wmDrawTriple *triple)

85
source/blender/windowmanager/intern/wm_stereo.c
View File

@ -110,10 +110,10 @@ static void wm_method_draw_stereo3d_interlace(wmWindow *win)
const int sizey = WM_window_pixels_y(win);
/* wmOrtho for the screen has this same offset */
float ratiox = sizex;
float ratioy = sizey;
float halfx = GLA_PIXEL_OFS;
float halfy = GLA_PIXEL_OFS;
float ratiox = 1.0f;
float ratioy = 1.0f;
float halfx = GLA_PIXEL_OFS / sizex;
float halfy = GLA_PIXEL_OFS / sizex;
Gwn_VertFormat *format = immVertexFormat();
unsigned int texcoord = GWN_vertformat_attr_add(format, "texCoord", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
@ -124,7 +124,7 @@ static void wm_method_draw_stereo3d_interlace(wmWindow *win)
/* leave GL_TEXTURE0 as the latest bind texture */
for (int eye = 1; eye >= 0; eye--) {
glActiveTexture(GL_TEXTURE0 + eye);
glBindTexture(drawdata[eye]->triple->target, drawdata[eye]->triple->bind);
glBindTexture(GL_TEXTURE_2D, drawdata[eye]->triple->bind);
}
immUniform1i("image_a", 0);
@ -149,8 +149,9 @@ static void wm_method_draw_stereo3d_interlace(wmWindow *win)
immEnd();
immUnbindProgram();
for (int eye = 0; eye < 2; eye++) {
glBindTexture(drawdata[eye]->triple->target, 0);
for (int eye = 1; eye >= 0; eye--) {
glActiveTexture(GL_TEXTURE0 + eye);
glBindTexture(GL_TEXTURE_2D, 0);
}
}
@ -194,7 +195,6 @@ static void wm_method_draw_stereo3d_sidebyside(wmWindow *win)
{
wmDrawData *drawdata;
wmDrawTriple *triple;
float halfx, halfy, ratiox, ratioy;
int view;
int soffx;
bool cross_eyed = (win->stereo3d_format->flag & S3D_SIDEBYSIDE_CROSSEYED) != 0;
@ -203,6 +203,8 @@ static void wm_method_draw_stereo3d_sidebyside(wmWindow *win)
unsigned int texcoord = GWN_vertformat_attr_add(format, "texCoord", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_ALPHA);
for (view = 0; view < 2; view ++) {
drawdata = BLI_findlink(&win->drawdata, (view * 2) + 1);
triple = drawdata->triple;
@ -217,27 +219,16 @@ static void wm_method_draw_stereo3d_sidebyside(wmWindow *win)
soffx = 0;
}
const int sizex = triple->x;
const int sizey = triple->y;
const int sizex = WM_window_pixels_x(win);
const int sizey = WM_window_pixels_y(win);
/* wmOrtho for the screen has this same offset */
ratiox = sizex;
ratioy = sizey;
halfx = GLA_PIXEL_OFS;
halfy = GLA_PIXEL_OFS;
const float ratiox = 1.0f;
const float ratioy = 1.0f;
const float halfx = GLA_PIXEL_OFS / sizex;
const float halfy = GLA_PIXEL_OFS / sizey;
/* texture rectangle has unnormalized coordinates */
if (triple->target == GL_TEXTURE_2D) {
ratiox /= triple->x;
ratioy /= triple->y;
halfx /= triple->x;
halfy /= triple->y;
}
/* TODO: if target is always same for both eyes, bind program & set uniform before loop */
immBindBuiltinProgram((triple->target == GL_TEXTURE_2D) ? GPU_SHADER_3D_IMAGE_MODULATE_ALPHA : GPU_SHADER_3D_IMAGE_RECT_MODULATE_ALPHA);
glBindTexture(triple->target, triple->bind);
glBindTexture(GL_TEXTURE_2D, triple->bind);
immUniform1f("alpha", 1.0f);
immUniform1i("image", 0); /* default GL_TEXTURE0 unit */
@ -257,18 +248,16 @@ static void wm_method_draw_stereo3d_sidebyside(wmWindow *win)
immVertex2f(pos, soffx, sizey);
immEnd();
/* TODO: if target is always same for both eyes, unbind program & texture target after loop */
glBindTexture(triple->target, 0);
immUnbindProgram();
}
glBindTexture(GL_TEXTURE_2D, 0);
immUnbindProgram();
}
static void wm_method_draw_stereo3d_topbottom(wmWindow *win)
{
wmDrawData *drawdata;
wmDrawTriple *triple;
float halfx, halfy, ratiox, ratioy;
int view;
int soffy;
@ -276,6 +265,8 @@ static void wm_method_draw_stereo3d_topbottom(wmWindow *win)
unsigned int texcoord = GWN_vertformat_attr_add(format, "texCoord", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
unsigned int pos = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 2, GWN_FETCH_FLOAT);
immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_ALPHA);
for (view = 0; view < 2; view ++) {
drawdata = BLI_findlink(&win->drawdata, (view * 2) + 1);
triple = drawdata->triple;
@ -287,27 +278,16 @@ static void wm_method_draw_stereo3d_topbottom(wmWindow *win)
soffy = 0;
}
const int sizex = triple->x;
const int sizey = triple->y;
const int sizex = WM_window_pixels_x(win);
const int sizey = WM_window_pixels_y(win);
/* wmOrtho for the screen has this same offset */
ratiox = sizex;
ratioy = sizey;
halfx = GLA_PIXEL_OFS;
halfy = GLA_PIXEL_OFS;
const float ratiox = 1.0f;
const float ratioy = 1.0f;
const float halfx = GLA_PIXEL_OFS / sizex;
const float halfy = GLA_PIXEL_OFS / sizey;
/* texture rectangle has unnormalized coordinates */
if (triple->target == GL_TEXTURE_2D) {
ratiox /= triple->x;
ratioy /= triple->y;
halfx /= triple->x;
halfy /= triple->y;
}
/* TODO: if target is always same for both eyes, bind program & set uniforms before loop */
immBindBuiltinProgram((triple->target == GL_TEXTURE_2D) ? GPU_SHADER_3D_IMAGE_MODULATE_ALPHA : GPU_SHADER_3D_IMAGE_RECT_MODULATE_ALPHA);
glBindTexture(triple->target, triple->bind);
glBindTexture(GL_TEXTURE_2D, triple->bind);
immUniform1f("alpha", 1.0f);
immUniform1i("image", 0); /* default GL_TEXTURE0 unit */
@ -327,11 +307,10 @@ static void wm_method_draw_stereo3d_topbottom(wmWindow *win)
immVertex2f(pos, 0.0f, soffy + (sizey * 0.5f));
immEnd();
/* TODO: if target is always same for both eyes, unbind program & texture target after loop */
immUnbindProgram();
glBindTexture(triple->target, 0);
}
immUnbindProgram();
glBindTexture(GL_TEXTURE_2D, 0);
}
void wm_method_draw_stereo3d(const bContext *UNUSED(C), wmWindow *win)

4
source/blender/windowmanager/wm_draw.h
View File

@ -34,12 +34,8 @@
#include "GPU_glew.h"
#define USE_TEXTURE_RECTANGLE 1
typedef struct wmDrawTriple {
GLuint bind;
int x, y;
GLenum target;
} wmDrawTriple;
typedef struct wmDrawData {