diff options
Diffstat (limited to 'source/blender/draw/engines/overlay/shaders')
52 files changed, 928 insertions, 151 deletions
diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_armature_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_armature_info.hh index 9f2acceed97..caa18ece122 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_armature_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_armature_info.hh @@ -69,6 +69,11 @@ GPU_SHADER_INTERFACE_INFO(overlay_armature_shape_outline_iface, "geom_in") .smooth(Type::VEC4, "vColSize") .flat(Type::INT, "inverted"); +GPU_SHADER_INTERFACE_INFO(overlay_armature_shape_outline_no_geom_iface, "") + .flat(Type::VEC4, "finalColor") + .flat(Type::VEC2, "edgeStart") + .no_perspective(Type::VEC2, "edgePos"); + GPU_SHADER_CREATE_INFO(overlay_armature_shape_outline) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") @@ -84,10 +89,26 @@ GPU_SHADER_CREATE_INFO(overlay_armature_shape_outline) .fragment_source("overlay_armature_wire_frag.glsl") .additional_info("overlay_frag_output", "overlay_armature_common", "draw_globals"); +GPU_SHADER_CREATE_INFO(overlay_armature_shape_outline_no_geom) + // .do_static_compilation(true) /* TODO fix on GL */ + .vertex_in(0, Type::VEC3, "pos") + .vertex_in(1, Type::VEC3, "snor") + /* Per instance. */ + .vertex_in(2, Type::VEC4, "color") + .vertex_in(3, Type::MAT4, "inst_obmat") + .vertex_out(overlay_armature_shape_outline_no_geom_iface) + .vertex_source("overlay_armature_shape_outline_vert_no_geom.glsl") + .fragment_source("overlay_armature_wire_frag.glsl") + .additional_info("overlay_frag_output", "overlay_armature_common", "draw_globals"); + GPU_SHADER_CREATE_INFO(overlay_armature_shape_outline_clipped) .do_static_compilation(true) .additional_info("overlay_armature_shape_outline", "drw_clipped"); +GPU_SHADER_CREATE_INFO(overlay_armature_shape_outline_clipped_no_geom) + // .do_static_compilation(true) /* TODO fix on GL */ + .additional_info("overlay_armature_shape_outline_no_geom", "drw_clipped"); + GPU_SHADER_INTERFACE_INFO(overlay_armature_shape_solid_iface, "") .smooth(Type::VEC4, "finalColor") .flat(Type::INT, "inverted"); diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_background_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_background_info.hh index 88a012c35c9..8bc15400248 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_background_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_background_info.hh @@ -15,7 +15,7 @@ GPU_SHADER_CREATE_INFO(overlay_background) GPU_SHADER_CREATE_INFO(overlay_clipbound) .do_static_compilation(true) - .push_constant(Type::VEC4, "color") + .push_constant(Type::VEC4, "ucolor") .push_constant(Type::VEC3, "boundbox", 8) .vertex_source("overlay_clipbound_vert.glsl") .fragment_out(0, Type::VEC4, "fragColor") diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_edit_mode_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_edit_mode_info.hh index 9396a6d3f2f..40b7249a997 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_edit_mode_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_edit_mode_info.hh @@ -22,6 +22,17 @@ GPU_SHADER_CREATE_INFO(overlay_edit_mesh_common) .vertex_source("overlay_edit_mesh_vert.glsl") .additional_info("draw_modelmat", "draw_globals"); +GPU_SHADER_CREATE_INFO(overlay_edit_mesh_common_no_geom) + .define("blender_srgb_to_framebuffer_space(a)", "a") + .sampler(0, ImageType::DEPTH_2D, "depthTex") + .fragment_out(0, Type::VEC4, "fragColor") + .push_constant(Type::BOOL, "selectFaces") + .push_constant(Type::BOOL, "selectEdges") + .push_constant(Type::FLOAT, "alpha") + .push_constant(Type::IVEC4, "dataMask") + .vertex_source("overlay_edit_mesh_vert_no_geom.glsl") + .additional_info("draw_modelmat", "draw_globals"); + GPU_SHADER_INTERFACE_INFO(overlay_edit_mesh_vert_iface, "") .smooth(Type::VEC4, "finalColor") .smooth(Type::FLOAT, "vertexCrease"); @@ -61,11 +72,28 @@ GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge) .fragment_source("overlay_edit_mesh_frag.glsl") .additional_info("overlay_edit_mesh_common"); +/* The Non-Geometry shader variant passes directly to fragment. */ +GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge_no_geom) + // .do_static_compilation(true) /* TODO fix on GL */ + .define("EDGE") + .vertex_in(0, Type::VEC3, "pos") + .vertex_in(1, Type::UCHAR4, "data") + .vertex_in(2, Type::VEC3_101010I2, "vnor") + .push_constant(Type::BOOL, "do_smooth_wire") + .vertex_out(overlay_edit_mesh_edge_geom_iface) + .fragment_source("overlay_edit_mesh_frag.glsl") + .additional_info("overlay_edit_mesh_common_no_geom"); + GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge_flat) .do_static_compilation(true) .define("FLAT") .additional_info("overlay_edit_mesh_edge"); +GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge_flat_no_geom) + // .do_static_compilation(true) /* TODO fix on GL */ + .define("FLAT") + .additional_info("overlay_edit_mesh_edge_no_geom"); + GPU_SHADER_CREATE_INFO(overlay_edit_mesh_face) .do_static_compilation(true) .define("FACE") @@ -136,10 +164,18 @@ GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge_clipped) .do_static_compilation(true) .additional_info("overlay_edit_mesh_edge", "drw_clipped"); +GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge_clipped_no_geom) + // .do_static_compilation(true) /* TODO fix on GL */ + .additional_info("overlay_edit_mesh_edge_no_geom", "drw_clipped"); + GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge_flat_clipped) .do_static_compilation(true) .additional_info("overlay_edit_mesh_edge_flat", "drw_clipped"); +GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge_flat_clipped_no_geom) + // .do_static_compilation(true) /* TODO fix on GL */ + .additional_info("overlay_edit_mesh_edge_flat_no_geom", "drw_clipped"); + GPU_SHADER_CREATE_INFO(overlay_edit_mesh_face_clipped) .do_static_compilation(true) .additional_info("overlay_edit_mesh_face", "drw_clipped"); @@ -242,7 +278,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_verts) GPU_SHADER_CREATE_INFO(overlay_edit_uv_tiled_image_borders) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") - .push_constant(Type::VEC4, "color") + .push_constant(Type::VEC4, "ucolor") .fragment_out(0, Type::VEC4, "fragColor") .vertex_source("overlay_edit_uv_tiled_image_borders_vert.glsl") .fragment_source("overlay_uniform_color_frag.glsl") @@ -258,7 +294,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_stencil_image) .sampler(0, ImageType::FLOAT_2D, "imgTexture") .push_constant(Type::BOOL, "imgPremultiplied") .push_constant(Type::BOOL, "imgAlphaBlend") - .push_constant(Type::VEC4, "color") + .push_constant(Type::VEC4, "ucolor") .fragment_out(0, Type::VEC4, "fragColor") .fragment_source("overlay_image_frag.glsl") .additional_info("draw_mesh"); @@ -326,10 +362,29 @@ GPU_SHADER_CREATE_INFO(overlay_edit_curve_handle) .fragment_source("overlay_varying_color.glsl") .additional_info("draw_mesh", "draw_globals"); +GPU_SHADER_CREATE_INFO(overlay_edit_curve_handle_no_geom) + // .do_static_compilation(true) /* TODO fix on GL */ + .typedef_source("overlay_shader_shared.h") + /* NOTE: Color already in Linear space. Which is what we want. */ + .define("srgbTarget", "false") + .vertex_in(0, Type::VEC3, "pos") + .vertex_in(1, Type::INT, "data") + .vertex_out(overlay_edit_curve_handle_iface) + .push_constant(Type::BOOL, "showCurveHandles") + .push_constant(Type::INT, "curveHandleDisplay") + .fragment_out(0, Type::VEC4, "fragColor") + .vertex_source("overlay_edit_curve_handle_vert_no_geom.glsl") + .fragment_source("overlay_varying_color.glsl") + .additional_info("draw_mesh", "draw_globals"); + GPU_SHADER_CREATE_INFO(overlay_edit_curve_handle_clipped) .do_static_compilation(true) .additional_info("overlay_edit_curve_handle", "drw_clipped"); +GPU_SHADER_CREATE_INFO(overlay_edit_curve_handle_clipped_no_geom) + // .do_static_compilation(true) /* TODO fix on GL */ + .additional_info("overlay_edit_curve_handle_no_geom", "drw_clipped"); + GPU_SHADER_CREATE_INFO(overlay_edit_curve_point) .do_static_compilation(true) .typedef_source("overlay_shader_shared.h") @@ -526,14 +581,26 @@ GPU_SHADER_CREATE_INFO(overlay_depth_only_clipped) GPU_SHADER_CREATE_INFO(overlay_uniform_color) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") - .push_constant(Type::VEC4, "color") + .push_constant(Type::VEC4, "ucolor") .fragment_out(0, Type::VEC4, "fragColor") .vertex_source("overlay_depth_only_vert.glsl") .fragment_source("overlay_uniform_color_frag.glsl") .additional_info("draw_mesh"); +GPU_SHADER_CREATE_INFO(overlay_uniform_color_pointcloud) + .do_static_compilation(true) + .push_constant(Type::VEC4, "ucolor") + .fragment_out(0, Type::VEC4, "fragColor") + .vertex_source("overlay_pointcloud_only_vert.glsl") + .fragment_source("overlay_uniform_color_frag.glsl") + .additional_info("draw_pointcloud"); + GPU_SHADER_CREATE_INFO(overlay_uniform_color_clipped) .do_static_compilation(true) .additional_info("overlay_depth_only", "drw_clipped"); +GPU_SHADER_CREATE_INFO(overlay_uniform_color_pointcloud_clipped) + .do_static_compilation(true) + .additional_info("overlay_uniform_color_pointcloud", "drw_clipped"); + /** \} */ diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_extra_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_extra_info.hh index 5b50bbcaa55..4874f251d67 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_extra_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_extra_info.hh @@ -110,12 +110,12 @@ GPU_SHADER_CREATE_INFO(overlay_extra_wire) GPU_SHADER_CREATE_INFO(overlay_extra_wire_select) .do_static_compilation(true) .define("SELECT_EDGES") - .additional_info("overlay_extra_wire", "drw_clipped"); + .additional_info("overlay_extra_wire"); GPU_SHADER_CREATE_INFO(overlay_extra_wire_object) .do_static_compilation(true) .define("OBJECT_WIRE") - .additional_info("overlay_extra_wire", "drw_clipped"); + .additional_info("overlay_extra_wire"); GPU_SHADER_CREATE_INFO(overlay_extra_wire_select_clipped) .do_static_compilation(true) @@ -145,7 +145,7 @@ GPU_SHADER_CREATE_INFO(overlay_extra_point) /* TODO(fclem): Move the vertex shader to Overlay engine and remove this bypass. */ .define("blender_srgb_to_framebuffer_space(a)", "a") .vertex_in(0, Type::VEC3, "pos") - .push_constant(Type::VEC4, "color") + .push_constant(Type::VEC4, "ucolor") .vertex_out(overlay_extra_point_iface) .fragment_out(0, Type::VEC4, "fragColor") .vertex_source("overlay_extra_point_vert.glsl") @@ -161,7 +161,7 @@ GPU_SHADER_INTERFACE_INFO(overlay_extra_loose_point_iface, "").smooth(Type::VEC4 GPU_SHADER_CREATE_INFO(overlay_extra_loose_point) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") - .push_constant(Type::VEC4, "color") + .push_constant(Type::VEC4, "ucolor") .vertex_out(overlay_extra_loose_point_iface) .fragment_out(0, Type::VEC4, "fragColor") .fragment_out(1, Type::VEC4, "lineOutput") @@ -183,6 +183,9 @@ GPU_SHADER_INTERFACE_INFO(overlay_motion_path_line_iface, "interp") .flat(Type::VEC2, "ss_pos") .smooth(Type::VEC4, "color"); +GPU_SHADER_INTERFACE_INFO(overlay_motion_path_line_no_geom_iface, "interp") + .smooth(Type::VEC4, "color"); + GPU_SHADER_CREATE_INFO(overlay_motion_path_line) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") @@ -199,10 +202,27 @@ GPU_SHADER_CREATE_INFO(overlay_motion_path_line) .fragment_source("overlay_motion_path_line_frag.glsl") .additional_info("draw_view", "draw_globals"); +GPU_SHADER_CREATE_INFO(overlay_motion_path_line_no_geom) + // .do_static_compilation(true) /* TODO fix on GL */ + .vertex_in(0, Type::VEC3, "pos") + .push_constant(Type::IVEC4, "mpathLineSettings") + .push_constant(Type::BOOL, "selected") + .push_constant(Type::VEC3, "customColor") + .push_constant(Type::INT, "lineThickness") /* In pixels. */ + .vertex_out(overlay_motion_path_line_no_geom_iface) + .fragment_out(0, Type::VEC4, "fragColor") + .vertex_source("overlay_motion_path_line_vert_no_geom.glsl") + .fragment_source("overlay_motion_path_line_frag.glsl") + .additional_info("draw_view", "draw_globals"); + GPU_SHADER_CREATE_INFO(overlay_motion_path_line_clipped) .do_static_compilation(true) .additional_info("overlay_motion_path_line", "drw_clipped"); +GPU_SHADER_CREATE_INFO(overlay_motion_path_line_clipped_no_geom) + // .do_static_compilation(true) /* TODO fix on GL */ + .additional_info("overlay_motion_path_line_no_geom", "drw_clipped"); + GPU_SHADER_INTERFACE_INFO(overlay_motion_path_point_iface, "").flat(Type::VEC4, "finalColor"); GPU_SHADER_CREATE_INFO(overlay_motion_path_point) @@ -237,7 +257,7 @@ GPU_SHADER_CREATE_INFO(overlay_image) .push_constant(Type::BOOL, "isCameraBackground") .push_constant(Type::BOOL, "imgPremultiplied") .push_constant(Type::BOOL, "imgAlphaBlend") - .push_constant(Type::VEC4, "color") + .push_constant(Type::VEC4, "ucolor") .vertex_in(0, Type::VEC3, "pos") .vertex_out(overlay_image_iface) .sampler(0, ImageType::FLOAT_2D, "imgTexture") @@ -284,7 +304,7 @@ GPU_SHADER_INTERFACE_INFO(overlay_particle_iface, "").flat(Type::VEC4, "finalCol GPU_SHADER_CREATE_INFO(overlay_particle) .sampler(0, ImageType::FLOAT_1D, "weightTex") - .push_constant(Type::VEC4, "color") /* Draw-size packed in alpha. */ + .push_constant(Type::VEC4, "ucolor") /* Draw-size packed in alpha. */ .vertex_in(0, Type::VEC3, "part_pos") .vertex_in(1, Type::VEC4, "part_rot") .vertex_in(2, Type::FLOAT, "part_val") diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_grid_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_grid_info.hh index a8f1281d53a..70175b7072f 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_grid_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_grid_info.hh @@ -32,7 +32,7 @@ GPU_SHADER_CREATE_INFO(overlay_grid_background) GPU_SHADER_CREATE_INFO(overlay_grid_image) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") - .push_constant(Type::VEC4, "color") + .push_constant(Type::VEC4, "ucolor") .fragment_out(0, Type::VEC4, "fragColor") .vertex_source("overlay_edit_uv_tiled_image_borders_vert.glsl") .fragment_source("overlay_uniform_color_frag.glsl") diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_outline_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_outline_info.hh index 288fb3b3cbd..abf9e873b29 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_outline_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_outline_info.hh @@ -14,7 +14,7 @@ GPU_SHADER_CREATE_INFO(overlay_outline_prepass) /* Using uint because 16bit uint can contain more ids than int. */ .fragment_out(0, Type::UINT, "out_object_id") .fragment_source("overlay_outline_prepass_frag.glsl") - .additional_info("draw_resource_handle"); + .additional_info("draw_resource_handle", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_outline_prepass_mesh) .do_static_compilation(true) @@ -72,7 +72,7 @@ GPU_SHADER_CREATE_INFO(overlay_outline_prepass_gpencil) /* Using uint because 16bit uint can contain more ids than int. */ .fragment_out(0, Type::UINT, "out_object_id") .fragment_source("overlay_outline_prepass_gpencil_frag.glsl") - .additional_info("draw_gpencil", "draw_resource_handle"); + .additional_info("draw_gpencil", "draw_resource_handle", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_outline_prepass_gpencil_clipped) .do_static_compilation(true) diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_paint_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_paint_info.hh index 3083d5a463b..08b421de3e6 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_paint_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_paint_info.hh @@ -12,7 +12,7 @@ GPU_SHADER_CREATE_INFO(overlay_paint_face) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") .vertex_in(1, Type::VEC4, "nor") /* Select flag on the 4th component. */ - .push_constant(Type::VEC4, "color") + .push_constant(Type::VEC4, "ucolor") .fragment_out(0, Type::VEC4, "fragColor") .vertex_source("overlay_paint_face_vert.glsl") .fragment_source("overlay_uniform_color_frag.glsl") diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_viewer_attribute_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_viewer_attribute_info.hh new file mode 100644 index 00000000000..6a0bd03f030 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_viewer_attribute_info.hh @@ -0,0 +1,66 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_INTERFACE_INFO(overlay_viewer_attribute_iface, "").smooth(Type::VEC4, "finalColor"); + +GPU_SHADER_CREATE_INFO(overlay_viewer_attribute_common).push_constant(Type::FLOAT, "opacity"); + +GPU_SHADER_CREATE_INFO(overlay_viewer_attribute_mesh) + .do_static_compilation(true) + .vertex_source("overlay_viewer_attribute_mesh_vert.glsl") + .fragment_source("overlay_viewer_attribute_frag.glsl") + .fragment_out(0, Type::VEC4, "out_color") + .fragment_out(1, Type::VEC4, "lineOutput") + .vertex_in(0, Type::VEC3, "pos") + .vertex_in(1, Type::VEC4, "attribute_value") + .vertex_out(overlay_viewer_attribute_iface) + .additional_info("overlay_viewer_attribute_common", "draw_mesh"); + +GPU_SHADER_CREATE_INFO(overlay_viewer_attribute_mesh_clipped) + .do_static_compilation(true) + .additional_info("overlay_viewer_attribute_mesh", "drw_clipped"); + +GPU_SHADER_CREATE_INFO(overlay_viewer_attribute_pointcloud) + .do_static_compilation(true) + .vertex_source("overlay_viewer_attribute_pointcloud_vert.glsl") + .fragment_source("overlay_viewer_attribute_frag.glsl") + .fragment_out(0, Type::VEC4, "out_color") + .fragment_out(1, Type::VEC4, "lineOutput") + .sampler(3, ImageType::FLOAT_BUFFER, "attribute_tx") + .vertex_out(overlay_viewer_attribute_iface) + .additional_info("overlay_viewer_attribute_common", "draw_pointcloud"); + +GPU_SHADER_CREATE_INFO(overlay_viewer_attribute_pointcloud_clipped) + .do_static_compilation(true) + .additional_info("overlay_viewer_attribute_pointcloud", "drw_clipped"); + +GPU_SHADER_CREATE_INFO(overlay_viewer_attribute_curve) + .do_static_compilation(true) + .vertex_source("overlay_viewer_attribute_curve_vert.glsl") + .fragment_source("overlay_viewer_attribute_frag.glsl") + .fragment_out(0, Type::VEC4, "out_color") + .fragment_out(1, Type::VEC4, "lineOutput") + .vertex_in(0, Type::VEC3, "pos") + .vertex_in(1, Type::VEC4, "attribute_value") + .vertex_out(overlay_viewer_attribute_iface) + .additional_info("overlay_viewer_attribute_common", "draw_modelmat", "draw_resource_id"); + +GPU_SHADER_CREATE_INFO(overlay_viewer_attribute_curve_clipped) + .do_static_compilation(true) + .additional_info("overlay_viewer_attribute_curve", "drw_clipped"); + +GPU_SHADER_CREATE_INFO(overlay_viewer_attribute_curves) + .do_static_compilation(true) + .vertex_source("overlay_viewer_attribute_curves_vert.glsl") + .fragment_source("overlay_viewer_attribute_frag.glsl") + .fragment_out(0, Type::VEC4, "out_color") + .fragment_out(1, Type::VEC4, "lineOutput") + .sampler(0, ImageType::FLOAT_BUFFER, "color_tx") + .push_constant(Type::BOOL, "is_point_domain") + .vertex_out(overlay_viewer_attribute_iface) + .additional_info("overlay_viewer_attribute_common", "draw_hair"); + +GPU_SHADER_CREATE_INFO(overlay_viewer_attribute_curves_clipped) + .do_static_compilation(true) + .additional_info("overlay_viewer_attribute_curves", "drw_clipped"); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl index ca5a6aff2ca..c13698728ef 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl @@ -137,7 +137,7 @@ void main() vec2 ofs_dir = compute_dir(ss0, ss1, ss2); /* Offset away from the center to avoid overlap with solid shape. */ - gl_Position.xy += ofs_dir * drw_view.viewport_size_inverse * gl_Position.w; + gl_Position.xy += ofs_dir * sizeViewportInv * gl_Position.w; edgeStart = edgePos = proj(gl_Position); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl index 4d21ffd96b5..17aed643224 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl @@ -38,5 +38,5 @@ void main() view_clipping_distances(sp); vec4 pos_4d = vec4(sp, 1.0); - gl_Position = drw_view.persmat * pos_4d; + gl_Position = drw_view.winmat * (drw_view.viewmat * pos_4d); } diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_geom.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_geom.glsl index b485b0a7807..65a2fcc1977 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_geom.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_geom.glsl @@ -56,7 +56,7 @@ void main(void) gl_Position = geom_in[1].pPos; /* Offset away from the center to avoid overlap with solid shape. */ - gl_Position.xy += (edge_dir - perp) * drw_view.viewport_size_inverse * gl_Position.w; + gl_Position.xy += (edge_dir - perp) * sizeViewportInv * gl_Position.w; /* Improve AA bleeding inside bone silhouette. */ gl_Position.z -= (is_persp) ? 1e-4 : 1e-6; edgeStart = edgePos = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport; @@ -65,7 +65,7 @@ void main(void) gl_Position = geom_in[2].pPos; /* Offset away from the center to avoid overlap with solid shape. */ - gl_Position.xy += (edge_dir + perp) * drw_view.viewport_size_inverse * gl_Position.w; + gl_Position.xy += (edge_dir + perp) * sizeViewportInv * gl_Position.w; /* Improve AA bleeding inside bone silhouette. */ gl_Position.z -= (is_persp) ? 1e-4 : 1e-6; edgeStart = edgePos = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl index 91eb6265192..bb45f213046 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl @@ -25,8 +25,8 @@ void main() * doing it per instance on CPU and sending it on via instance attribute. */ mat3 normal_mat = transpose(inverse(mat3(model_mat))); /* TODO: FIX: there is still a problem with this vector - * when the bone is scaled or in persp mode. But it's - * barely visible at the outline corners. */ + * when the bone is scaled or in perspective mode. + * But it's barely visible at the outline corners. */ geom_in.ssNor = normalize(normal_world_to_view(normal_mat * snor).xy); geom_in.ssPos = proj(geom_in.pPos); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert_no_geom.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert_no_geom.glsl new file mode 100644 index 00000000000..57c0ecb0b9b --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert_no_geom.glsl @@ -0,0 +1,178 @@ + +#pragma USE_SSBO_VERTEX_FETCH(LineList, 2) +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +#define DISCARD_VERTEX \ + gl_Position = finalColor = vec4(0.0); \ + edgeStart = edgePos = vec2(0.0); \ + return; + +/* Project to screen space. */ +vec2 proj(vec4 pos) +{ + return (0.5 * (pos.xy / pos.w) + 0.5) * sizeViewport.xy; +} + +void do_vertex_shader(mat4 in_inst_obmat, + vec3 in_pos, + vec3 in_snor, + out vec4 out_pPos, + out vec3 out_vPos, + out vec2 out_ssPos, + out vec2 out_ssNor, + out vec4 out_vColSize, + out int out_inverted, + out vec4 out_wpos) +{ + vec4 bone_color, state_color; + mat4 model_mat = extract_matrix_packed_data(in_inst_obmat, state_color, bone_color); + + vec4 worldPosition = model_mat * vec4(in_pos, 1.0); + vec4 viewpos = ViewMatrix * worldPosition; + out_wpos = worldPosition; + out_vPos = viewpos.xyz; + out_pPos = ProjectionMatrix * viewpos; + + out_inverted = int(dot(cross(model_mat[0].xyz, model_mat[1].xyz), model_mat[2].xyz) < 0.0); + + /* This is slow and run per vertex, but it's still faster than + * doing it per instance on CPU and sending it on via instance attribute. */ + mat3 normal_mat = transpose(inverse(mat3(model_mat))); + /* TODO FIX: there is still a problem with this vector + * when the bone is scaled or in persp mode. But it's + * barely visible at the outline corners. */ + out_ssNor = normalize(normal_world_to_view(normal_mat * in_snor).xy); + + out_ssPos = proj(out_pPos); + + out_vColSize = bone_color; +} + +void main() +{ + /* Outputs a singular vertex as part of a LineList primitive, however, requires access to + * neighboring 4 vertices. */ + /* Fetch verts from input type lines adjacency. */ + int line_prim_id = (gl_VertexID / 2); + int line_vertex_id = gl_VertexID % 2; + int base_vertex_id = line_prim_id * 2; + + /* IF Input Primitive Type == Lines_Adjacency, then indices are accessed as per GL specification: + * i.e. 4 indices per unique prim (Provoking vert 4i-2) + * + * IF Input Primitive Type == LineStrip_Adjacency, then indices are accessed using: + * - 2 indices per unique prim, plus 1 index at each end, such that the strided + * - 4-index block can be walked. */ + vec3 in_pos[4]; + in_pos[0] = vertex_fetch_attribute_raw(vertex_id_from_index_id(4 * line_prim_id), pos, vec3); + in_pos[1] = vertex_fetch_attribute_raw(vertex_id_from_index_id(4 * line_prim_id + 1), pos, vec3); + in_pos[2] = vertex_fetch_attribute_raw(vertex_id_from_index_id(4 * line_prim_id + 2), pos, vec3); + in_pos[3] = vertex_fetch_attribute_raw(vertex_id_from_index_id(4 * line_prim_id + 3), pos, vec3); + + vec3 in_snor[4]; + in_snor[0] = vertex_fetch_attribute_raw(vertex_id_from_index_id(4 * line_prim_id), snor, vec3); + in_snor[1] = vertex_fetch_attribute_raw( + vertex_id_from_index_id(4 * line_prim_id + 1), snor, vec3); + in_snor[2] = vertex_fetch_attribute_raw( + vertex_id_from_index_id(4 * line_prim_id + 2), snor, vec3); + in_snor[3] = vertex_fetch_attribute_raw( + vertex_id_from_index_id(4 * line_prim_id + 3), snor, vec3); + + mat4 in_inst_obmat = vertex_fetch_attribute(gl_VertexID, inst_obmat, mat4); + + /* Run original GL vertex shader implementation per vertex in adjacency list. */ + vec4 pPos[4]; + vec3 vPos[4]; + vec2 ssPos[4]; + vec2 ssNor[4]; + vec4 vColSize[4]; + int inverted[4]; + vec4 wPos[4]; + + for (int v = 0; v < 4; v++) { + do_vertex_shader(in_inst_obmat, + in_pos[v], + in_snor[v], + pPos[v], + vPos[v], + ssPos[v], + ssNor[v], + vColSize[v], + inverted[v], + wPos[v]); + } + + /* Geometry Shader equivalent to calculate vertex output position. */ + finalColor = vec4(vColSize[0].rgb, 1.0); + + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + + vec3 view_vec = (is_persp) ? normalize(vPos[1]) : vec3(0.0, 0.0, -1.0); + vec3 v10 = vPos[0] - vPos[1]; + vec3 v12 = vPos[2] - vPos[1]; + vec3 v13 = vPos[3] - vPos[1]; + + vec3 n0 = cross(v12, v10); + vec3 n3 = cross(v13, v12); + + float fac0 = dot(view_vec, n0); + float fac3 = dot(view_vec, n3); + + /* If one of the face is perpendicular to the view, + * consider it and outline edge. */ + if (abs(fac0) > 1e-5 && abs(fac3) > 1e-5) { + /* If both adjacent verts are facing the camera the same way, + * then it isn't an outline edge. */ + if (sign(fac0) == sign(fac3)) { + DISCARD_VERTEX + } + } + + n0 = (inverted[0] == 1) ? -n0 : n0; + /* Don't outline if concave edge. */ + if (dot(n0, v13) > 0.0001) { + DISCARD_VERTEX + } + + vec2 perp = normalize(ssPos[2] - ssPos[1]); + vec2 edge_dir = vec2(-perp.y, perp.x); + + vec2 hidden_point; + /* Take the farthest point to compute edge direction + * (avoid problems with point behind near plane). + * If the chosen point is parallel to the edge in screen space, + * choose the other point anyway. + * This fixes some issue with cubes in orthographic views.*/ + if (vPos[0].z < vPos[3].z) { + hidden_point = (abs(fac0) > 1e-5) ? ssPos[0] : ssPos[3]; + } + else { + hidden_point = (abs(fac3) > 1e-5) ? ssPos[3] : ssPos[0]; + } + vec2 hidden_dir = normalize(hidden_point - ssPos[1]); + + float fac = dot(-hidden_dir, edge_dir); + edge_dir *= (fac < 0.0) ? -1.0 : 1.0; + + /* Output corresponding value based on which vertex this corresponds to in the + * original input primitive. */ + if (line_vertex_id == 0) { + gl_Position = pPos[1]; + /* Offset away from the center to avoid overlap with solid shape. */ + gl_Position.xy += (edge_dir - perp) * sizeViewportInv * gl_Position.w; + /* Improve AA bleeding inside bone silhouette. */ + gl_Position.z -= (is_persp) ? 1e-4 : 1e-6; + edgeStart = edgePos = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; + view_clipping_distances(wPos[1].xyz); + } + else { + gl_Position = pPos[2]; + /* Offset away from the center to avoid overlap with solid shape. */ + gl_Position.xy += (edge_dir + perp) * sizeViewportInv * gl_Position.w; + /* Improve AA bleeding inside bone silhouette. */ + gl_Position.z -= (is_persp) ? 1e-4 : 1e-6; + edgeStart = edgePos = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; + view_clipping_distances(wPos[2].xyz); + } +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl index 68f7e75673f..2b5605c85d3 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl @@ -25,7 +25,7 @@ void main() finalColor.a = 1.0; vec4 world_pos = model_mat * vec4(pos, 1.0); - gl_Position = drw_view.persmat * world_pos; + gl_Position = drw_view.winmat * (drw_view.viewmat * world_pos); view_clipping_distances(world_pos.xyz); } diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl index 4d79fab718f..ef9a0b7bdd6 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl @@ -63,7 +63,7 @@ void main() /* Offset away from the center to avoid overlap with solid shape. */ vec2 ofs_dir = normalize(proj(gl_Position) - proj(center)); - gl_Position.xy += ofs_dir * drw_view.viewport_size_inverse * gl_Position.w; + gl_Position.xy += ofs_dir * sizeViewportInv * gl_Position.w; edgeStart = edgePos = proj(gl_Position); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_vert.glsl index e7917a46312..c10a221ef08 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_vert.glsl @@ -64,7 +64,7 @@ void main() if (finalInnerColor.a > 0.0) { float stick_size = sizePixel * 5.0; gl_Position = (is_head) ? p0 : p1; - gl_Position.xy += stick_size * (vpos * drw_view.viewport_size_inverse); + gl_Position.xy += stick_size * (vpos * sizeViewportInv); gl_Position.z += (is_bone) ? 0.0 : 1e-6; /* Avoid Z fighting of head/tails. */ view_clipping_distances((is_head ? boneStart_4d : boneEnd_4d).xyz); } diff --git a/source/blender/draw/engines/overlay/shaders/overlay_background_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_background_frag.glsl index b25dcae9fca..960986bebd5 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_background_frag.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_background_frag.glsl @@ -18,8 +18,8 @@ float dither(void) void main() { /* The blend equation is: - * resutl.rgb = SRC.rgb * (1 - DST.a) + DST.rgb * (SRC.a) - * result.a = SRC.a * 0 + DST.a * SRC.a + * `result.rgb = SRC.rgb * (1 - DST.a) + DST.rgb * (SRC.a)` + * `result.a = SRC.a * 0 + DST.a * SRC.a` * This removes the alpha channel and put the background behind reference images * while masking the reference images by the render alpha. */ diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_geom.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_geom.glsl index 7d92baea595..c1726f00d66 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_geom.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_geom.glsl @@ -83,7 +83,7 @@ void main() vec4(inner_color.rgb, 0.0); vec2 v1_2 = (v2.xy / v2.w - v1.xy / v1.w); - vec2 offset = sizeEdge * 4.0 * drw_view.viewport_size_inverse; /* 4.0 is eyeballed */ + vec2 offset = sizeEdge * 4.0 * sizeViewportInv; /* 4.0 is eyeballed */ if (abs(v1_2.x * sizeViewport.x) < abs(v1_2.y * sizeViewport.y)) { offset.y = 0.0; diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert_no_geom.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert_no_geom.glsl new file mode 100644 index 00000000000..8b4b7afb996 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert_no_geom.glsl @@ -0,0 +1,16 @@ +/* TODO(Metal): Implement correct SSBO implementation for geom shader workaround. + * Currently included as placeholder to unblock failing compilation in Metal. */ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + vert.flag = data; + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_geom.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_geom.glsl index 82f957b2071..257058d7029 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_geom.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_geom.glsl @@ -56,7 +56,7 @@ void main() half_size += 0.5; } - vec3 edge_ofs = vec3(half_size * drw_view.viewport_size_inverse, 0.0); + vec3 edge_ofs = vec3(half_size * sizeViewportInv, 0.0); bool horizontal = line.x > line.y; edge_ofs = (horizontal) ? edge_ofs.zyz : edge_ofs.xzz; diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl index 76a944c6987..ce1ee8ca448 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl @@ -5,11 +5,11 @@ void main() { mat3 imat = mat3(ModelMatrixInverse); - vec3 right = normalize(imat * screenVecs[0].xyz); - vec3 up = normalize(imat * screenVecs[1].xyz); + vec3 right = normalize(imat * ViewMatrixInverse[0].xyz); + vec3 up = normalize(imat * ViewMatrixInverse[1].xyz); vec3 screen_pos = (right * pos.x + up * pos.z) * size; vec4 pos_4d = ModelMatrix * vec4(local_pos + screen_pos, 1.0); - gl_Position = drw_view.persmat * pos_4d; + gl_Position = drw_view.winmat * (drw_view.viewmat * pos_4d); /* Manual stipple: one segment out of 2 is transparent. */ finalColor = ((gl_VertexID & 1) == 0) ? colorSkinRoot : vec4(0.0); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert_no_geom.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert_no_geom.glsl new file mode 100644 index 00000000000..fb18b95ccc5 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert_no_geom.glsl @@ -0,0 +1,208 @@ + +#pragma USE_SSBO_VERTEX_FETCH(TriangleList, 6) + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) +#pragma BLENDER_REQUIRE(overlay_edit_mesh_common_lib.glsl) + +#define DISCARD_VERTEX \ + gl_Position = geometry_out.finalColorOuter = geometry_out.finalColor = vec4(0.0); \ + geometry_out.edgeCoord = 0.0; \ + return; + +bool test_occlusion(vec4 pos) +{ + vec3 ndc = (pos.xyz / pos.w) * 0.5 + 0.5; + return ndc.z > texture(depthTex, ndc.xy).r; +} + +vec3 non_linear_blend_color(vec3 col1, vec3 col2, float fac) +{ + col1 = pow(col1, vec3(1.0 / 2.2)); + col2 = pow(col2, vec3(1.0 / 2.2)); + vec3 col = mix(col1, col2, fac); + return pow(col, vec3(2.2)); +} + +vec3 vec3_1010102_Inorm_to_vec3(vec3 data) +{ + return data; +} + +vec3 vec3_1010102_Inorm_to_vec3(int data) +{ + vec3 out_vec; + out_vec.x = float(clamp(data, -512, 511)) / 511.0f; + out_vec.y = float(clamp(data >> 10, -512, 511)) / 511.0f; + out_vec.z = float(clamp(data >> 20, -512, 511)) / 511.0f; + return out_vec; +} + +void do_vertex(vec4 color, vec4 pos, float coord, vec2 offset) +{ + geometry_out.finalColor = color; + geometry_out.edgeCoord = coord; + gl_Position = pos; + /* Multiply offset by 2 because gl_Position range is [-1..1]. */ + gl_Position.xy += offset * 2.0 * pos.w; +} + +void main() +{ + /* Index of the quad primitive -- corresponds to one line prim. */ + int quad_id = gl_VertexID / 6; + + /* Determine vertex within the output 2-triangle quad (A, B, C)(A, C, D). */ + int quad_vertex_id = gl_VertexID % 6; + + /* Base index of the line primitive: + * IF PrimType == LineList: base_vertex_id = quad_id*2 + * IF PrimType == LineStrip: base_vertex_id = quad_id + * + * Note: This is currently used as LineList. + * + * Note: Primitive Restart Will not work with this setup as-is. We should avoid using + * input primitive types which use restart indices. */ + int base_vertex_id = quad_id * 2; + + /* Fetch attribute values for self and neighboring vertex. */ + vec3 in_pos0 = vertex_fetch_attribute(base_vertex_id, pos, vec3); + vec3 in_pos1 = vertex_fetch_attribute(base_vertex_id + 1, pos, vec3); + uchar4 in_data0 = vertex_fetch_attribute(base_vertex_id, data, uchar4); + uchar4 in_data1 = vertex_fetch_attribute(base_vertex_id + 1, data, uchar4); + vec3 in_vnor0 = vec3_1010102_Inorm_to_vec3( + vertex_fetch_attribute(base_vertex_id, vnor, vec3_1010102_Inorm)); + vec3 in_vnor1 = vec3_1010102_Inorm_to_vec3( + vertex_fetch_attribute(base_vertex_id + 1, vnor, vec3_1010102_Inorm)); + + /* Calculate values for self and neighboring vertex. */ + vec4 out_finalColor[2]; + vec4 out_finalColorOuter[2]; + int selectOveride[2]; + + vec3 world_pos0 = point_object_to_world(in_pos0); + vec3 world_pos1 = point_object_to_world(in_pos1); + vec4 out_pos0 = point_world_to_ndc(world_pos0); + vec4 out_pos1 = point_world_to_ndc(world_pos1); + ivec4 m_data0 = ivec4(in_data0) & dataMask; + ivec4 m_data1 = ivec4(in_data1) & dataMask; + +#if defined(EDGE) +# ifdef FLAT + out_finalColor[0] = EDIT_MESH_edge_color_inner(m_data0.y); + out_finalColor[1] = EDIT_MESH_edge_color_inner(m_data1.y); + selectOveride[0] = 1; + selectOveride[1] = 1; +# else + out_finalColor[0] = EDIT_MESH_edge_vertex_color(m_data0.y); + out_finalColor[1] = EDIT_MESH_edge_vertex_color(m_data1.y); + selectOveride[0] = (m_data0.y & EDGE_SELECTED); + selectOveride[1] = (m_data1.y & EDGE_SELECTED); +# endif + + float crease0 = float(m_data0.z) / 255.0; + float crease1 = float(m_data1.z) / 255.0; + float bweight0 = float(m_data0.w) / 255.0; + float bweight1 = float(m_data1.w) / 255.0; + out_finalColorOuter[0] = EDIT_MESH_edge_color_outer(m_data0.y, m_data0.x, crease0, bweight0); + out_finalColorOuter[1] = EDIT_MESH_edge_color_outer(m_data1.y, m_data1.x, crease1, bweight1); + + if (out_finalColorOuter[0].a > 0.0) { + out_pos0.z -= 5e-7 * abs(out_pos0.w); + } + if (out_finalColorOuter[1].a > 0.0) { + out_pos1.z -= 5e-7 * abs(out_pos1.w); + } + + /* Occlusion done in fragment shader. */ + bool occluded0 = false; + bool occluded1 = false; +#endif + + out_finalColor[0].a *= (occluded0) ? alpha : 1.0; + out_finalColor[1].a *= (occluded1) ? alpha : 1.0; + +#if !defined(FACE) + /* Facing based color blend */ + vec3 vpos0 = point_world_to_view(world_pos0); + vec3 view_normal0 = normalize(normal_object_to_view(in_vnor0) + 1e-4); + vec3 view_vec0 = (ProjectionMatrix[3][3] == 0.0) ? normalize(vpos0) : vec3(0.0, 0.0, 1.0); + float facing0 = dot(view_vec0, view_normal0); + facing0 = 1.0 - abs(facing0) * 0.2; + + vec3 vpos1 = point_world_to_view(world_pos1); + vec3 view_normal1 = normalize(normal_object_to_view(in_vnor1) + 1e-4); + vec3 view_vec1 = (ProjectionMatrix[3][3] == 0.0) ? normalize(vpos1) : vec3(0.0, 0.0, 1.0); + float facing1 = dot(view_vec1, view_normal1); + facing1 = 1.0 - abs(facing1) * 0.2; + + /* Do interpolation in a non-linear space to have a better visual result. */ + out_finalColor[0].rgb = non_linear_blend_color( + colorEditMeshMiddle.rgb, out_finalColor[0].rgb, facing0); + out_finalColor[1].rgb = non_linear_blend_color( + colorEditMeshMiddle.rgb, out_finalColor[1].rgb, facing1); +#endif + + // -------- GEOM SHADER ALTERNATIVE ----------- // + vec2 ss_pos[2]; + + /* Clip line against near plane to avoid deformed lines. */ + vec4 pos0 = out_pos0; + vec4 pos1 = out_pos1; + vec2 pz_ndc = vec2(pos0.z / pos0.w, pos1.z / pos1.w); + bvec2 clipped = lessThan(pz_ndc, vec2(-1.0)); + if (all(clipped)) { + /* Totally clipped. */ + DISCARD_VERTEX; + } + + vec4 pos01 = pos0 - pos1; + float ofs = abs((pz_ndc.y + 1.0) / (pz_ndc.x - pz_ndc.y)); + if (clipped.y) { + pos1 += pos01 * ofs; + } + else if (clipped.x) { + pos0 -= pos01 * (1.0 - ofs); + } + + ss_pos[0] = pos0.xy / pos0.w; + ss_pos[1] = pos1.xy / pos1.w; + + vec2 line = ss_pos[0] - ss_pos[1]; + line = abs(line) * sizeViewport.xy; + + geometry_out.finalColorOuter = out_finalColorOuter[0]; + float half_size = sizeEdge; + /* Enlarge edge for flag display. */ + half_size += (geometry_out.finalColorOuter.a > 0.0) ? max(sizeEdge, 1.0) : 0.0; + +#ifdef USE_SMOOTH_WIRE + /* Add 1 px for AA */ + half_size += 0.5; +#endif + + vec3 edge_ofs = vec3(half_size * sizeViewportInv, 0.0); + + bool horizontal = line.x > line.y; + edge_ofs = (horizontal) ? edge_ofs.zyz : edge_ofs.xzz; + + vec4 final_color = (selectOveride[0] == 0) ? out_finalColor[1] : out_finalColor[0]; + + /* Output specific Vertex data depending on quad_vertex_id. */ + if (quad_vertex_id == 0) { + view_clipping_distances(world_pos0); + do_vertex(out_finalColor[0], pos0, half_size, edge_ofs.xy); + } + else if (quad_vertex_id == 1 || quad_vertex_id == 3) { + view_clipping_distances(world_pos0); + do_vertex(out_finalColor[0], pos0, -half_size, -edge_ofs.xy); + } + else if (quad_vertex_id == 2 || quad_vertex_id == 5) { + view_clipping_distances(world_pos1); + do_vertex(final_color, pos1, half_size, edge_ofs.xy); + } + else if (quad_vertex_id == 4) { + view_clipping_distances(world_pos1); + do_vertex(final_color, pos1, -half_size, -edge_ofs.xy); + } +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_frag.glsl index a849cb5160a..c9dc90e4113 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_frag.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_frag.glsl @@ -4,8 +4,8 @@ * We want to know how much a pixel is covered by a line. * We replace the square pixel with acircle of the same area and try to find the intersection area. * The area we search is the circular segment. https://en.wikipedia.org/wiki/Circular_segment - * The formula for the area uses inverse trig function and is quite complexe. Instead, - * we approximate it by using the smoothstep function and a 1.05 factor to the disc radius. + * The formula for the area uses inverse trig function and is quite complex. Instead, + * we approximate it by using the smooth-step function and a 1.05 factor to the disc radius. */ #define M_1_SQRTPI 0.5641895835477563 /* 1/sqrt(pi) */ #define DISC_RADIUS (M_1_SQRTPI * 1.05) diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_geom.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_geom.glsl index 8b19f671139..8038c68476a 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_geom.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_geom.glsl @@ -28,7 +28,7 @@ void main() half_size += (lineStyle == OVERLAY_UV_LINE_STYLE_OUTLINE) ? max(sizeEdge * (doSmoothWire ? 1.0 : 3.0), 1.0) : 0.0; - /* Add 1 px for AA */ + /* Add 1 PX for AA. */ if (doSmoothWire) { half_size += 0.5; } @@ -36,7 +36,7 @@ void main() vec2 line = ss_pos[0] - ss_pos[1]; vec2 line_dir = normalize(line); vec2 line_perp = vec2(-line_dir.y, line_dir.x); - vec2 edge_ofs = line_perp * drw_view.viewport_size_inverse * ceil(half_size); + vec2 edge_ofs = line_perp * sizeViewportInv * ceil(half_size); float selectFac0 = geom_in[0].selectionFac; float selectFac1 = geom_in[1].selectionFac; #ifdef USE_EDGE_SELECT diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_vert.glsl index 23f1a44c321..b7bcfbeb0d4 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_vert.glsl @@ -5,8 +5,8 @@ void main() vec3 world_pos = point_object_to_world(vec3(au, 0.0)); gl_Position = point_world_to_ndc(world_pos); /* Snap vertices to the pixel grid to reduce artifacts. */ - vec2 half_viewport_res = drw_view.viewport_size * 0.5; - vec2 half_pixel_offset = drw_view.viewport_size_inverse * 0.5; + vec2 half_viewport_res = sizeViewport * 0.5; + vec2 half_pixel_offset = sizeViewportInv * 0.5; gl_Position.xy = floor(gl_Position.xy * half_viewport_res) / half_viewport_res + half_pixel_offset; diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_groundline_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_groundline_vert.glsl index ff7aae523e7..bc8ba710d3b 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_extra_groundline_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_groundline_vert.glsl @@ -7,7 +7,7 @@ void main() finalColor = colorLight; /* Relative to DPI scaling. Have constant screen size. */ - vec3 screen_pos = screenVecs[0].xyz * pos.x + screenVecs[1].xyz * pos.y; + vec3 screen_pos = ViewMatrixInverse[0].xyz * pos.x + ViewMatrixInverse[1].xyz * pos.y; vec3 p = inst_pos; p.z *= (pos.z == 0.0) ? 0.0 : 1.0; float screen_size = mul_project_m4_v3_zfac(p) * sizePixel; diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_point_vert.glsl index de999c241c0..179c3cb6d73 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_extra_point_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_point_vert.glsl @@ -16,7 +16,7 @@ void main() radii[3] = radius - outline_width - 1.0; radii /= sizeObjectCenter; - fillColor = color; + fillColor = ucolor; outlineColor = colorOutline; view_clipping_distances(world_pos); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_vert.glsl index acaf04219c0..7b1e29525e9 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_extra_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_vert.glsl @@ -171,14 +171,14 @@ void main() vec3 world_pos; if ((vclass & VCLASS_SCREENSPACE) != 0) { /* Relative to DPI scaling. Have constant screen size. */ - vec3 screen_pos = screenVecs[0].xyz * vpos.x + screenVecs[1].xyz * vpos.y; + vec3 screen_pos = ViewMatrixInverse[0].xyz * vpos.x + ViewMatrixInverse[1].xyz * vpos.y; vec3 p = (obmat * vec4(vofs, 1.0)).xyz; float screen_size = mul_project_m4_v3_zfac(p) * sizePixel; world_pos = p + screen_pos * screen_size; } else if ((vclass & VCLASS_SCREENALIGNED) != 0) { /* World sized, camera facing geometry. */ - vec3 screen_pos = screenVecs[0].xyz * vpos.x + screenVecs[1].xyz * vpos.y; + vec3 screen_pos = ViewMatrixInverse[0].xyz * vpos.x + ViewMatrixInverse[1].xyz * vpos.y; world_pos = (obmat * vec4(vofs, 1.0)).xyz + screen_pos; } else { @@ -218,8 +218,7 @@ void main() /* HACK: to avoid losing sub-pixel object in selections, we add a bit of randomness to the * wire to at least create one fragment that will pass the occlusion query. */ /* TODO(fclem): Limit this workaround to selection. It's not very noticeable but still... */ - gl_Position.xy += drw_view.viewport_size_inverse * gl_Position.w * - ((gl_VertexID % 2 == 0) ? -1.0 : 1.0); + gl_Position.xy += sizeViewportInv * gl_Position.w * ((gl_VertexID % 2 == 0) ? -1.0 : 1.0); #endif view_clipping_distances(world_pos); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_vert.glsl index cd217021e8f..efa4e4706f3 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_vert.glsl @@ -16,8 +16,7 @@ void main() /* HACK: to avoid losing sub-pixel object in selections, we add a bit of randomness to the * wire to at least create one fragment that will pass the occlusion query. */ /* TODO(fclem): Limit this workaround to selection. It's not very noticeable but still... */ - gl_Position.xy += drw_view.viewport_size_inverse * gl_Position.w * - ((gl_VertexID % 2 == 0) ? -1.0 : 1.0); + gl_Position.xy += sizeViewportInv * gl_Position.w * ((gl_VertexID % 2 == 0) ? -1.0 : 1.0); #endif stipple_coord = stipple_start = screen_position(gl_Position); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_grid_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_grid_frag.glsl index 54a4231590e..b401c3e7b2e 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_grid_frag.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_grid_frag.glsl @@ -1,6 +1,6 @@ /** * Infinite grid: - * Draw antialiazed grid and axes of different sizes with smooth blending between Level of details. + * Draw antialiased grid and axes of different sizes with smooth blending between levels of detail. * We draw multiple triangles to avoid float precision issues due to perspective interpolation. **/ @@ -8,29 +8,33 @@ #pragma BLENDER_REQUIRE(common_math_lib.glsl) /** - * We want to know how much a pixel is covered by a line. - * We replace the square pixel with acircle of the same area and try to find the intersection area. - * The area we search is the circular segment. https://en.wikipedia.org/wiki/Circular_segment - * The formula for the area uses inverse trig function and is quite complexe. Instead, - * we approximate it by using the smoothstep function and a 1.05 factor to the disc radius. + * We want to know how much of a pixel is covered by a line. + * Here, we imagine the square pixel is a circle with the same area and try to find the + * intersection area. The overlap area is a circular segment. + * https://en.wikipedia.org/wiki/Circular_segment The formula for the area uses inverse trig + * function and is quite complex. Instead, we approximate it by using the smoothstep function and + * a 1.05 factor to the disc radius. + * + * For an alternate approach, see: + * https://developer.nvidia.com/gpugems/gpugems2/part-iii-high-quality-rendering/chapter-22-fast-prefiltered-lines */ #define M_1_SQRTPI 0.5641895835477563 /* 1/sqrt(pi) */ #define DISC_RADIUS (M_1_SQRTPI * 1.05) -#define GRID_LINE_SMOOTH_START (0.5 - DISC_RADIUS) -#define GRID_LINE_SMOOTH_END (0.5 + DISC_RADIUS) +#define GRID_LINE_SMOOTH_START (0.5 + DISC_RADIUS) +#define GRID_LINE_SMOOTH_END (0.5 - DISC_RADIUS) #define GRID_LINE_STEP(dist) smoothstep(GRID_LINE_SMOOTH_START, GRID_LINE_SMOOTH_END, dist) -float get_grid(vec2 co, vec2 fwidthCos, float grid_scale) +float get_grid(vec2 co, vec2 fwidthCos, vec2 grid_scale) { - float half_size = grid_scale / 2.0; + vec2 half_size = grid_scale / 2.0; /* Triangular wave pattern, amplitude is [0, half_size]. */ - vec2 grid_domain = abs(mod(co + half_size, vec2(grid_scale)) - half_size); + vec2 grid_domain = abs(mod(co + half_size, grid_scale) - half_size); /* Modulate by the absolute rate of change of the coordinates * (make line have the same width under perspective). */ grid_domain /= fwidthCos; /* Collapse waves. */ float line_dist = min(grid_domain.x, grid_domain.y); - return 1.0 - GRID_LINE_STEP(line_dist - grid_buf.line_size); + return GRID_LINE_STEP(line_dist - grid_buf.line_size); } vec3 get_axes(vec3 co, vec3 fwidthCos, float line_size) @@ -39,7 +43,7 @@ vec3 get_axes(vec3 co, vec3 fwidthCos, float line_size) /* Modulate by the absolute rate of change of the coordinates * (make line have the same width under perspective). */ axes_domain /= fwidthCos; - return 1.0 - GRID_LINE_STEP(axes_domain - (line_size + grid_buf.line_size)); + return GRID_LINE_STEP(axes_domain - (line_size + grid_buf.line_size)); } #define linearstep(p0, p1, v) (clamp(((v) - (p0)) / abs((p1) - (p0)), 0.0, 1.0)) @@ -91,9 +95,9 @@ void main() } if (flag_test(grid_flag, SHOW_GRID)) { - /* Using `max(dot(dFdxPos, screenVecs[0]), dot(dFdyPos, screenVecs[1]))` + /* Using `max(dot(dFdxPos, ViewMatrixInverse[0]), dot(dFdyPos, ViewMatrixInverse[1]))` * would be more accurate, but not really necessary. */ - float grid_res = dot(dFdxPos, screenVecs[0].xyz); + float grid_res = dot(dFdxPos, ViewMatrixInverse[0].xyz); /* The grid begins to appear when it comprises 4 pixels. */ grid_res *= 4; @@ -106,49 +110,30 @@ void main() grid_res = grid_buf.zoom_factor; } - /* From biggest to smallest. */ - vec4 scale; -#define grid_step(a) grid_buf.steps[a].x -#if 0 /* Inefficient. */ - int step_id = 0; - scale[0] = 0.0; - scale[1] = grid_step(0); - while (scale[1] < grid_res && step_id != STEPS_LEN - 1) { - scale[0] = scale[1]; - scale[1] = grid_step(++step_id); - } - scale[2] = grid_step(min(step_id + 1, STEPS_LEN - 1)); - scale[3] = grid_step(min(step_id + 2, STEPS_LEN - 1)); -#else - /* For more efficiency, unroll the loop above. */ - if (grid_step(0) > grid_res) { - scale = vec4(0.0, grid_step(0), grid_step(1), grid_step(2)); - } - else if (grid_step(1) > grid_res) { - scale = vec4(grid_step(0), grid_step(1), grid_step(2), grid_step(3)); - } - else if (grid_step(2) > grid_res) { - scale = vec4(grid_step(1), grid_step(2), grid_step(3), grid_step(4)); - } - else if (grid_step(3) > grid_res) { - scale = vec4(grid_step(2), grid_step(3), grid_step(4), grid_step(5)); - } - else if (grid_step(4) > grid_res) { - scale = vec4(grid_step(3), grid_step(4), grid_step(5), grid_step(6)); - } - else if (grid_step(5) > grid_res) { - scale = vec4(grid_step(4), grid_step(5), grid_step(6), grid_step(7)); - } - else if (grid_step(6) > grid_res) { - scale = vec4(grid_step(5), grid_step(6), grid_step(7), grid_step(7)); - } - else { - scale = vec4(grid_step(6), grid_step(7), grid_step(7), grid_step(7)); +/** Keep in sync with `SI_GRID_STEPS_LEN` in `DNA_space_types.h`. */ +#define STEPS_LEN 8 + int step_id_x = STEPS_LEN - 1; + int step_id_y = STEPS_LEN - 1; + + /* Loop backwards a compile-time-constant number of steps. */ + for (int i = STEPS_LEN - 2; i >= 0; --i) { + step_id_x = (grid_res < grid_buf.steps[i].x) ? i : step_id_x; /* Branchless. */ + step_id_y = (grid_res < grid_buf.steps[i].y) ? i : step_id_y; } -#endif -#undef grid_step - float blend = 1.0 - linearstep(scale[0], scale[1], grid_res); + /* From biggest to smallest. */ + float scale0x = step_id_x > 0 ? grid_buf.steps[step_id_x - 1].x : 0.0; + float scaleAx = grid_buf.steps[step_id_x].x; + float scaleBx = grid_buf.steps[min(step_id_x + 1, STEPS_LEN - 1)].x; + float scaleCx = grid_buf.steps[min(step_id_x + 2, STEPS_LEN - 1)].x; + + float scale0y = step_id_y > 0 ? grid_buf.steps[step_id_y - 1].y : 0.0; + float scaleAy = grid_buf.steps[step_id_y].y; + float scaleBy = grid_buf.steps[min(step_id_y + 1, STEPS_LEN - 1)].y; + float scaleCy = grid_buf.steps[min(step_id_y + 2, STEPS_LEN - 1)].y; + + /* Subtract from 1.0 to fix blending when `scale0x == scaleAx`. */ + float blend = 1.0 - linearstep(scale0x + scale0y, scaleAx + scaleAy, grid_res + grid_res); blend = blend * blend * blend; vec2 grid_pos, grid_fwidth; @@ -165,9 +150,9 @@ void main() grid_fwidth = fwidthPos.xy; } - float gridA = get_grid(grid_pos, grid_fwidth, scale[1]); - float gridB = get_grid(grid_pos, grid_fwidth, scale[2]); - float gridC = get_grid(grid_pos, grid_fwidth, scale[3]); + float gridA = get_grid(grid_pos, grid_fwidth, vec2(scaleAx, scaleAy)); + float gridB = get_grid(grid_pos, grid_fwidth, vec2(scaleBx, scaleBy)); + float gridC = get_grid(grid_pos, grid_fwidth, vec2(scaleCx, scaleCy)); out_color = colorGrid; out_color.a *= gridA * blend; diff --git a/source/blender/draw/engines/overlay/shaders/overlay_grid_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_grid_vert.glsl index b43b1eb4a52..6a027f94f49 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_grid_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_grid_vert.glsl @@ -39,5 +39,5 @@ void main() local_pos.z = clamp(local_pos.z, -1.0, 0.0); } - gl_Position = drw_view.persmat * vec4(real_pos, 1.0); + gl_Position = drw_view.winmat * (drw_view.viewmat * vec4(real_pos, 1.0)); } diff --git a/source/blender/draw/engines/overlay/shaders/overlay_image_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_image_frag.glsl index e0339507e0f..1a9da98c1fa 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_image_frag.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_image_frag.glsl @@ -6,7 +6,7 @@ void main() vec4 tex_color; tex_color = texture_read_as_linearrgb(imgTexture, imgPremultiplied, uvs_clamped); - fragColor = tex_color * color; + fragColor = tex_color * ucolor; if (!imgAlphaBlend) { /* Arbitrary discard anything below 5% opacity. diff --git a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_geom.glsl b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_geom.glsl index 25e13e7c212..32a38db140a 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_geom.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_geom.glsl @@ -12,8 +12,7 @@ vec2 compute_dir(vec2 v0, vec2 v1) void main(void) { vec2 t; - vec2 edge_dir = compute_dir(interp_in[0].ss_pos, interp_in[1].ss_pos) * - drw_view.viewport_size_inverse; + vec2 edge_dir = compute_dir(interp_in[0].ss_pos, interp_in[1].ss_pos) * sizeViewportInv; bool is_persp = (drw_view.winmat[3][3] == 0.0); float line_size = float(lineThickness) * sizePixel; diff --git a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert.glsl index e6281f75b8f..50c24de0838 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert.glsl @@ -18,7 +18,7 @@ vec2 proj(vec4 pos) void main() { - gl_Position = drw_view.persmat * vec4(pos, 1.0); + gl_Position = drw_view.winmat * (drw_view.viewmat * vec4(pos, 1.0)); interp.ss_pos = proj(gl_Position); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert_no_geom.glsl b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert_no_geom.glsl new file mode 100644 index 00000000000..abaa814a4dc --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert_no_geom.glsl @@ -0,0 +1,160 @@ + +#pragma USE_SSBO_VERTEX_FETCH(TriangleList, 6) + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +#define frameCurrent mpathLineSettings.x +#define frameStart mpathLineSettings.y +#define frameEnd mpathLineSettings.z +#define cacheStart mpathLineSettings.w + +/* Project to screen space. */ +vec2 proj(vec4 pos) +{ + return (0.5 * (pos.xy / pos.w) + 0.5) * sizeViewport.xy; +} + +#define SET_INTENSITY(A, B, C, min, max) \ + (((1.0 - (float(C - B) / float(C - A))) * (max - min)) + min) + +vec2 compute_dir(vec2 v0, vec2 v1) +{ + vec2 dir = normalize(v1 - v0 + 1e-8); + dir = vec2(-dir.y, dir.x); + return dir; +} + +void do_vertex_shader(vec4 pos, int vertex_id, out vec2 out_sspos, out vec4 out_finalcolour) +{ + out_sspos = proj(pos); + out_finalcolour = vec4(0.0); + + int frame = vertex_id + cacheStart; + float intensity; /* how faint */ + vec3 blend_base = (abs(frame - frameCurrent) == 0) ? + colorCurrentFrame.rgb : + colorBackground.rgb; /* "bleed" cframe color to ease color blending */ + bool use_custom_color = customColor.x >= 0.0; + /* TODO: We might want something more consistent with custom color and standard colors. */ + if (frame < frameCurrent) { + if (use_custom_color) { + /* Custom color: previous frames color is darker than current frame */ + out_finalcolour.rgb = customColor * 0.25; + } + else { + /* black - before frameCurrent */ + if (selected) { + intensity = SET_INTENSITY(frameStart, frame, frameCurrent, 0.25, 0.75); + } + else { + intensity = SET_INTENSITY(frameStart, frame, frameCurrent, 0.68, 0.92); + } + out_finalcolour.rgb = mix(colorWire.rgb, blend_base, intensity); + } + } + else if (frame > frameCurrent) { + if (use_custom_color) { + /* Custom color: next frames color is equal to user selected color */ + out_finalcolour.rgb = customColor; + } + else { + /* blue - after frameCurrent */ + if (selected) { + intensity = SET_INTENSITY(frameCurrent, frame, frameEnd, 0.25, 0.75); + } + else { + intensity = SET_INTENSITY(frameCurrent, frame, frameEnd, 0.68, 0.92); + } + + out_finalcolour.rgb = mix(colorBonePose.rgb, blend_base, intensity); + } + } + else { + if (use_custom_color) { + /* Custom color: current frame color is slightly darker than user selected color */ + out_finalcolour.rgb = customColor * 0.5; + } + else { + /* green - on frameCurrent */ + if (selected) { + intensity = 0.92f; + } + else { + intensity = 0.75f; + } + out_finalcolour.rgb = mix(colorBackground.rgb, blend_base, intensity); + } + } + out_finalcolour.a = 1.0; +} + +void main() +{ + /** Determine Output Primitive ID and relative vertex. */ + /* Index of the quad primitive. We generate one quad for each input line. */ + int quad_id = gl_VertexID / 6; + + /* Determine vertex within the quad (A, B, C)(A, C, D). */ + int quad_vertex_id = gl_VertexID % 6; + /* Base index of the line primitive: + * - IF PrimType == LineList: base_vertex_id = quad_id*2 + * - IF PrimType == LineStrip: base_vertex_id = quad_id + * + * Note: Primitive is LineStrip for this shader. */ + int base_vertex_id = quad_id; + + /* Fetch attributes for self and neighboring vertex. */ + vec3 in_pos0 = vertex_fetch_attribute(base_vertex_id, pos, vec3); + vec3 in_pos1 = vertex_fetch_attribute(base_vertex_id + 1, pos, vec3); + + vec4 out_pos0 = drw_view.winmat * (drw_view.viewmat * vec4(in_pos0, 1.0)); + vec4 out_pos1 = drw_view.winmat * (drw_view.viewmat * vec4(in_pos1, 1.0)); + + /* Final calculations required for Geometry Shader alternative. + * We need to calculate values for each vertex position to correctly determine the final output + * position. */ + vec2 ssPos[2]; + vec4 finalColor_geom[2]; + + do_vertex_shader(out_pos0, base_vertex_id, ssPos[0], finalColor_geom[0]); + do_vertex_shader(out_pos1, base_vertex_id + 1, ssPos[0], finalColor_geom[0]); + + /* Geometry shader alternative -- Output is trianglelist consisting of 6 vertices. + * Each vertex shader invocation is one vertex in the output primitive, so outptut + * required ID. */ + vec2 t; + vec2 edge_dir = compute_dir(ssPos[0], ssPos[1]) * sizeViewportInv; + + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + float line_size = float(lineThickness) * sizePixel; + + if (quad_vertex_id == 0) { + view_clipping_distances(out_pos0.xyz); + + interp.color = finalColor_geom[0]; + t = edge_dir * (line_size * (is_persp ? out_pos0.w : 1.0)); + gl_Position = out_pos0 + vec4(t, 0.0, 0.0); + } + else if (quad_vertex_id == 1 || quad_vertex_id == 3) { + view_clipping_distances(out_pos0.xyz); + + interp.color = finalColor_geom[0]; + t = edge_dir * (line_size * (is_persp ? out_pos0.w : 1.0)); + gl_Position = out_pos0 - vec4(t, 0.0, 0.0); + } + else if (quad_vertex_id == 2 || quad_vertex_id == 5) { + view_clipping_distances(out_pos1.xyz); + + interp.color = finalColor_geom[1]; + t = edge_dir * (line_size * (is_persp ? out_pos1.w : 1.0)); + gl_Position = out_pos1 + vec4(t, 0.0, 0.0); + } + else if (quad_vertex_id == 4) { + view_clipping_distances(out_pos1.xyz); + + interp.color = finalColor_geom[1]; + t = edge_dir * (line_size * (is_persp ? out_pos1.w : 1.0)); + gl_Position = out_pos1 - vec4(t, 0.0, 0.0); + } +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_point_vert.glsl index 70892954cd8..7305d00c052 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_point_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_point_vert.glsl @@ -9,7 +9,7 @@ void main() { - gl_Position = drw_view.persmat * vec4(pos, 1.0); + gl_Position = drw_view.winmat * (drw_view.viewmat * vec4(pos, 1.0)); gl_PointSize = float(pointSize + 2); int frame = gl_VertexID + cacheStart; diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_detect_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_detect_frag.glsl index 472a589f441..18914b0276f 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_outline_detect_frag.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_detect_frag.glsl @@ -36,7 +36,7 @@ bvec4 gather_edges(vec2 uv, uint ref) #ifdef GPU_ARB_texture_gather ids = textureGather(outlineId, uv); #else - vec3 ofs = vec3(0.5, 0.5, -0.5) * drw_view.viewport_size_inverse.xyy; + vec3 ofs = vec3(0.5, 0.5, -0.5) * sizeViewportInv.xyy; ids.x = textureLod(outlineId, uv - ofs.xz, 0.0).r; ids.y = textureLod(outlineId, uv + ofs.xy, 0.0).r; ids.z = textureLod(outlineId, uv + ofs.xz, 0.0).r; @@ -161,8 +161,8 @@ void main() uint ref = textureLod(outlineId, uvcoordsvar.xy, 0.0).r; uint ref_col = ref; - vec2 uvs = gl_FragCoord.xy * drw_view.viewport_size_inverse; - vec3 ofs = vec3(drw_view.viewport_size_inverse.xy, 0.0); + vec2 uvs = gl_FragCoord.xy * sizeViewportInv; + vec3 ofs = vec3(sizeViewportInv.xy, 0.0); vec2 depth_uv = uvs; @@ -269,13 +269,13 @@ void main() switch (edge_case) { /* Straight lines. */ case YPOS: - extra_edges = gather_edges(uvs + drw_view.viewport_size_inverse * vec2(2.5, 0.5), ref); - extra_edges2 = gather_edges(uvs + drw_view.viewport_size_inverse * vec2(-2.5, 0.5), ref); + extra_edges = gather_edges(uvs + sizeViewportInv * vec2(2.5, 0.5), ref); + extra_edges2 = gather_edges(uvs + sizeViewportInv * vec2(-2.5, 0.5), ref); straight_line_dir(extra_edges, extra_edges2, line_start, line_end); break; case YNEG: - extra_edges = gather_edges(uvs + drw_view.viewport_size_inverse * vec2(-2.5, -0.5), ref); - extra_edges2 = gather_edges(uvs + drw_view.viewport_size_inverse * vec2(2.5, -0.5), ref); + extra_edges = gather_edges(uvs + sizeViewportInv * vec2(-2.5, -0.5), ref); + extra_edges2 = gather_edges(uvs + sizeViewportInv * vec2(2.5, -0.5), ref); extra_edges = rotate_180(extra_edges); extra_edges2 = rotate_180(extra_edges2); straight_line_dir(extra_edges, extra_edges2, line_start, line_end); @@ -283,8 +283,8 @@ void main() line_end = rotate_180(line_end); break; case XPOS: - extra_edges = gather_edges(uvs + drw_view.viewport_size_inverse * vec2(0.5, 2.5), ref); - extra_edges2 = gather_edges(uvs + drw_view.viewport_size_inverse * vec2(0.5, -2.5), ref); + extra_edges = gather_edges(uvs + sizeViewportInv * vec2(0.5, 2.5), ref); + extra_edges2 = gather_edges(uvs + sizeViewportInv * vec2(0.5, -2.5), ref); extra_edges = rotate_90(extra_edges); extra_edges2 = rotate_90(extra_edges2); straight_line_dir(extra_edges, extra_edges2, line_start, line_end); @@ -292,8 +292,8 @@ void main() line_end = rotate_90(line_end); break; case XNEG: - extra_edges = gather_edges(uvs + drw_view.viewport_size_inverse * vec2(-0.5, 2.5), ref); - extra_edges2 = gather_edges(uvs + drw_view.viewport_size_inverse * vec2(-0.5, -2.5), ref); + extra_edges = gather_edges(uvs + sizeViewportInv * vec2(-0.5, 2.5), ref); + extra_edges2 = gather_edges(uvs + sizeViewportInv * vec2(-0.5, -2.5), ref); extra_edges = rotate_270(extra_edges); extra_edges2 = rotate_270(extra_edges2); straight_line_dir(extra_edges, extra_edges2, line_start, line_end); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_curves_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_curves_vert.glsl index f9ec475d21f..27150d1cb3d 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_curves_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_curves_vert.glsl @@ -45,8 +45,8 @@ void main() vec3 world_pos; if (hairThicknessRes > 1) { /* Calculate the thickness, thicktime, worldpos taken into account the outline. */ - float outline_width = point_world_to_ndc(center_wpos).w * 1.25 * - drw_view.viewport_size_inverse.y * drw_view.wininv[1][1]; + float outline_width = point_world_to_ndc(center_wpos).w * 1.25 * sizeViewportInv.y * + drw_view.wininv[1][1]; thickness += outline_width; float thick_time = float(gl_VertexID % hairThicknessRes) / float(hairThicknessRes - 1); thick_time = thickness * (thick_time * 2.0 - 1.0); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_frag.glsl index 92be9ec3bcb..2b7c3f06769 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_frag.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_frag.glsl @@ -23,9 +23,9 @@ void main() if (!gpStrokeOrder3d) { /* Stroke order 2D. Project to gpDepthPlane. */ bool is_persp = drw_view.winmat[3][3] == 0.0; - vec2 uvs = vec2(gl_FragCoord.xy) * drw_view.viewport_size_inverse; + vec2 uvs = vec2(gl_FragCoord.xy) * sizeViewportInv; vec3 pos_ndc = vec3(uvs, gl_FragCoord.z) * 2.0 - 1.0; - vec4 pos_world = drw_view.persinv * vec4(pos_ndc, 1.0); + vec4 pos_world = drw_view.viewinv * (drw_view.wininv * vec4(pos_ndc, 1.0)); vec3 pos = pos_world.xyz / pos_world.w; vec3 ray_ori = pos; diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl index 4b1470e5723..851e0884354 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl @@ -34,20 +34,7 @@ void main() float unused_strength; vec2 unused_uv; - gl_Position = gpencil_vertex(ma, - ma1, - ma2, - ma3, - pos, - pos1, - pos2, - pos3, - uv1, - uv2, - col1, - col2, - fcol1, - vec4(drw_view.viewport_size, drw_view.viewport_size_inverse), + gl_Position = gpencil_vertex(vec4(sizeViewport, sizeViewportInv), world_pos, unused_N, unused_color, diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_point_vert.glsl index 8736b2a87db..7b7408964f2 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_paint_point_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_point_vert.glsl @@ -10,8 +10,8 @@ void main() vec3 world_pos = point_object_to_world(pos); gl_Position = point_world_to_ndc(world_pos); - /* Add offset in Z to avoid zfighting and render selected wires on top. */ - /* TODO: scale this bias using znear and zfar range. */ + /* Add offset in Z to avoid Z-fighting and render selected wires on top. */ + /* TODO: scale this bias using Z-near and Z-far range. */ gl_Position.z -= (is_select ? 2e-4 : 1e-4); if (is_hidden) { diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_wire_vert.glsl index 749cc92f082..f34133596b1 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_paint_wire_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_wire_vert.glsl @@ -10,8 +10,8 @@ void main() vec3 world_pos = point_object_to_world(pos); gl_Position = point_world_to_ndc(world_pos); - /* Add offset in Z to avoid zfighting and render selected wires on top. */ - /* TODO: scale this bias using znear and zfar range. */ + /* Add offset in Z to avoid Z-fighting and render selected wires on top. */ + /* TODO: scale this bias using Z-near and Z-far range. */ gl_Position.z -= (is_select ? 2e-4 : 1e-4); if (is_hidden) { diff --git a/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl index c48e7cce550..2c2d3199e45 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl @@ -16,7 +16,7 @@ vec3 rotate(vec3 vec, vec4 quat) void main() { /* Drawsize packed in alpha. */ - float draw_size = color.a; + float draw_size = ucolor.a; vec3 world_pos = part_pos; @@ -28,7 +28,7 @@ void main() if ((vclass & VCLASS_SCREENALIGNED) != 0) { /* World sized, camera facing geometry. */ - world_pos += (screenVecs[0].xyz * pos.x + screenVecs[1].xyz * pos.y) * draw_size; + world_pos += (ViewMatrixInverse[0].xyz * pos.x + ViewMatrixInverse[1].xyz * pos.y) * draw_size; } else { world_pos += rotate(pos, part_rot) * draw_size; @@ -43,7 +43,7 @@ void main() finalColor = vec4(clamp(pos * 10000.0, 0.0, 1.0), 1.0); } else if (part_val < 0.0) { - finalColor = vec4(color.rgb, 1.0); + finalColor = vec4(ucolor.rgb, 1.0); } else { finalColor = vec4(texture(weightTex, part_val).rgb, 1.0); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_pointcloud_only_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_pointcloud_only_vert.glsl new file mode 100644 index 00000000000..8a7e81028d3 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_pointcloud_only_vert.glsl @@ -0,0 +1,9 @@ +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) +#pragma BLENDER_REQUIRE(common_pointcloud_lib.glsl) + +void main() +{ + vec3 world_pos = pointcloud_get_pos(); + gl_Position = point_world_to_ndc(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_uniform_color_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_uniform_color_frag.glsl index e1a4a3602e3..2794481489c 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_uniform_color_frag.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_uniform_color_frag.glsl @@ -1,4 +1,4 @@ void main() { - fragColor = color; + fragColor = ucolor; } diff --git a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curve_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curve_vert.glsl new file mode 100644 index 00000000000..7c2c386b2f5 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curve_vert.glsl @@ -0,0 +1,9 @@ +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + finalColor = attribute_value; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curves_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curves_vert.glsl new file mode 100644 index 00000000000..23d313e036f --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_curves_vert.glsl @@ -0,0 +1,28 @@ +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) +#pragma BLENDER_REQUIRE(common_hair_lib.glsl) + +void main() +{ + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + float time, thick_time, thickness; + vec3 world_pos, tan, binor; + hair_get_pos_tan_binor_time(is_persp, + ModelMatrixInverse, + ViewMatrixInverse[3].xyz, + ViewMatrixInverse[2].xyz, + world_pos, + tan, + binor, + time, + thickness, + thick_time); + gl_Position = point_world_to_ndc(world_pos); + + if (is_point_domain) { + finalColor = texelFetch(color_tx, hair_get_base_id()); + } + else { + finalColor = texelFetch(color_tx, hair_get_strand_id()); + } +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_frag.glsl new file mode 100644 index 00000000000..e5752ada940 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_frag.glsl @@ -0,0 +1,8 @@ + +void main() +{ + out_color = finalColor; + out_color.a *= opacity; + /* Writing to this second texture is necessary to avoid undefined behavior. */ + lineOutput = vec4(0.0); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_mesh_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_mesh_vert.glsl new file mode 100644 index 00000000000..7c2c386b2f5 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_mesh_vert.glsl @@ -0,0 +1,9 @@ +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + finalColor = attribute_value; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_pointcloud_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_pointcloud_vert.glsl new file mode 100644 index 00000000000..e7b7cafd898 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_viewer_attribute_pointcloud_vert.glsl @@ -0,0 +1,10 @@ +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) +#pragma BLENDER_REQUIRE(common_pointcloud_lib.glsl) + +void main() +{ + vec3 world_pos = pointcloud_get_pos(); + gl_Position = point_world_to_ndc(world_pos); + finalColor = pointcloud_get_customdata_vec4(attribute_tx); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_wireframe_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_wireframe_frag.glsl index bc28d7a8a36..d3eb1a500ba 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_wireframe_frag.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_wireframe_frag.glsl @@ -17,10 +17,10 @@ void main() vec2 dir = lineOutput.xy * 2.0 - 1.0; bool dir_horiz = abs(dir.x) > abs(dir.y); - vec2 uv = gl_FragCoord.xy * drw_view.viewport_size_inverse; + vec2 uv = gl_FragCoord.xy * sizeViewportInv; float depth_occluder = texture(depthTex, uv).r; float depth_min = depth_occluder; - vec2 texel_uv_size = drw_view.viewport_size_inverse; + vec2 texel_uv_size = sizeViewportInv; if (dir_horiz) { depth_min = min(depth_min, texture(depthTex, uv + vec2(-texel_uv_size.x, 0.0)).r); diff --git a/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl index d189ab1b72c..7af2e0b3427 100644 --- a/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl +++ b/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl @@ -96,7 +96,7 @@ void main() wofs = normal_world_to_view(wofs); /* Push vertex half a pixel (maximum) in normal direction. */ - gl_Position.xy += wofs.xy * drw_view.viewport_size_inverse * gl_Position.w; + gl_Position.xy += wofs.xy * sizeViewportInv * gl_Position.w; /* Push the vertex towards the camera. Helps a bit. */ gl_Position.z -= facing_ratio * curvature * 1.0e-6 * gl_Position.w; @@ -136,8 +136,7 @@ void main() #ifdef SELECT_EDGES /* HACK: to avoid losing sub-pixel object in selections, we add a bit of randomness to the * wire to at least create one fragment that will pass the occlusion query. */ - gl_Position.xy += drw_view.viewport_size_inverse * gl_Position.w * - ((gl_VertexID % 2 == 0) ? -1.0 : 1.0); + gl_Position.xy += sizeViewportInv * gl_Position.w * ((gl_VertexID % 2 == 0) ? -1.0 : 1.0); #endif view_clipping_distances(wpos); |