Antonio Vazquez
f24e9bb038
This parameter allows to define the threshold for SMAA algorithm. Differential Revision: https://developer.blender.org/D7708
336 lines
11 KiB
C
336 lines
11 KiB
C
/*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* Copyright 2019, Blender Foundation.
|
|
*/
|
|
|
|
/** \file
|
|
* \ingroup draw
|
|
*/
|
|
#include "DRW_render.h"
|
|
|
|
#include "gpencil_engine.h"
|
|
|
|
extern char datatoc_gpencil_common_lib_glsl[];
|
|
extern char datatoc_gpencil_frag_glsl[];
|
|
extern char datatoc_gpencil_vert_glsl[];
|
|
extern char datatoc_gpencil_antialiasing_frag_glsl[];
|
|
extern char datatoc_gpencil_antialiasing_vert_glsl[];
|
|
extern char datatoc_gpencil_layer_blend_frag_glsl[];
|
|
extern char datatoc_gpencil_mask_invert_frag_glsl[];
|
|
extern char datatoc_gpencil_depth_merge_frag_glsl[];
|
|
extern char datatoc_gpencil_depth_merge_vert_glsl[];
|
|
extern char datatoc_gpencil_vfx_frag_glsl[];
|
|
|
|
extern char datatoc_common_colormanagement_lib_glsl[];
|
|
extern char datatoc_common_fullscreen_vert_glsl[];
|
|
extern char datatoc_common_smaa_lib_glsl[];
|
|
extern char datatoc_common_view_lib_glsl[];
|
|
|
|
static struct {
|
|
/* SMAA antialiasing */
|
|
GPUShader *antialiasing_sh[3];
|
|
/* GPencil Object rendering */
|
|
GPUShader *gpencil_sh;
|
|
/* Final Compositing over rendered background. */
|
|
GPUShader *composite_sh;
|
|
/* All layer blend types in one shader! */
|
|
GPUShader *layer_blend_sh;
|
|
/* Merge the final object depth to the depth buffer. */
|
|
GPUShader *depth_merge_sh;
|
|
/* Invert the content of the mask buffer. */
|
|
GPUShader *mask_invert_sh;
|
|
/* Effects. */
|
|
GPUShader *fx_composite_sh;
|
|
GPUShader *fx_colorize_sh;
|
|
GPUShader *fx_blur_sh;
|
|
GPUShader *fx_glow_sh;
|
|
GPUShader *fx_pixel_sh;
|
|
GPUShader *fx_rim_sh;
|
|
GPUShader *fx_shadow_sh;
|
|
GPUShader *fx_transform_sh;
|
|
/* general drawing shaders */
|
|
GPUShader *gpencil_fill_sh;
|
|
GPUShader *gpencil_stroke_sh;
|
|
GPUShader *gpencil_point_sh;
|
|
GPUShader *gpencil_edit_point_sh;
|
|
GPUShader *gpencil_line_sh;
|
|
GPUShader *gpencil_drawing_fill_sh;
|
|
GPUShader *gpencil_fullscreen_sh;
|
|
GPUShader *gpencil_simple_fullscreen_sh;
|
|
GPUShader *gpencil_blend_fullscreen_sh;
|
|
GPUShader *gpencil_background_sh;
|
|
GPUShader *gpencil_paper_sh;
|
|
} g_shaders = {{NULL}};
|
|
|
|
void GPENCIL_shader_free(void)
|
|
{
|
|
DRW_SHADER_FREE_SAFE(g_shaders.antialiasing_sh[0]);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.antialiasing_sh[1]);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.antialiasing_sh[2]);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.composite_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.layer_blend_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.depth_merge_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.mask_invert_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.fx_composite_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.fx_colorize_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.fx_blur_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.fx_glow_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.fx_pixel_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.fx_rim_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.fx_shadow_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.fx_transform_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_fill_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_stroke_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_point_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_edit_point_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_line_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_drawing_fill_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_fullscreen_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_simple_fullscreen_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_blend_fullscreen_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_background_sh);
|
|
DRW_SHADER_FREE_SAFE(g_shaders.gpencil_paper_sh);
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_antialiasing(int stage)
|
|
{
|
|
BLI_assert(stage < 3);
|
|
|
|
if (!g_shaders.antialiasing_sh[stage]) {
|
|
char stage_define[32];
|
|
BLI_snprintf(stage_define, sizeof(stage_define), "#define SMAA_STAGE %d\n", stage);
|
|
|
|
g_shaders.antialiasing_sh[stage] = GPU_shader_create_from_arrays({
|
|
.vert =
|
|
(const char *[]){
|
|
"#define SMAA_INCLUDE_VS 1\n",
|
|
"#define SMAA_INCLUDE_PS 0\n",
|
|
"uniform vec4 viewportMetrics;\n",
|
|
datatoc_common_smaa_lib_glsl,
|
|
datatoc_gpencil_antialiasing_vert_glsl,
|
|
NULL,
|
|
},
|
|
.frag =
|
|
(const char *[]){
|
|
"#define SMAA_INCLUDE_VS 0\n",
|
|
"#define SMAA_INCLUDE_PS 1\n",
|
|
"uniform vec4 viewportMetrics;\n",
|
|
datatoc_common_smaa_lib_glsl,
|
|
datatoc_gpencil_antialiasing_frag_glsl,
|
|
NULL,
|
|
},
|
|
.defs =
|
|
(const char *[]){
|
|
"uniform float lumaWeight;\n",
|
|
"#define SMAA_GLSL_3\n",
|
|
"#define SMAA_RT_METRICS viewportMetrics\n",
|
|
"#define SMAA_PRESET_HIGH\n",
|
|
"#define SMAA_LUMA_WEIGHT float4(lumaWeight, lumaWeight, lumaWeight, 0.0)\n",
|
|
"#define SMAA_NO_DISCARD\n",
|
|
stage_define,
|
|
NULL,
|
|
},
|
|
});
|
|
}
|
|
return g_shaders.antialiasing_sh[stage];
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_geometry_get(void)
|
|
{
|
|
if (!g_shaders.gpencil_sh) {
|
|
g_shaders.gpencil_sh = GPU_shader_create_from_arrays({
|
|
.vert =
|
|
(const char *[]){
|
|
datatoc_common_view_lib_glsl,
|
|
datatoc_gpencil_common_lib_glsl,
|
|
datatoc_gpencil_vert_glsl,
|
|
NULL,
|
|
},
|
|
.frag =
|
|
(const char *[]){
|
|
datatoc_common_colormanagement_lib_glsl,
|
|
datatoc_gpencil_common_lib_glsl,
|
|
datatoc_gpencil_frag_glsl,
|
|
NULL,
|
|
},
|
|
.defs =
|
|
(const char *[]){
|
|
"#define GP_MATERIAL_BUFFER_LEN " STRINGIFY(GP_MATERIAL_BUFFER_LEN) "\n",
|
|
"#define GPENCIL_LIGHT_BUFFER_LEN " STRINGIFY(GPENCIL_LIGHT_BUFFER_LEN) "\n",
|
|
"#define UNIFORM_RESOURCE_ID\n",
|
|
NULL,
|
|
},
|
|
});
|
|
}
|
|
return g_shaders.gpencil_sh;
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_layer_blend_get(void)
|
|
{
|
|
if (!g_shaders.layer_blend_sh) {
|
|
g_shaders.layer_blend_sh = GPU_shader_create_from_arrays({
|
|
.vert =
|
|
(const char *[]){
|
|
datatoc_common_fullscreen_vert_glsl,
|
|
NULL,
|
|
},
|
|
.frag =
|
|
(const char *[]){
|
|
datatoc_gpencil_common_lib_glsl,
|
|
datatoc_gpencil_layer_blend_frag_glsl,
|
|
NULL,
|
|
},
|
|
});
|
|
}
|
|
return g_shaders.layer_blend_sh;
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_mask_invert_get(void)
|
|
{
|
|
if (!g_shaders.mask_invert_sh) {
|
|
g_shaders.mask_invert_sh = DRW_shader_create_fullscreen(datatoc_gpencil_mask_invert_frag_glsl,
|
|
NULL);
|
|
}
|
|
return g_shaders.mask_invert_sh;
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_depth_merge_get(void)
|
|
{
|
|
if (!g_shaders.depth_merge_sh) {
|
|
g_shaders.depth_merge_sh = GPU_shader_create_from_arrays({
|
|
.vert =
|
|
(const char *[]){
|
|
datatoc_common_view_lib_glsl,
|
|
datatoc_gpencil_depth_merge_vert_glsl,
|
|
NULL,
|
|
},
|
|
.frag =
|
|
(const char *[]){
|
|
datatoc_gpencil_depth_merge_frag_glsl,
|
|
NULL,
|
|
},
|
|
});
|
|
}
|
|
return g_shaders.depth_merge_sh;
|
|
}
|
|
|
|
/* ------- FX Shaders --------- */
|
|
|
|
GPUShader *GPENCIL_shader_fx_blur_get(void)
|
|
{
|
|
if (!g_shaders.fx_blur_sh) {
|
|
g_shaders.fx_blur_sh = DRW_shader_create_fullscreen(datatoc_gpencil_vfx_frag_glsl,
|
|
"#define BLUR\n");
|
|
}
|
|
return g_shaders.fx_blur_sh;
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_fx_colorize_get(void)
|
|
{
|
|
if (!g_shaders.fx_colorize_sh) {
|
|
g_shaders.fx_colorize_sh = DRW_shader_create_fullscreen(datatoc_gpencil_vfx_frag_glsl,
|
|
"#define COLORIZE\n");
|
|
}
|
|
return g_shaders.fx_colorize_sh;
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_fx_composite_get(void)
|
|
{
|
|
if (!g_shaders.fx_composite_sh) {
|
|
g_shaders.fx_composite_sh = DRW_shader_create_fullscreen(datatoc_gpencil_vfx_frag_glsl,
|
|
"#define COMPOSITE\n");
|
|
}
|
|
return g_shaders.fx_composite_sh;
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_fx_glow_get(void)
|
|
{
|
|
if (!g_shaders.fx_glow_sh) {
|
|
g_shaders.fx_glow_sh = GPU_shader_create_from_arrays({
|
|
.vert =
|
|
(const char *[]){
|
|
datatoc_common_fullscreen_vert_glsl,
|
|
NULL,
|
|
},
|
|
.frag =
|
|
(const char *[]){
|
|
datatoc_gpencil_common_lib_glsl,
|
|
datatoc_gpencil_vfx_frag_glsl,
|
|
NULL,
|
|
},
|
|
.defs =
|
|
(const char *[]){
|
|
"#define GLOW\n",
|
|
NULL,
|
|
},
|
|
});
|
|
}
|
|
return g_shaders.fx_glow_sh;
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_fx_pixelize_get(void)
|
|
{
|
|
if (!g_shaders.fx_pixel_sh) {
|
|
g_shaders.fx_pixel_sh = DRW_shader_create_fullscreen(datatoc_gpencil_vfx_frag_glsl,
|
|
"#define PIXELIZE\n");
|
|
}
|
|
return g_shaders.fx_pixel_sh;
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_fx_rim_get(void)
|
|
{
|
|
if (!g_shaders.fx_rim_sh) {
|
|
g_shaders.fx_rim_sh = GPU_shader_create_from_arrays({
|
|
.vert =
|
|
(const char *[]){
|
|
datatoc_common_fullscreen_vert_glsl,
|
|
NULL,
|
|
},
|
|
.frag =
|
|
(const char *[]){
|
|
datatoc_gpencil_common_lib_glsl,
|
|
datatoc_gpencil_vfx_frag_glsl,
|
|
NULL,
|
|
},
|
|
.defs =
|
|
(const char *[]){
|
|
"#define RIM\n",
|
|
NULL,
|
|
},
|
|
});
|
|
}
|
|
return g_shaders.fx_rim_sh;
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_fx_shadow_get(void)
|
|
{
|
|
if (!g_shaders.fx_shadow_sh) {
|
|
g_shaders.fx_shadow_sh = DRW_shader_create_fullscreen(datatoc_gpencil_vfx_frag_glsl,
|
|
"#define SHADOW\n");
|
|
}
|
|
return g_shaders.fx_shadow_sh;
|
|
}
|
|
|
|
GPUShader *GPENCIL_shader_fx_transform_get(void)
|
|
{
|
|
if (!g_shaders.fx_transform_sh) {
|
|
g_shaders.fx_transform_sh = DRW_shader_create_fullscreen(datatoc_gpencil_vfx_frag_glsl,
|
|
"#define TRANSFORM\n");
|
|
}
|
|
return g_shaders.fx_transform_sh;
|
|
}
|