From c15e913df87af34b381922b2a6951e9bc2baef6c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= Date: Thu, 2 Jun 2022 21:08:05 +0200 Subject: Cleanup: DRW: Added overlay_ prefix to all *.glsl files in overlay/shaders This is needed to avoid potential naming collision with other engines --- source/blender/draw/CMakeLists.txt | 194 +++++------ .../engines/overlay/shaders/antialiasing_frag.glsl | 146 --------- .../overlay/shaders/armature_dof_solid_frag.glsl | 6 - .../engines/overlay/shaders/armature_dof_vert.glsl | 32 -- .../shaders/armature_envelope_outline_vert.glsl | 145 --------- .../shaders/armature_envelope_solid_frag.glsl | 17 - .../shaders/armature_envelope_solid_vert.glsl | 42 --- .../shaders/armature_shape_outline_geom.glsl | 76 ----- .../shaders/armature_shape_outline_vert.glsl | 37 --- .../overlay/shaders/armature_shape_solid_frag.glsl | 12 - .../overlay/shaders/armature_shape_solid_vert.glsl | 31 -- .../overlay/shaders/armature_shape_wire_vert.glsl | 19 -- .../shaders/armature_sphere_outline_vert.glsl | 74 ----- .../shaders/armature_sphere_solid_frag.glsl | 52 --- .../shaders/armature_sphere_solid_vert.glsl | 76 ----- .../overlay/shaders/armature_stick_frag.glsl | 8 - .../overlay/shaders/armature_stick_vert.glsl | 74 ----- .../overlay/shaders/armature_wire_frag.glsl | 8 - .../overlay/shaders/armature_wire_vert.glsl | 16 - .../engines/overlay/shaders/background_frag.glsl | 86 ----- .../engines/overlay/shaders/clipbound_vert.glsl | 13 - .../overlay/shaders/common_overlay_lib.glsl | 5 - .../engines/overlay/shaders/depth_only_vert.glsl | 13 - .../overlay/shaders/edit_curve_handle_geom.glsl | 116 ------- .../overlay/shaders/edit_curve_handle_vert.glsl | 14 - .../overlay/shaders/edit_curve_point_vert.glsl | 37 --- .../overlay/shaders/edit_curve_wire_vert.glsl | 23 -- .../overlay/shaders/edit_gpencil_canvas_vert.glsl | 30 -- .../overlay/shaders/edit_gpencil_guide_vert.glsl | 14 - .../engines/overlay/shaders/edit_gpencil_vert.glsl | 87 ----- .../overlay/shaders/edit_lattice_point_vert.glsl | 28 -- .../overlay/shaders/edit_lattice_wire_vert.glsl | 32 -- .../overlay/shaders/edit_mesh_analysis_frag.glsl | 5 - .../overlay/shaders/edit_mesh_analysis_vert.glsl | 29 -- .../overlay/shaders/edit_mesh_common_lib.glsl | 77 ----- .../engines/overlay/shaders/edit_mesh_frag.glsl | 44 --- .../engines/overlay/shaders/edit_mesh_geom.glsl | 77 ----- .../overlay/shaders/edit_mesh_normal_vert.glsl | 69 ---- .../overlay/shaders/edit_mesh_skin_root_vert.glsl | 17 - .../engines/overlay/shaders/edit_mesh_vert.glsl | 99 ------ .../overlay/shaders/edit_particle_point_vert.glsl | 15 - .../overlay/shaders/edit_particle_strand_vert.glsl | 35 -- .../overlay/shaders/edit_uv_edges_frag.glsl | 69 ---- .../overlay/shaders/edit_uv_edges_geom.glsl | 57 ---- .../overlay/shaders/edit_uv_edges_vert.glsl | 27 -- .../overlay/shaders/edit_uv_face_dots_vert.glsl | 10 - .../overlay/shaders/edit_uv_faces_vert.glsl | 14 - .../overlay/shaders/edit_uv_image_mask_frag.glsl | 8 - .../overlay/shaders/edit_uv_image_vert.glsl | 11 - .../overlay/shaders/edit_uv_stretching_vert.glsl | 82 ----- .../shaders/edit_uv_tiled_image_borders_vert.glsl | 14 - .../overlay/shaders/edit_uv_verts_frag.glsl | 27 -- .../overlay/shaders/edit_uv_verts_vert.glsl | 33 -- .../draw/engines/overlay/shaders/extra_frag.glsl | 8 - .../overlay/shaders/extra_groundline_vert.glsl | 22 -- .../shaders/extra_lightprobe_grid_vert.glsl | 61 ---- .../overlay/shaders/extra_loose_point_frag.glsl | 20 -- .../overlay/shaders/extra_loose_point_vert.glsl | 17 - .../engines/overlay/shaders/extra_point_vert.glsl | 23 -- .../draw/engines/overlay/shaders/extra_vert.glsl | 226 ------------- .../engines/overlay/shaders/extra_wire_frag.glsl | 26 -- .../engines/overlay/shaders/extra_wire_vert.glsl | 47 --- .../draw/engines/overlay/shaders/facing_frag.glsl | 5 - .../draw/engines/overlay/shaders/facing_vert.glsl | 10 - .../overlay/shaders/grid_background_frag.glsl | 7 - .../draw/engines/overlay/shaders/grid_frag.glsl | 232 ------------- .../draw/engines/overlay/shaders/grid_vert.glsl | 43 --- .../draw/engines/overlay/shaders/image_frag.glsl | 24 -- .../draw/engines/overlay/shaders/image_vert.glsl | 29 -- .../shaders/infos/overlay_antialiasing_info.hh | 4 +- .../overlay/shaders/infos/overlay_armature_info.hh | 44 +-- .../shaders/infos/overlay_background_info.hh | 4 +- .../shaders/infos/overlay_edit_mode_info.hh | 64 ++-- .../overlay/shaders/infos/overlay_extra_info.hh | 40 +-- .../overlay/shaders/infos/overlay_facing_info.hh | 4 +- .../overlay/shaders/infos/overlay_grid_info.hh | 10 +- .../overlay/shaders/infos/overlay_outline_info.hh | 16 +- .../overlay/shaders/infos/overlay_paint_info.hh | 18 +- .../overlay/shaders/infos/overlay_sculpt_info.hh | 4 +- .../overlay/shaders/infos/overlay_volume_info.hh | 4 +- .../shaders/infos/overlay_wireframe_info.hh | 4 +- .../overlay/shaders/motion_path_line_frag.glsl | 5 - .../overlay/shaders/motion_path_line_geom.glsl | 37 --- .../overlay/shaders/motion_path_line_vert.glsl | 87 ----- .../overlay/shaders/motion_path_point_vert.glsl | 47 --- .../overlay/shaders/outline_detect_frag.glsl | 360 --------------------- .../overlay/shaders/outline_prepass_frag.glsl | 5 - .../overlay/shaders/outline_prepass_geom.glsl | 47 --- .../shaders/outline_prepass_gpencil_frag.glsl | 42 --- .../shaders/outline_prepass_gpencil_vert.glsl | 74 ----- .../shaders/outline_prepass_pointcloud_vert.glsl | 48 --- .../overlay/shaders/outline_prepass_vert.glsl | 50 --- .../overlay/shaders/overlay_antialiasing_frag.glsl | 146 +++++++++ .../shaders/overlay_armature_dof_solid_frag.glsl | 6 + .../overlay/shaders/overlay_armature_dof_vert.glsl | 32 ++ .../overlay_armature_envelope_outline_vert.glsl | 145 +++++++++ .../overlay_armature_envelope_solid_frag.glsl | 17 + .../overlay_armature_envelope_solid_vert.glsl | 42 +++ .../overlay_armature_shape_outline_geom.glsl | 76 +++++ .../overlay_armature_shape_outline_vert.glsl | 37 +++ .../shaders/overlay_armature_shape_solid_frag.glsl | 12 + .../shaders/overlay_armature_shape_solid_vert.glsl | 31 ++ .../shaders/overlay_armature_shape_wire_vert.glsl | 19 ++ .../overlay_armature_sphere_outline_vert.glsl | 74 +++++ .../overlay_armature_sphere_solid_frag.glsl | 52 +++ .../overlay_armature_sphere_solid_vert.glsl | 76 +++++ .../shaders/overlay_armature_stick_frag.glsl | 8 + .../shaders/overlay_armature_stick_vert.glsl | 74 +++++ .../shaders/overlay_armature_wire_frag.glsl | 8 + .../shaders/overlay_armature_wire_vert.glsl | 16 + .../overlay/shaders/overlay_background_frag.glsl | 86 +++++ .../overlay/shaders/overlay_clipbound_vert.glsl | 13 + .../overlay/shaders/overlay_common_lib.glsl | 5 + .../overlay/shaders/overlay_depth_only_vert.glsl | 13 + .../shaders/overlay_edit_curve_handle_geom.glsl | 116 +++++++ .../shaders/overlay_edit_curve_handle_vert.glsl | 14 + .../shaders/overlay_edit_curve_point_vert.glsl | 37 +++ .../shaders/overlay_edit_curve_wire_vert.glsl | 23 ++ .../shaders/overlay_edit_gpencil_canvas_vert.glsl | 30 ++ .../shaders/overlay_edit_gpencil_guide_vert.glsl | 14 + .../overlay/shaders/overlay_edit_gpencil_vert.glsl | 87 +++++ .../shaders/overlay_edit_lattice_point_vert.glsl | 28 ++ .../shaders/overlay_edit_lattice_wire_vert.glsl | 32 ++ .../shaders/overlay_edit_mesh_analysis_frag.glsl | 5 + .../shaders/overlay_edit_mesh_analysis_vert.glsl | 29 ++ .../shaders/overlay_edit_mesh_common_lib.glsl | 77 +++++ .../overlay/shaders/overlay_edit_mesh_frag.glsl | 44 +++ .../overlay/shaders/overlay_edit_mesh_geom.glsl | 77 +++++ .../shaders/overlay_edit_mesh_normal_vert.glsl | 69 ++++ .../shaders/overlay_edit_mesh_skin_root_vert.glsl | 17 + .../overlay/shaders/overlay_edit_mesh_vert.glsl | 99 ++++++ .../shaders/overlay_edit_particle_point_vert.glsl | 15 + .../shaders/overlay_edit_particle_strand_vert.glsl | 35 ++ .../shaders/overlay_edit_uv_edges_frag.glsl | 69 ++++ .../shaders/overlay_edit_uv_edges_geom.glsl | 57 ++++ .../shaders/overlay_edit_uv_edges_vert.glsl | 27 ++ .../shaders/overlay_edit_uv_face_dots_vert.glsl | 10 + .../shaders/overlay_edit_uv_faces_vert.glsl | 14 + .../shaders/overlay_edit_uv_image_mask_frag.glsl | 8 + .../shaders/overlay_edit_uv_image_vert.glsl | 11 + .../shaders/overlay_edit_uv_stretching_vert.glsl | 82 +++++ .../overlay_edit_uv_tiled_image_borders_vert.glsl | 14 + .../shaders/overlay_edit_uv_verts_frag.glsl | 27 ++ .../shaders/overlay_edit_uv_verts_vert.glsl | 33 ++ .../overlay/shaders/overlay_extra_frag.glsl | 8 + .../shaders/overlay_extra_groundline_vert.glsl | 22 ++ .../overlay_extra_lightprobe_grid_vert.glsl | 61 ++++ .../shaders/overlay_extra_loose_point_frag.glsl | 20 ++ .../shaders/overlay_extra_loose_point_vert.glsl | 17 + .../overlay/shaders/overlay_extra_point_vert.glsl | 23 ++ .../overlay/shaders/overlay_extra_vert.glsl | 226 +++++++++++++ .../overlay/shaders/overlay_extra_wire_frag.glsl | 26 ++ .../overlay/shaders/overlay_extra_wire_vert.glsl | 47 +++ .../overlay/shaders/overlay_facing_frag.glsl | 5 + .../overlay/shaders/overlay_facing_vert.glsl | 10 + .../shaders/overlay_grid_background_frag.glsl | 7 + .../engines/overlay/shaders/overlay_grid_frag.glsl | 232 +++++++++++++ .../engines/overlay/shaders/overlay_grid_vert.glsl | 43 +++ .../overlay/shaders/overlay_image_frag.glsl | 24 ++ .../overlay/shaders/overlay_image_vert.glsl | 29 ++ .../shaders/overlay_motion_path_line_frag.glsl | 5 + .../shaders/overlay_motion_path_line_geom.glsl | 37 +++ .../shaders/overlay_motion_path_line_vert.glsl | 87 +++++ .../shaders/overlay_motion_path_point_vert.glsl | 47 +++ .../shaders/overlay_outline_detect_frag.glsl | 360 +++++++++++++++++++++ .../shaders/overlay_outline_prepass_frag.glsl | 5 + .../shaders/overlay_outline_prepass_geom.glsl | 47 +++ .../overlay_outline_prepass_gpencil_frag.glsl | 42 +++ .../overlay_outline_prepass_gpencil_vert.glsl | 74 +++++ .../overlay_outline_prepass_pointcloud_vert.glsl | 48 +++ .../shaders/overlay_outline_prepass_vert.glsl | 50 +++ .../overlay/shaders/overlay_paint_face_vert.glsl | 21 ++ .../overlay/shaders/overlay_paint_point_vert.glsl | 27 ++ .../shaders/overlay_paint_texture_frag.glsl | 14 + .../shaders/overlay_paint_texture_vert.glsl | 14 + .../shaders/overlay_paint_vertcol_frag.glsl | 20 ++ .../shaders/overlay_paint_vertcol_vert.glsl | 22 ++ .../overlay/shaders/overlay_paint_weight_frag.glsl | 98 ++++++ .../overlay/shaders/overlay_paint_weight_vert.glsl | 25 ++ .../overlay/shaders/overlay_paint_wire_vert.glsl | 31 ++ .../overlay/shaders/overlay_particle_frag.glsl | 23 ++ .../overlay/shaders/overlay_particle_vert.glsl | 53 +++ .../overlay/shaders/overlay_sculpt_mask_frag.glsl | 5 + .../overlay/shaders/overlay_sculpt_mask_vert.glsl | 13 + .../shaders/overlay_volume_gridlines_vert.glsl | 98 ++++++ .../shaders/overlay_volume_velocity_vert.glsl | 191 +++++++++++ .../overlay/shaders/overlay_wireframe_frag.glsl | 44 +++ .../overlay/shaders/overlay_wireframe_vert.glsl | 144 +++++++++ .../overlay/shaders/overlay_xray_fade_frag.glsl | 7 + .../engines/overlay/shaders/paint_face_vert.glsl | 21 -- .../engines/overlay/shaders/paint_point_vert.glsl | 27 -- .../overlay/shaders/paint_texture_frag.glsl | 14 - .../overlay/shaders/paint_texture_vert.glsl | 14 - .../overlay/shaders/paint_vertcol_frag.glsl | 20 -- .../overlay/shaders/paint_vertcol_vert.glsl | 22 -- .../engines/overlay/shaders/paint_weight_frag.glsl | 98 ------ .../engines/overlay/shaders/paint_weight_vert.glsl | 25 -- .../engines/overlay/shaders/paint_wire_vert.glsl | 31 -- .../engines/overlay/shaders/particle_frag.glsl | 23 -- .../engines/overlay/shaders/particle_vert.glsl | 53 --- .../engines/overlay/shaders/sculpt_mask_frag.glsl | 5 - .../engines/overlay/shaders/sculpt_mask_vert.glsl | 13 - .../overlay/shaders/volume_gridlines_vert.glsl | 98 ------ .../overlay/shaders/volume_velocity_vert.glsl | 191 ----------- .../engines/overlay/shaders/wireframe_frag.glsl | 44 --- .../engines/overlay/shaders/wireframe_vert.glsl | 144 --------- .../engines/overlay/shaders/xray_fade_frag.glsl | 7 - 207 files changed, 4845 insertions(+), 4845 deletions(-) delete mode 100644 source/blender/draw/engines/overlay/shaders/antialiasing_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_dof_solid_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_dof_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_envelope_outline_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_envelope_solid_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_envelope_solid_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_shape_outline_geom.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_shape_outline_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_shape_solid_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_shape_solid_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_shape_wire_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_sphere_outline_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_sphere_solid_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_sphere_solid_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_stick_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_stick_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_wire_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/armature_wire_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/background_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/clipbound_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/common_overlay_lib.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/depth_only_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_curve_handle_geom.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_curve_handle_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_curve_point_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_curve_wire_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_gpencil_canvas_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_gpencil_guide_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_lattice_point_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_lattice_wire_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_mesh_analysis_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_mesh_analysis_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_mesh_common_lib.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_mesh_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_mesh_geom.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_mesh_normal_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_mesh_skin_root_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_mesh_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_particle_point_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_particle_strand_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_edges_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_edges_geom.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_edges_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_face_dots_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_faces_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_image_mask_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_image_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_stretching_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_tiled_image_borders_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_verts_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/edit_uv_verts_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/extra_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/extra_groundline_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/extra_lightprobe_grid_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/extra_loose_point_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/extra_loose_point_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/extra_point_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/extra_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/extra_wire_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/extra_wire_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/facing_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/facing_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/grid_background_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/grid_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/grid_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/image_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/image_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/motion_path_line_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/motion_path_line_geom.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/motion_path_line_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/motion_path_point_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/outline_detect_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/outline_prepass_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/outline_prepass_geom.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/outline_prepass_gpencil_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/outline_prepass_gpencil_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/outline_prepass_pointcloud_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/outline_prepass_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_antialiasing_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_dof_solid_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_dof_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_geom.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_shape_wire_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_stick_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_stick_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_wire_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_armature_wire_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_background_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_clipbound_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_common_lib.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_depth_only_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_geom.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_curve_point_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_canvas_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_guide_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_point_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_wire_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_common_lib.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_geom.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_normal_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_particle_point_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_particle_strand_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_geom.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_face_dots_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_faces_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_image_mask_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_image_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_stretching_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_tiled_image_borders_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_verts_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_edit_uv_verts_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_extra_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_extra_groundline_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_extra_lightprobe_grid_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_extra_point_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_extra_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_extra_wire_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_extra_wire_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_facing_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_facing_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_grid_background_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_grid_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_grid_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_image_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_image_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_geom.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_motion_path_point_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_outline_detect_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_geom.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_pointcloud_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_paint_face_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_paint_point_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_paint_texture_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_paint_texture_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_paint_vertcol_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_paint_vertcol_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_paint_weight_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_paint_weight_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_paint_wire_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_particle_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_volume_gridlines_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_volume_velocity_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_wireframe_frag.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl create mode 100644 source/blender/draw/engines/overlay/shaders/overlay_xray_fade_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/paint_face_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/paint_point_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/paint_texture_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/paint_texture_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/paint_vertcol_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/paint_vertcol_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/paint_weight_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/paint_weight_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/paint_wire_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/particle_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/particle_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/sculpt_mask_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/sculpt_mask_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/volume_gridlines_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/volume_velocity_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/wireframe_frag.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/wireframe_vert.glsl delete mode 100644 source/blender/draw/engines/overlay/shaders/xray_fade_frag.glsl (limited to 'source/blender/draw') diff --git a/source/blender/draw/CMakeLists.txt b/source/blender/draw/CMakeLists.txt index d2a89576022..370b3397e8b 100644 --- a/source/blender/draw/CMakeLists.txt +++ b/source/blender/draw/CMakeLists.txt @@ -457,103 +457,103 @@ set(GLSL_SRC engines/basic/shaders/depth_pointcloud_vert.glsl engines/basic/shaders/depth_frag.glsl - engines/overlay/shaders/common_overlay_lib.glsl - engines/overlay/shaders/antialiasing_frag.glsl - engines/overlay/shaders/armature_dof_vert.glsl - engines/overlay/shaders/armature_dof_solid_frag.glsl - engines/overlay/shaders/armature_envelope_outline_vert.glsl - engines/overlay/shaders/armature_envelope_solid_frag.glsl - engines/overlay/shaders/armature_envelope_solid_vert.glsl - engines/overlay/shaders/armature_shape_outline_geom.glsl - engines/overlay/shaders/armature_shape_outline_vert.glsl - engines/overlay/shaders/armature_shape_solid_frag.glsl - engines/overlay/shaders/armature_shape_solid_vert.glsl - engines/overlay/shaders/armature_shape_wire_vert.glsl - engines/overlay/shaders/armature_sphere_outline_vert.glsl - engines/overlay/shaders/armature_sphere_solid_frag.glsl - engines/overlay/shaders/armature_sphere_solid_vert.glsl - engines/overlay/shaders/armature_stick_frag.glsl - engines/overlay/shaders/armature_stick_vert.glsl - engines/overlay/shaders/armature_wire_frag.glsl - engines/overlay/shaders/armature_wire_vert.glsl - engines/overlay/shaders/background_frag.glsl - engines/overlay/shaders/clipbound_vert.glsl - engines/overlay/shaders/depth_only_vert.glsl - engines/overlay/shaders/edit_curve_handle_geom.glsl - engines/overlay/shaders/edit_curve_handle_vert.glsl - engines/overlay/shaders/edit_curve_point_vert.glsl - engines/overlay/shaders/edit_curve_wire_vert.glsl - engines/overlay/shaders/edit_gpencil_canvas_vert.glsl - engines/overlay/shaders/edit_gpencil_guide_vert.glsl - engines/overlay/shaders/edit_gpencil_vert.glsl - engines/overlay/shaders/edit_lattice_point_vert.glsl - engines/overlay/shaders/edit_lattice_wire_vert.glsl - engines/overlay/shaders/edit_mesh_common_lib.glsl - engines/overlay/shaders/edit_mesh_frag.glsl - engines/overlay/shaders/edit_mesh_geom.glsl - engines/overlay/shaders/edit_mesh_normal_vert.glsl - engines/overlay/shaders/edit_mesh_analysis_frag.glsl - engines/overlay/shaders/edit_mesh_analysis_vert.glsl - engines/overlay/shaders/edit_mesh_skin_root_vert.glsl - engines/overlay/shaders/edit_mesh_vert.glsl - engines/overlay/shaders/edit_particle_strand_vert.glsl - engines/overlay/shaders/edit_particle_point_vert.glsl - engines/overlay/shaders/edit_uv_edges_vert.glsl - engines/overlay/shaders/edit_uv_edges_geom.glsl - engines/overlay/shaders/edit_uv_edges_frag.glsl - engines/overlay/shaders/edit_uv_verts_vert.glsl - engines/overlay/shaders/edit_uv_verts_frag.glsl - engines/overlay/shaders/edit_uv_faces_vert.glsl - engines/overlay/shaders/edit_uv_face_dots_vert.glsl - engines/overlay/shaders/edit_uv_image_vert.glsl - engines/overlay/shaders/edit_uv_image_mask_frag.glsl - engines/overlay/shaders/edit_uv_stretching_vert.glsl - engines/overlay/shaders/edit_uv_tiled_image_borders_vert.glsl - engines/overlay/shaders/extra_frag.glsl - engines/overlay/shaders/extra_vert.glsl - engines/overlay/shaders/extra_groundline_vert.glsl - engines/overlay/shaders/extra_lightprobe_grid_vert.glsl - engines/overlay/shaders/extra_loose_point_frag.glsl - engines/overlay/shaders/extra_loose_point_vert.glsl - engines/overlay/shaders/extra_point_vert.glsl - engines/overlay/shaders/extra_wire_frag.glsl - engines/overlay/shaders/extra_wire_vert.glsl - engines/overlay/shaders/facing_frag.glsl - engines/overlay/shaders/facing_vert.glsl - engines/overlay/shaders/grid_background_frag.glsl - engines/overlay/shaders/grid_frag.glsl - engines/overlay/shaders/grid_vert.glsl - engines/overlay/shaders/image_vert.glsl - engines/overlay/shaders/image_frag.glsl - engines/overlay/shaders/motion_path_line_frag.glsl - engines/overlay/shaders/motion_path_line_geom.glsl - engines/overlay/shaders/motion_path_line_vert.glsl - engines/overlay/shaders/motion_path_point_vert.glsl - engines/overlay/shaders/outline_detect_frag.glsl - engines/overlay/shaders/outline_prepass_frag.glsl - engines/overlay/shaders/outline_prepass_gpencil_frag.glsl - engines/overlay/shaders/outline_prepass_geom.glsl - engines/overlay/shaders/outline_prepass_gpencil_vert.glsl - engines/overlay/shaders/outline_prepass_pointcloud_vert.glsl - engines/overlay/shaders/outline_prepass_vert.glsl - engines/overlay/shaders/paint_face_vert.glsl - engines/overlay/shaders/paint_point_vert.glsl - engines/overlay/shaders/paint_texture_frag.glsl - engines/overlay/shaders/paint_texture_vert.glsl - engines/overlay/shaders/paint_vertcol_frag.glsl - engines/overlay/shaders/paint_vertcol_vert.glsl - engines/overlay/shaders/paint_weight_frag.glsl - engines/overlay/shaders/paint_weight_vert.glsl - engines/overlay/shaders/paint_wire_vert.glsl - engines/overlay/shaders/particle_vert.glsl - engines/overlay/shaders/particle_frag.glsl - engines/overlay/shaders/sculpt_mask_vert.glsl - engines/overlay/shaders/sculpt_mask_frag.glsl - engines/overlay/shaders/volume_velocity_vert.glsl - engines/overlay/shaders/volume_gridlines_vert.glsl - engines/overlay/shaders/wireframe_vert.glsl - engines/overlay/shaders/wireframe_frag.glsl - engines/overlay/shaders/xray_fade_frag.glsl + engines/overlay/shaders/overlay_common_lib.glsl + engines/overlay/shaders/overlay_antialiasing_frag.glsl + engines/overlay/shaders/overlay_armature_dof_vert.glsl + engines/overlay/shaders/overlay_armature_dof_solid_frag.glsl + engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl + engines/overlay/shaders/overlay_armature_envelope_solid_frag.glsl + engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl + engines/overlay/shaders/overlay_armature_shape_outline_geom.glsl + engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl + engines/overlay/shaders/overlay_armature_shape_solid_frag.glsl + engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl + engines/overlay/shaders/overlay_armature_shape_wire_vert.glsl + engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl + engines/overlay/shaders/overlay_armature_sphere_solid_frag.glsl + engines/overlay/shaders/overlay_armature_sphere_solid_vert.glsl + engines/overlay/shaders/overlay_armature_stick_frag.glsl + engines/overlay/shaders/overlay_armature_stick_vert.glsl + engines/overlay/shaders/overlay_armature_wire_frag.glsl + engines/overlay/shaders/overlay_armature_wire_vert.glsl + engines/overlay/shaders/overlay_background_frag.glsl + engines/overlay/shaders/overlay_clipbound_vert.glsl + engines/overlay/shaders/overlay_depth_only_vert.glsl + engines/overlay/shaders/overlay_edit_curve_handle_geom.glsl + engines/overlay/shaders/overlay_edit_curve_handle_vert.glsl + engines/overlay/shaders/overlay_edit_curve_point_vert.glsl + engines/overlay/shaders/overlay_edit_curve_wire_vert.glsl + engines/overlay/shaders/overlay_edit_gpencil_canvas_vert.glsl + engines/overlay/shaders/overlay_edit_gpencil_guide_vert.glsl + engines/overlay/shaders/overlay_edit_gpencil_vert.glsl + engines/overlay/shaders/overlay_edit_lattice_point_vert.glsl + engines/overlay/shaders/overlay_edit_lattice_wire_vert.glsl + engines/overlay/shaders/overlay_edit_mesh_common_lib.glsl + engines/overlay/shaders/overlay_edit_mesh_frag.glsl + engines/overlay/shaders/overlay_edit_mesh_geom.glsl + engines/overlay/shaders/overlay_edit_mesh_normal_vert.glsl + engines/overlay/shaders/overlay_edit_mesh_analysis_frag.glsl + engines/overlay/shaders/overlay_edit_mesh_analysis_vert.glsl + engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl + engines/overlay/shaders/overlay_edit_mesh_vert.glsl + engines/overlay/shaders/overlay_edit_particle_strand_vert.glsl + engines/overlay/shaders/overlay_edit_particle_point_vert.glsl + engines/overlay/shaders/overlay_edit_uv_edges_vert.glsl + engines/overlay/shaders/overlay_edit_uv_edges_geom.glsl + engines/overlay/shaders/overlay_edit_uv_edges_frag.glsl + engines/overlay/shaders/overlay_edit_uv_verts_vert.glsl + engines/overlay/shaders/overlay_edit_uv_verts_frag.glsl + engines/overlay/shaders/overlay_edit_uv_faces_vert.glsl + engines/overlay/shaders/overlay_edit_uv_face_dots_vert.glsl + engines/overlay/shaders/overlay_edit_uv_image_vert.glsl + engines/overlay/shaders/overlay_edit_uv_image_mask_frag.glsl + engines/overlay/shaders/overlay_edit_uv_stretching_vert.glsl + engines/overlay/shaders/overlay_edit_uv_tiled_image_borders_vert.glsl + engines/overlay/shaders/overlay_extra_frag.glsl + engines/overlay/shaders/overlay_extra_vert.glsl + engines/overlay/shaders/overlay_extra_groundline_vert.glsl + engines/overlay/shaders/overlay_extra_lightprobe_grid_vert.glsl + engines/overlay/shaders/overlay_extra_loose_point_frag.glsl + engines/overlay/shaders/overlay_extra_loose_point_vert.glsl + engines/overlay/shaders/overlay_extra_point_vert.glsl + engines/overlay/shaders/overlay_extra_wire_frag.glsl + engines/overlay/shaders/overlay_extra_wire_vert.glsl + engines/overlay/shaders/overlay_facing_frag.glsl + engines/overlay/shaders/overlay_facing_vert.glsl + engines/overlay/shaders/overlay_grid_background_frag.glsl + engines/overlay/shaders/overlay_grid_frag.glsl + engines/overlay/shaders/overlay_grid_vert.glsl + engines/overlay/shaders/overlay_image_vert.glsl + engines/overlay/shaders/overlay_image_frag.glsl + engines/overlay/shaders/overlay_motion_path_line_frag.glsl + engines/overlay/shaders/overlay_motion_path_line_geom.glsl + engines/overlay/shaders/overlay_motion_path_line_vert.glsl + engines/overlay/shaders/overlay_motion_path_point_vert.glsl + engines/overlay/shaders/overlay_outline_detect_frag.glsl + engines/overlay/shaders/overlay_outline_prepass_frag.glsl + engines/overlay/shaders/overlay_outline_prepass_gpencil_frag.glsl + engines/overlay/shaders/overlay_outline_prepass_geom.glsl + engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl + engines/overlay/shaders/overlay_outline_prepass_pointcloud_vert.glsl + engines/overlay/shaders/overlay_outline_prepass_vert.glsl + engines/overlay/shaders/overlay_paint_face_vert.glsl + engines/overlay/shaders/overlay_paint_point_vert.glsl + engines/overlay/shaders/overlay_paint_texture_frag.glsl + engines/overlay/shaders/overlay_paint_texture_vert.glsl + engines/overlay/shaders/overlay_paint_vertcol_frag.glsl + engines/overlay/shaders/overlay_paint_vertcol_vert.glsl + engines/overlay/shaders/overlay_paint_weight_frag.glsl + engines/overlay/shaders/overlay_paint_weight_vert.glsl + engines/overlay/shaders/overlay_paint_wire_vert.glsl + engines/overlay/shaders/overlay_particle_vert.glsl + engines/overlay/shaders/overlay_particle_frag.glsl + engines/overlay/shaders/overlay_sculpt_mask_vert.glsl + engines/overlay/shaders/overlay_sculpt_mask_frag.glsl + engines/overlay/shaders/overlay_volume_velocity_vert.glsl + engines/overlay/shaders/overlay_volume_gridlines_vert.glsl + engines/overlay/shaders/overlay_wireframe_vert.glsl + engines/overlay/shaders/overlay_wireframe_frag.glsl + engines/overlay/shaders/overlay_xray_fade_frag.glsl engines/overlay/overlay_shader_shared.h diff --git a/source/blender/draw/engines/overlay/shaders/antialiasing_frag.glsl b/source/blender/draw/engines/overlay/shaders/antialiasing_frag.glsl deleted file mode 100644 index f28a809fdab..00000000000 --- a/source/blender/draw/engines/overlay/shaders/antialiasing_frag.glsl +++ /dev/null @@ -1,146 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_math_lib.glsl) - -#define M_1_SQRTPI 0.5641895835477563 /* 1/sqrt(pi) */ - -/** - * 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. - */ -#define DISC_RADIUS (M_1_SQRTPI * 1.05) -#define LINE_SMOOTH_START (0.5 - DISC_RADIUS) -#define LINE_SMOOTH_END (0.5 + DISC_RADIUS) - -/** - * Returns coverage of a line onto a sample that is distance_to_line (in pixels) far from the line. - * line_kernel_size is the inner size of the line with 100% coverage. - */ -float line_coverage(float distance_to_line, float line_kernel_size) -{ - if (doSmoothLines) { - return smoothstep( - LINE_SMOOTH_END, LINE_SMOOTH_START, abs(distance_to_line) - line_kernel_size); - } - else { - return step(-0.5, line_kernel_size - abs(distance_to_line)); - } -} -vec4 line_coverage(vec4 distance_to_line, float line_kernel_size) -{ - if (doSmoothLines) { - return smoothstep( - LINE_SMOOTH_END, LINE_SMOOTH_START, abs(distance_to_line) - line_kernel_size); - } - else { - return step(-0.5, line_kernel_size - abs(distance_to_line)); - } -} - -vec2 decode_line_dir(vec2 dir) -{ - return dir * 2.0 - 1.0; -} - -float decode_line_dist(float dist) -{ - return (dist - 0.1) * 4.0 - 2.0; -} - -float neighbor_dist(vec3 line_dir_and_dist, vec2 ofs) -{ - float dist = decode_line_dist(line_dir_and_dist.z); - vec2 dir = decode_line_dir(line_dir_and_dist.xy); - - bool is_line = line_dir_and_dist.z != 0.0; - bool dir_horiz = abs(dir.x) > abs(dir.y); - bool ofs_horiz = (ofs.x != 0); - - if (!is_line || (ofs_horiz != dir_horiz)) { - dist += 1e10; /* No line. */ - } - else { - dist += dot(ofs, -dir); - } - return dist; -} - -void neighbor_blend( - float line_coverage, float line_depth, vec4 line_color, inout float frag_depth, inout vec4 col) -{ - line_color *= line_coverage; - if (line_coverage > 0.0 && line_depth < frag_depth) { - /* Alpha over. */ - col = col * (1.0 - line_color.a) + line_color; - frag_depth = line_depth; - } - else { - /* Alpha under. */ - col = col + line_color * (1.0 - col.a); - } -} - -void main() -{ - ivec2 center_texel = ivec2(gl_FragCoord.xy); - float line_kernel = sizePixel * 0.5 - 0.5; - - fragColor = texelFetch(colorTex, center_texel, 0); - - bool original_col_has_alpha = fragColor.a < 1.0; - - float depth = texelFetch(depthTex, center_texel, 0).r; - - float dist_raw = texelFetch(lineTex, center_texel, 0).b; - float dist = decode_line_dist(dist_raw); - - /* TODO: Opti: use textureGather. */ - vec4 neightbor_col0 = texelFetchOffset(colorTex, center_texel, 0, ivec2(1, 0)); - vec4 neightbor_col1 = texelFetchOffset(colorTex, center_texel, 0, ivec2(-1, 0)); - vec4 neightbor_col2 = texelFetchOffset(colorTex, center_texel, 0, ivec2(0, 1)); - vec4 neightbor_col3 = texelFetchOffset(colorTex, center_texel, 0, ivec2(0, -1)); - - vec3 neightbor_line0 = texelFetchOffset(lineTex, center_texel, 0, ivec2(1, 0)).rgb; - vec3 neightbor_line1 = texelFetchOffset(lineTex, center_texel, 0, ivec2(-1, 0)).rgb; - vec3 neightbor_line2 = texelFetchOffset(lineTex, center_texel, 0, ivec2(0, 1)).rgb; - vec3 neightbor_line3 = texelFetchOffset(lineTex, center_texel, 0, ivec2(0, -1)).rgb; - - vec4 depths; - depths.x = texelFetchOffset(depthTex, center_texel, 0, ivec2(1, 0)).r; - depths.y = texelFetchOffset(depthTex, center_texel, 0, ivec2(-1, 0)).r; - depths.z = texelFetchOffset(depthTex, center_texel, 0, ivec2(0, 1)).r; - depths.w = texelFetchOffset(depthTex, center_texel, 0, ivec2(0, -1)).r; - - vec4 line_dists; - line_dists.x = neighbor_dist(neightbor_line0, vec2(1, 0)); - line_dists.y = neighbor_dist(neightbor_line1, vec2(-1, 0)); - line_dists.z = neighbor_dist(neightbor_line2, vec2(0, 1)); - line_dists.w = neighbor_dist(neightbor_line3, vec2(0, -1)); - - vec4 coverage = line_coverage(line_dists, line_kernel); - - if (dist_raw > 0.0) { - fragColor *= line_coverage(dist, line_kernel); - } - - /* We don't order fragments but use alpha over/alpha under based on current minimum frag depth. - */ - neighbor_blend(coverage.x, depths.x, neightbor_col0, depth, fragColor); - neighbor_blend(coverage.y, depths.y, neightbor_col1, depth, fragColor); - neighbor_blend(coverage.z, depths.z, neightbor_col2, depth, fragColor); - neighbor_blend(coverage.w, depths.w, neightbor_col3, depth, fragColor); - -#if 1 - /* Fix aliasing issue with really dense meshes and 1 pixel sized lines. */ - if (!original_col_has_alpha && dist_raw > 0.0 && line_kernel < 0.45) { - vec4 lines = vec4(neightbor_line0.z, neightbor_line1.z, neightbor_line2.z, neightbor_line3.z); - /* Count number of line neighbors. */ - float blend = dot(vec4(0.25), step(0.001, lines)); - /* Only do blend if there are more than 2 neighbors. This avoids losing too much AA. */ - blend = clamp(blend * 2.0 - 1.0, 0.0, 1.0); - fragColor = mix(fragColor, fragColor / fragColor.a, blend); - } -#endif -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_dof_solid_frag.glsl b/source/blender/draw/engines/overlay/shaders/armature_dof_solid_frag.glsl deleted file mode 100644 index d46abbf79ee..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_dof_solid_frag.glsl +++ /dev/null @@ -1,6 +0,0 @@ - -void main() -{ - fragColor = vec4(finalColor.rgb, finalColor.a * alpha); - lineOutput = vec4(0.0); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_dof_vert.glsl b/source/blender/draw/engines/overlay/shaders/armature_dof_vert.glsl deleted file mode 100644 index b3c9ce5dfd2..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_dof_vert.glsl +++ /dev/null @@ -1,32 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -vec3 sphere_project(float ax, float az) -{ - float sine = 1.0 - ax * ax - az * az; - float q3 = sqrt(max(0.0, sine)); - - return vec3(-az * q3, 0.5 - sine, ax * q3) * 2.0; -} - -void main() -{ - mat4 model_mat = inst_obmat; - model_mat[0][3] = model_mat[1][3] = model_mat[2][3] = 0.0; - model_mat[3][3] = 1.0; - - vec2 amin = vec2(inst_obmat[0][3], inst_obmat[1][3]); - vec2 amax = vec2(inst_obmat[2][3], inst_obmat[3][3]); - - vec3 final_pos = sphere_project(pos.x * abs((pos.x > 0.0) ? amax.x : amin.x), - pos.y * abs((pos.y > 0.0) ? amax.y : amin.y)); - - vec3 world_pos = (model_mat * vec4(final_pos, 1.0)).xyz; - gl_Position = point_world_to_ndc(world_pos); - finalColor = color; - - edgeStart = edgePos = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_envelope_outline_vert.glsl b/source/blender/draw/engines/overlay/shaders/armature_envelope_outline_vert.glsl deleted file mode 100644 index 0a8e279e9b0..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_envelope_outline_vert.glsl +++ /dev/null @@ -1,145 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -/* project to screen space */ -vec2 proj(vec4 pos) -{ - return (0.5 * (pos.xy / pos.w) + 0.5) * sizeViewport.xy; -} - -vec2 compute_dir(vec2 v0, vec2 v1, vec2 v2) -{ - vec2 dir = normalize(v2 - v0); - dir = vec2(dir.y, -dir.x); - return dir; -} - -mat3 compute_mat(vec4 sphere, vec3 bone_vec, out float z_ofs) -{ - bool is_persp = (ProjectionMatrix[3][3] == 0.0); - vec3 cam_ray = (is_persp) ? sphere.xyz - ViewMatrixInverse[3].xyz : -ViewMatrixInverse[2].xyz; - - /* Sphere center distance from the camera (persp) in world space. */ - float cam_dist = length(cam_ray); - - /* Compute view aligned orthonormal space. */ - vec3 z_axis = cam_ray / cam_dist; - vec3 x_axis = normalize(cross(bone_vec, z_axis)); - vec3 y_axis = cross(z_axis, x_axis); - z_ofs = 0.0; - - if (is_persp) { - /* For perspective, the projected sphere radius - * can be bigger than the center disc. Compute the - * max angular size and compensate by sliding the disc - * towards the camera and scale it accordingly. */ - const float half_pi = 3.1415926 * 0.5; - float rad = sphere.w; - /* Let be : - * V the view vector origin. - * O the sphere origin. - * T the point on the target circle. - * We compute the angle between (OV) and (OT). */ - float a = half_pi - asin(rad / cam_dist); - float cos_b = cos(a); - float sin_b = sqrt(clamp(1.0 - cos_b * cos_b, 0.0, 1.0)); - - x_axis *= sin_b; - y_axis *= sin_b; - z_ofs = -rad * cos_b; - } - - return mat3(x_axis, y_axis, z_axis); -} - -struct Bone { - vec3 vec; - float sinb; -}; - -bool bone_blend_starts(vec3 p, Bone b) -{ - /* we just want to know when the head sphere starts interpolating. */ - return dot(p, b.vec) > -b.sinb; -} - -vec3 get_outline_point(vec2 pos, - vec4 sph_near, - vec4 sph_far, - mat3 mat_near, - mat3 mat_far, - float z_ofs_near, - float z_ofs_far, - Bone b) -{ - /* Compute outline position on the nearest sphere and check - * if it penetrates the capsule body. If it does, put this - * vertex on the farthest sphere. */ - vec3 wpos = mat_near * vec3(pos * sph_near.w, z_ofs_near); - if (bone_blend_starts(wpos, b)) { - wpos = sph_far.xyz + mat_far * vec3(pos * sph_far.w, z_ofs_far); - } - else { - wpos += sph_near.xyz; - } - return wpos; -} - -void main() -{ - float dst_head = distance(headSphere.xyz, ViewMatrixInverse[3].xyz); - float dst_tail = distance(tailSphere.xyz, ViewMatrixInverse[3].xyz); - // float dst_head = -dot(headSphere.xyz, ViewMatrix[2].xyz); - // float dst_tail = -dot(tailSphere.xyz, ViewMatrix[2].xyz); - - vec4 sph_near, sph_far; - if ((dst_head > dst_tail) && (ProjectionMatrix[3][3] == 0.0)) { - sph_near = tailSphere; - sph_far = headSphere; - } - else { - sph_near = headSphere; - sph_far = tailSphere; - } - - vec3 bone_vec = (sph_far.xyz - sph_near.xyz) + 1e-8; - - Bone b; - float bone_lenrcp = 1.0 / max(1e-8, sqrt(dot(bone_vec, bone_vec))); - b.sinb = (sph_far.w - sph_near.w) * bone_lenrcp * sph_near.w; - b.vec = bone_vec * bone_lenrcp; - - float z_ofs_near, z_ofs_far; - mat3 mat_near = compute_mat(sph_near, bone_vec, z_ofs_near); - mat3 mat_far = compute_mat(sph_far, bone_vec, z_ofs_far); - - vec3 wpos0 = get_outline_point( - pos0, sph_near, sph_far, mat_near, mat_far, z_ofs_near, z_ofs_far, b); - vec3 wpos1 = get_outline_point( - pos1, sph_near, sph_far, mat_near, mat_far, z_ofs_near, z_ofs_far, b); - vec3 wpos2 = get_outline_point( - pos2, sph_near, sph_far, mat_near, mat_far, z_ofs_near, z_ofs_far, b); - - view_clipping_distances(wpos1); - - vec4 p0 = point_world_to_ndc(wpos0); - vec4 p1 = point_world_to_ndc(wpos1); - vec4 p2 = point_world_to_ndc(wpos2); - - gl_Position = p1; - - /* compute position from 3 vertex because the change in direction - * can happen very quicky and lead to very thin edges. */ - vec2 ss0 = proj(p0); - vec2 ss1 = proj(p1); - vec2 ss2 = proj(p2); - 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; - - edgeStart = edgePos = proj(gl_Position); - - finalColor = vec4(outlineColorSize.rgb, 1.0); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_envelope_solid_frag.glsl b/source/blender/draw/engines/overlay/shaders/armature_envelope_solid_frag.glsl deleted file mode 100644 index a90d2e3e406..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_envelope_solid_frag.glsl +++ /dev/null @@ -1,17 +0,0 @@ - -void main() -{ - float n = normalize(normalView).z; - if (isDistance) { - n = 1.0 - clamp(-n, 0.0, 1.0); - fragColor = vec4(1.0, 1.0, 1.0, 0.33 * alpha) * n; - } - else { - /* Smooth lighting factor. */ - const float s = 0.2; /* [0.0-0.5] range */ - float fac = clamp((n * (1.0 - s)) + s, 0.0, 1.0); - fragColor.rgb = mix(finalStateColor, finalBoneColor, fac * fac); - fragColor.a = alpha; - } - lineOutput = vec4(0.0); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_envelope_solid_vert.glsl b/source/blender/draw/engines/overlay/shaders/armature_envelope_solid_vert.glsl deleted file mode 100644 index 2dd86a57dfd..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_envelope_solid_vert.glsl +++ /dev/null @@ -1,42 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - vec3 bone_vec = tailSphere.xyz - headSphere.xyz; - float bone_len = max(1e-8, sqrt(dot(bone_vec, bone_vec))); - float bone_lenrcp = 1.0 / bone_len; -#ifdef SMOOTH_ENVELOPE - float sinb = (tailSphere.w - headSphere.w) * bone_lenrcp; -#else - const float sinb = 0.0; -#endif - - vec3 y_axis = bone_vec * bone_lenrcp; - vec3 z_axis = normalize(cross(xAxis, -y_axis)); - vec3 x_axis = cross(y_axis, z_axis); /* cannot trust xAxis to be orthogonal. */ - - vec3 sp, nor; - nor = sp = pos.xyz; - - /* In bone space */ - bool is_head = (pos.z < -sinb); - sp *= (is_head) ? headSphere.w : tailSphere.w; - sp.z += (is_head) ? 0.0 : bone_len; - - /* Convert to world space */ - mat3 bone_mat = mat3(x_axis, y_axis, z_axis); - sp = bone_mat * sp.xzy + headSphere.xyz; - nor = bone_mat * nor.xzy; - - normalView = mat3(ViewMatrix) * nor; - - finalStateColor = stateColor; - finalBoneColor = boneColor; - - view_clipping_distances(sp); - - vec4 pos_4d = vec4(sp, 1.0); - gl_Position = ViewProjectionMatrix * pos_4d; -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_shape_outline_geom.glsl b/source/blender/draw/engines/overlay/shaders/armature_shape_outline_geom.glsl deleted file mode 100644 index 47c5dada708..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_shape_outline_geom.glsl +++ /dev/null @@ -1,76 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) - -void main(void) -{ - finalColor = vec4(geom_in[0].vColSize.rgb, 1.0); - - bool is_persp = (ProjectionMatrix[3][3] == 0.0); - - vec3 view_vec = (is_persp) ? normalize(geom_in[1].vPos) : vec3(0.0, 0.0, -1.0); - vec3 v10 = geom_in[0].vPos - geom_in[1].vPos; - vec3 v12 = geom_in[2].vPos - geom_in[1].vPos; - vec3 v13 = geom_in[3].vPos - geom_in[1].vPos; - - 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)) { - return; - } - } - - n0 = (geom_in[0].inverted == 1) ? -n0 : n0; - /* Don't outline if concave edge. */ - if (dot(n0, v13) > 0.0001) { - return; - } - - vec2 perp = normalize(geom_in[2].ssPos - geom_in[1].ssPos); - 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 (geom_in[0].vPos.z < geom_in[3].vPos.z) { - hidden_point = (abs(fac0) > 1e-5) ? geom_in[0].ssPos : geom_in[3].ssPos; - } - else { - hidden_point = (abs(fac3) > 1e-5) ? geom_in[3].ssPos : geom_in[0].ssPos; - } - vec2 hidden_dir = normalize(hidden_point - geom_in[1].ssPos); - - float fac = dot(-hidden_dir, edge_dir); - edge_dir *= (fac < 0.0) ? -1.0 : 1.0; - - 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; - /* 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; - view_clipping_distances_set(gl_in[1]); - EmitVertex(); - - 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; - /* 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_set(gl_in[2]); - EmitVertex(); - - EndPrimitive(); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_shape_outline_vert.glsl b/source/blender/draw/engines/overlay/shaders/armature_shape_outline_vert.glsl deleted file mode 100644 index 29319b3f7ac..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_shape_outline_vert.glsl +++ /dev/null @@ -1,37 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -/* project to screen space */ -vec2 proj(vec4 pos) -{ - return (0.5 * (pos.xy / pos.w) + 0.5) * sizeViewport.xy; -} - -void main() -{ - vec4 bone_color, state_color; - mat4 model_mat = extract_matrix_packed_data(inst_obmat, state_color, bone_color); - - vec4 world_pos = model_mat * vec4(pos, 1.0); - vec4 view_pos = ViewMatrix * world_pos; - - geom_in.vPos = view_pos.xyz; - geom_in.pPos = ProjectionMatrix * view_pos; - - geom_in.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. */ - geom_in.ssNor = normalize(normal_world_to_view(normal_mat * snor).xy); - - geom_in.ssPos = proj(geom_in.pPos); - - geom_in.vColSize = bone_color; - - view_clipping_distances(world_pos.xyz); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_shape_solid_frag.glsl b/source/blender/draw/engines/overlay/shaders/armature_shape_solid_frag.glsl deleted file mode 100644 index 8e1768846dc..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_shape_solid_frag.glsl +++ /dev/null @@ -1,12 +0,0 @@ - -void main() -{ - /* Manual back-face culling. Not ideal for performance - * but needed for view clarity in X-ray mode and support - * for inverted bone matrices. */ - if ((inverted == 1) == gl_FrontFacing) { - discard; - } - fragColor = vec4(finalColor.rgb, alpha); - lineOutput = vec4(0.0); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_shape_solid_vert.glsl b/source/blender/draw/engines/overlay/shaders/armature_shape_solid_vert.glsl deleted file mode 100644 index cdbe8c3d7df..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_shape_solid_vert.glsl +++ /dev/null @@ -1,31 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - vec4 bone_color, state_color; - mat4 model_mat = extract_matrix_packed_data(inst_obmat, state_color, bone_color); - - /* 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))); - vec3 normal = normalize(normal_world_to_view(normal_mat * nor)); - - inverted = int(dot(cross(model_mat[0].xyz, model_mat[1].xyz), model_mat[2].xyz) < 0.0); - - /* Do lighting at an angle to avoid flat shading on front facing bone. */ - const vec3 light = vec3(0.1, 0.1, 0.8); - float n = dot(normal, light); - - /* Smooth lighting factor. */ - const float s = 0.2; /* [0.0-0.5] range */ - float fac = clamp((n * (1.0 - s)) + s, 0.0, 1.0); - finalColor.rgb = mix(state_color.rgb, bone_color.rgb, fac * fac); - finalColor.a = 1.0; - - vec4 world_pos = model_mat * vec4(pos, 1.0); - gl_Position = ViewProjectionMatrix * world_pos; - - view_clipping_distances(world_pos.xyz); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_shape_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/armature_shape_wire_vert.glsl deleted file mode 100644 index cee86956c43..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_shape_wire_vert.glsl +++ /dev/null @@ -1,19 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - vec4 bone_color, state_color; - mat4 model_mat = extract_matrix_packed_data(inst_obmat, state_color, bone_color); - - vec3 world_pos = (model_mat * vec4(pos, 1.0)).xyz; - gl_Position = point_world_to_ndc(world_pos); - - finalColor.rgb = mix(state_color.rgb, bone_color.rgb, 0.5); - finalColor.a = 1.0; - - edgeStart = edgePos = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_sphere_outline_vert.glsl b/source/blender/draw/engines/overlay/shaders/armature_sphere_outline_vert.glsl deleted file mode 100644 index 31369e0c3df..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_sphere_outline_vert.glsl +++ /dev/null @@ -1,74 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -/* project to screen space */ -vec2 proj(vec4 pos) -{ - return (0.5 * (pos.xy / pos.w) + 0.5) * sizeViewport.xy; -} - -void main() -{ - vec4 bone_color, state_color; - mat4 model_mat = extract_matrix_packed_data(inst_obmat, state_color, bone_color); - - mat4 model_view_matrix = ViewMatrix * model_mat; - mat4 sphereMatrix = inverse(model_view_matrix); - - bool is_persp = (ProjectionMatrix[3][3] == 0.0); - - /* This is the local space camera ray (not normalize). - * In perspective mode it's also the viewspace position - * of the sphere center. */ - vec3 cam_ray = (is_persp) ? model_view_matrix[3].xyz : vec3(0.0, 0.0, -1.0); - cam_ray = mat3(sphereMatrix) * cam_ray; - - /* Sphere center distance from the camera (persp) in local space. */ - float cam_dist = length(cam_ray); - - /* Compute view aligned orthonormal space. */ - vec3 z_axis = cam_ray / cam_dist; - vec3 x_axis = normalize(cross(sphereMatrix[1].xyz, z_axis)); - vec3 y_axis = cross(z_axis, x_axis); - float z_ofs = 0.0; - - if (is_persp) { - /* For perspective, the projected sphere radius - * can be bigger than the center disc. Compute the - * max angular size and compensate by sliding the disc - * towards the camera and scale it accordingly. */ - const float half_pi = 3.1415926 * 0.5; - const float rad = 0.05; - /* Let be (in local space): - * V the view vector origin. - * O the sphere origin. - * T the point on the target circle. - * We compute the angle between (OV) and (OT). */ - float a = half_pi - asin(rad / cam_dist); - float cos_b = cos(a); - float sin_b = sqrt(clamp(1.0 - cos_b * cos_b, 0.0, 1.0)); - - x_axis *= sin_b; - y_axis *= sin_b; - z_ofs = -rad * cos_b; - } - - /* Camera oriented position (but still in local space) */ - vec3 cam_pos0 = x_axis * pos.x + y_axis * pos.y + z_axis * z_ofs; - - vec4 V = model_view_matrix * vec4(cam_pos0, 1.0); - gl_Position = ProjectionMatrix * V; - vec4 center = ProjectionMatrix * vec4(model_view_matrix[3].xyz, 1.0); - - /* 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; - - edgeStart = edgePos = proj(gl_Position); - - finalColor = vec4(bone_color.rgb, 1.0); - - vec4 world_pos = model_mat * vec4(cam_pos0, 1.0); - view_clipping_distances(world_pos.xyz); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_sphere_solid_frag.glsl b/source/blender/draw/engines/overlay/shaders/armature_sphere_solid_frag.glsl deleted file mode 100644 index e60b6e94492..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_sphere_solid_frag.glsl +++ /dev/null @@ -1,52 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - const float sphere_radius = 0.05; - - bool is_perp = (ProjectionMatrix[3][3] == 0.0); - vec3 ray_ori_view = (is_perp) ? vec3(0.0) : viewPosition.xyz; - vec3 ray_dir_view = (is_perp) ? viewPosition : vec3(0.0, 0.0, -1.0); - - /* Single matrix mul without branch. */ - vec4 mul_vec = (is_perp) ? vec4(ray_dir_view, 0.0) : vec4(ray_ori_view, 1.0); - vec3 mul_res = (sphereMatrix * mul_vec).xyz; - - /* Reminder : - * sphereMatrix[3] is the view space origin in sphere space (sph_ori -> view_ori). - * sphereMatrix[2] is the view space Z axis in sphere space. */ - - /* convert to sphere local space */ - vec3 ray_ori = (is_perp) ? sphereMatrix[3].xyz : mul_res; - vec3 ray_dir = (is_perp) ? mul_res : -sphereMatrix[2].xyz; - float ray_len = length(ray_dir); - ray_dir /= ray_len; - - /* Line to sphere intersect */ - const float sphere_radius_sqr = sphere_radius * sphere_radius; - float b = dot(ray_ori, ray_dir); - float c = dot(ray_ori, ray_ori) - sphere_radius_sqr; - float h = b * b - c; - float t = -sqrt(max(0.0, h)) - b; - - /* Compute dot product for lighting */ - vec3 p = ray_dir * t + ray_ori; /* Point on sphere */ - vec3 n = normalize(p); /* Normal is just the point in sphere space, normalized. */ - vec3 l = normalize(sphereMatrix[2].xyz); /* Just the view Z axis in the sphere space. */ - - /* Smooth lighting factor. */ - const float s = 0.2; /* [0.0-0.5] range */ - float fac = clamp((dot(n, l) * (1.0 - s)) + s, 0.0, 1.0); - fragColor.rgb = mix(finalStateColor, finalBoneColor, fac * fac); - - /* 2x2 dither pattern to smooth the lighting. */ - float dither = (0.5 + dot(vec2(ivec2(gl_FragCoord.xy) & ivec2(1)), vec2(1.0, 2.0))) * 0.25; - dither *= (1.0 / 255.0); /* Assume 8bit per color buffer. */ - - fragColor = vec4(fragColor.rgb + dither, alpha); - lineOutput = vec4(0.0); - - t /= ray_len; - gl_FragDepth = get_depth_from_view_z(ray_dir_view.z * t + ray_ori_view.z); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_sphere_solid_vert.glsl b/source/blender/draw/engines/overlay/shaders/armature_sphere_solid_vert.glsl deleted file mode 100644 index abbaad8cd10..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_sphere_solid_vert.glsl +++ /dev/null @@ -1,76 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -/* Sphere radius */ -const float rad = 0.05; - -void main() -{ - vec4 bone_color, state_color; - mat4 model_mat = extract_matrix_packed_data(inst_obmat, state_color, bone_color); - - mat4 model_view_matrix = ViewMatrix * model_mat; - sphereMatrix = inverse(model_view_matrix); - - bool is_persp = (ProjectionMatrix[3][3] == 0.0); - - /* This is the local space camera ray (not normalize). - * In perspective mode it's also the viewspace position - * of the sphere center. */ - vec3 cam_ray = (is_persp) ? model_view_matrix[3].xyz : vec3(0.0, 0.0, -1.0); - cam_ray = mat3(sphereMatrix) * cam_ray; - - /* Sphere center distance from the camera (persp) in local space. */ - float cam_dist = length(cam_ray); - - /* Compute view aligned orthonormal space. */ - vec3 z_axis = cam_ray / cam_dist; - vec3 x_axis = normalize(cross(sphereMatrix[1].xyz, z_axis)); - vec3 y_axis = cross(z_axis, x_axis); - - float z_ofs = -rad - 1e-8; /* offset to the front of the sphere */ - if (is_persp) { - /* For perspective, the projected sphere radius - * can be bigger than the center disc. Compute the - * max angular size and compensate by sliding the disc - * towards the camera and scale it accordingly. */ - const float half_pi = 3.1415926 * 0.5; - /* Let be (in local space): - * V the view vector origin. - * O the sphere origin. - * T the point on the target circle. - * We compute the angle between (OV) and (OT). */ - float a = half_pi - asin(rad / cam_dist); - float cos_b = cos(a); - float sin_b = sqrt(clamp(1.0 - cos_b * cos_b, 0.0, 1.0)); -#if 1 - /* Instead of choosing the biggest circle in screenspace, - * we choose the nearest with the same angular size. This - * permit us to leverage GL_ARB_conservative_depth in the - * fragment shader. */ - float minor = cam_dist - rad; - float major = cam_dist - cos_b * rad; - float fac = minor / major; - sin_b *= fac; -#else - z_ofs = -rad * cos_b; -#endif - x_axis *= sin_b; - y_axis *= sin_b; - } - - /* Camera oriented position (but still in local space) */ - vec3 cam_pos = x_axis * pos.x + y_axis * pos.y + z_axis * z_ofs; - - vec4 pos_4d = vec4(cam_pos, 1.0); - vec4 V = model_view_matrix * pos_4d; - gl_Position = ProjectionMatrix * V; - viewPosition = V.xyz; - - finalStateColor = state_color.xyz; - finalBoneColor = bone_color.xyz; - - vec4 world_pos = model_mat * pos_4d; - view_clipping_distances(world_pos.xyz); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_stick_frag.glsl b/source/blender/draw/engines/overlay/shaders/armature_stick_frag.glsl deleted file mode 100644 index 2e42cdf0517..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_stick_frag.glsl +++ /dev/null @@ -1,8 +0,0 @@ - -void main() -{ - float fac = smoothstep(1.0, 0.2, colorFac); - fragColor.rgb = mix(finalInnerColor.rgb, finalWireColor.rgb, fac); - fragColor.a = alpha; - lineOutput = vec4(0.0); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_stick_vert.glsl b/source/blender/draw/engines/overlay/shaders/armature_stick_vert.glsl deleted file mode 100644 index b5edcd2858b..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_stick_vert.glsl +++ /dev/null @@ -1,74 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -/* TODO(@fclem): Share definition with C code. */ -#define COL_WIRE 1u /* (1 << 0) */ -#define COL_HEAD 2u /* (1 << 1) */ -#define COL_TAIL 4u /* (1 << 2) */ -#define COL_BONE 8u /* (1 << 3) */ - -#define POS_HEAD 16u /* (1 << 4) */ -#define POS_TAIL 32u /* (1 << 5) */ /* UNUSED */ -#define POS_BONE 64u /* (1 << 6) */ - -#define is_head bool(flag & POS_HEAD) -#define is_bone bool(flag & POS_BONE) - -/* project to screen space */ -vec2 proj(vec4 pos) -{ - return (0.5 * (pos.xy / pos.w) + 0.5) * sizeViewport.xy; -} - -void main() -{ - finalInnerColor = ((flag & COL_HEAD) != 0u) ? headColor : tailColor; - finalInnerColor = ((flag & COL_BONE) != 0u) ? boneColor : finalInnerColor; - finalWireColor = (do_wire) ? wireColor : finalInnerColor; - /* Make the color */ - colorFac = ((flag & COL_WIRE) == 0u) ? ((flag & COL_BONE) != 0u) ? 1.0 : 2.0 : 0.0; - - vec4 boneStart_4d = vec4(boneStart, 1.0); - vec4 boneEnd_4d = vec4(boneEnd, 1.0); - vec4 v0 = ViewMatrix * boneStart_4d; - vec4 v1 = ViewMatrix * boneEnd_4d; - - /* Clip the bone to the camera origin plane (not the clip plane) - * to avoid glitches if one end is behind the camera origin (in persp). */ - float clip_dist = (ProjectionMatrix[3][3] == 0.0) ? - -1e-7 : - 1e20; /* hardcoded, -1e-8 is giving gliches. */ - vec3 bvec = v1.xyz - v0.xyz; - vec3 clip_pt = v0.xyz + bvec * ((v0.z - clip_dist) / -bvec.z); - if (v0.z > clip_dist) { - v0.xyz = clip_pt; - } - else if (v1.z > clip_dist) { - v1.xyz = clip_pt; - } - - vec4 p0 = ProjectionMatrix * v0; - vec4 p1 = ProjectionMatrix * v1; - - float h = (is_head) ? p0.w : p1.w; - - vec2 x_screen_vec = normalize(proj(p1) - proj(p0) + 1e-8); - vec2 y_screen_vec = vec2(x_screen_vec.y, -x_screen_vec.x); - - /* 2D screen aligned pos at the point */ - vec2 vpos = pos.x * x_screen_vec + pos.y * y_screen_vec; - vpos *= (ProjectionMatrix[3][3] == 0.0) ? h : 1.0; - vpos *= (do_wire) ? 1.0 : 0.5; - - 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.z += (is_bone) ? 0.0 : 1e-6; /* Avoid Z fighting of head/tails. */ - view_clipping_distances((is_head ? boneStart_4d : boneEnd_4d).xyz); - } - else { - gl_Position = vec4(0.0); - } -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_wire_frag.glsl b/source/blender/draw/engines/overlay/shaders/armature_wire_frag.glsl deleted file mode 100644 index 2c454a8becd..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_wire_frag.glsl +++ /dev/null @@ -1,8 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - lineOutput = pack_line_data(gl_FragCoord.xy, edgeStart, edgePos); - fragColor = vec4(finalColor.rgb, finalColor.a * alpha); -} diff --git a/source/blender/draw/engines/overlay/shaders/armature_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/armature_wire_vert.glsl deleted file mode 100644 index c89d0249e4f..00000000000 --- a/source/blender/draw/engines/overlay/shaders/armature_wire_vert.glsl +++ /dev/null @@ -1,16 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - finalColor.rgb = color.rgb; - finalColor.a = 1.0; - - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); - - edgeStart = edgePos = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/background_frag.glsl b/source/blender/draw/engines/overlay/shaders/background_frag.glsl deleted file mode 100644 index b25dcae9fca..00000000000 --- a/source/blender/draw/engines/overlay/shaders/background_frag.glsl +++ /dev/null @@ -1,86 +0,0 @@ - - -#pragma BLENDER_REQUIRE(common_math_lib.glsl) - -/* 4x4 bayer matrix prepared for 8bit UNORM precision error. */ -#define P(x) (((x + 0.5) * (1.0 / 16.0) - 0.5) * (1.0 / 255.0)) -const vec4 dither_mat4x4[4] = vec4[4](vec4(P(0.0), P(8.0), P(2.0), P(10.0)), - vec4(P(12.0), P(4.0), P(14.0), P(6.0)), - vec4(P(3.0), P(11.0), P(1.0), P(9.0)), - vec4(P(15.0), P(7.0), P(13.0), P(5.0))); - -float dither(void) -{ - ivec2 co = ivec2(gl_FragCoord.xy) % 4; - return dither_mat4x4[co.x][co.y]; -} - -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 - * This removes the alpha channel and put the background behind reference images - * while masking the reference images by the render alpha. - */ - float alpha = texture(colorBuffer, uvcoordsvar.xy).a; - float depth = texture(depthBuffer, uvcoordsvar.xy).r; - - vec3 bg_col; - vec3 col_high; - vec3 col_low; - - /* BG_SOLID_CHECKER selects BG_SOLID when no pixel has been drawn otherwise use the BG_CHERKER. - */ - int bg_type = bgType == BG_SOLID_CHECKER ? (depth == 1.0 ? BG_SOLID : BG_CHECKER) : bgType; - - switch (bg_type) { - case BG_SOLID: - bg_col = colorBackground.rgb; - break; - case BG_GRADIENT: - /* XXX do interpolation in a non-linear space to have a better visual result. */ - col_high = pow(colorBackground.rgb, vec3(1.0 / 2.2)); - col_low = pow(colorBackgroundGradient.rgb, vec3(1.0 / 2.2)); - bg_col = mix(col_low, col_high, uvcoordsvar.y); - /* Convert back to linear. */ - bg_col = pow(bg_col, vec3(2.2)); - /* Dither to hide low precision buffer. (Could be improved) */ - bg_col += dither(); - break; - case BG_RADIAL: { - /* Do interpolation in a non-linear space to have a better visual result. */ - col_high = pow(colorBackground.rgb, vec3(1.0 / 2.2)); - col_low = pow(colorBackgroundGradient.rgb, vec3(1.0 / 2.2)); - - vec2 uv_n = uvcoordsvar.xy - 0.5; - bg_col = mix(col_high, col_low, length(uv_n) * M_SQRT2); - - /* Convert back to linear. */ - bg_col = pow(bg_col, vec3(2.2)); - /* Dither to hide low precision buffer. (Could be improved) */ - bg_col += dither(); - break; - } - case BG_CHECKER: { - float size = sizeChecker * sizePixel; - ivec2 p = ivec2(floor(gl_FragCoord.xy / size)); - bool check = mod(p.x, 2) == mod(p.y, 2); - bg_col = (check) ? colorCheckerPrimary.rgb : colorCheckerSecondary.rgb; - break; - } - case BG_MASK: - fragColor = vec4(vec3(1.0 - alpha), 0.0); - return; - } - - bg_col = mix(bg_col, colorOverride.rgb, colorOverride.a); - - /* Mimic alpha under behavior. Result is premultiplied. */ - fragColor = vec4(bg_col, 1.0) * (1.0 - alpha); - - /* Special case: If the render is not transparent, do not clear alpha values. */ - if (depth == 1.0 && alpha == 1.0) { - fragColor.a = 1.0; - } -} diff --git a/source/blender/draw/engines/overlay/shaders/clipbound_vert.glsl b/source/blender/draw/engines/overlay/shaders/clipbound_vert.glsl deleted file mode 100644 index c065a66414f..00000000000 --- a/source/blender/draw/engines/overlay/shaders/clipbound_vert.glsl +++ /dev/null @@ -1,13 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - vec3 world_pos = boundbox[gl_VertexID]; - gl_Position = point_world_to_ndc(world_pos); - - /* Result in a position at 1.0 (far plane). Small epsilon to avoid precision issue. - * This mimics the effect of infinite projection matrix - * (see http://www.terathon.com/gdc07_lengyel.pdf). */ - gl_Position.z = gl_Position.w - 2.4e-7; -} diff --git a/source/blender/draw/engines/overlay/shaders/common_overlay_lib.glsl b/source/blender/draw/engines/overlay/shaders/common_overlay_lib.glsl deleted file mode 100644 index 65aeb81a4ef..00000000000 --- a/source/blender/draw/engines/overlay/shaders/common_overlay_lib.glsl +++ /dev/null @@ -1,5 +0,0 @@ -#define OVERLAY_UV_LINE_STYLE_OUTLINE 0 -#define OVERLAY_UV_LINE_STYLE_DASH 1 -#define OVERLAY_UV_LINE_STYLE_BLACK 2 -#define OVERLAY_UV_LINE_STYLE_WHITE 3 -#define OVERLAY_UV_LINE_STYLE_SHADOW 4 diff --git a/source/blender/draw/engines/overlay/shaders/depth_only_vert.glsl b/source/blender/draw/engines/overlay/shaders/depth_only_vert.glsl deleted file mode 100644 index d403890f44e..00000000000 --- a/source/blender/draw/engines/overlay/shaders/depth_only_vert.glsl +++ /dev/null @@ -1,13 +0,0 @@ - -#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); - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_curve_handle_geom.glsl b/source/blender/draw/engines/overlay/shaders/edit_curve_handle_geom.glsl deleted file mode 100644 index 7d92baea595..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_curve_handle_geom.glsl +++ /dev/null @@ -1,116 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void output_line(vec2 offset, vec4 color) -{ - finalColor = color; - - gl_Position = gl_in[0].gl_Position; - gl_Position.xy += offset * gl_in[0].gl_Position.w; - view_clipping_distances_set(gl_in[0]); - EmitVertex(); - - gl_Position = gl_in[1].gl_Position; - gl_Position.xy += offset * gl_in[1].gl_Position.w; - view_clipping_distances_set(gl_in[1]); - EmitVertex(); -} - -void main() -{ - vec4 v1 = gl_in[0].gl_Position; - vec4 v2 = gl_in[1].gl_Position; - - int is_active_nurb = (vert[1].flag & ACTIVE_NURB); - int color_id = (vert[1].flag >> COLOR_SHIFT); - - /* Don't output any edges if we don't show handles */ - if (!showCurveHandles && (color_id < 5)) { - return; - } - - bool edge_selected = (((vert[1].flag | vert[0].flag) & VERT_SELECTED) != 0); - bool handle_selected = (showCurveHandles && - (((vert[1].flag | vert[0].flag) & VERT_SELECTED_BEZT_HANDLE) != 0)); - - bool is_gpencil = ((vert[1].flag & VERT_GPENCIL_BEZT_HANDLE) != 0); - - /* If handle type is only selected and the edge is not selected, don't show. */ - if ((curveHandleDisplay != CURVE_HANDLE_ALL) && (!handle_selected)) { - /* Nurbs must show the handles always. */ - bool is_u_segment = (((vert[1].flag ^ vert[0].flag) & EVEN_U_BIT) != 0); - if ((!is_u_segment) && (color_id <= 4)) { - return; - } - if (is_gpencil) { - return; - } - } - - vec4 inner_color; - if (color_id == 0) { - inner_color = (edge_selected) ? colorHandleSelFree : colorHandleFree; - } - else if (color_id == 1) { - inner_color = (edge_selected) ? colorHandleSelAuto : colorHandleAuto; - } - else if (color_id == 2) { - inner_color = (edge_selected) ? colorHandleSelVect : colorHandleVect; - } - else if (color_id == 3) { - inner_color = (edge_selected) ? colorHandleSelAlign : colorHandleAlign; - } - else if (color_id == 4) { - inner_color = (edge_selected) ? colorHandleSelAutoclamp : colorHandleAutoclamp; - } - else { - bool is_selected = (((vert[1].flag & vert[0].flag) & VERT_SELECTED) != 0); - bool is_u_segment = (((vert[1].flag ^ vert[0].flag) & EVEN_U_BIT) != 0); - if (is_u_segment) { - inner_color = (is_selected) ? colorNurbSelUline : colorNurbUline; - } - else { - inner_color = (is_selected) ? colorNurbSelVline : colorNurbVline; - } - } - - vec4 outer_color = (is_active_nurb != 0) ? - mix(colorActiveSpline, - inner_color, - 0.25) /* Minimize active color bleeding on inner_color. */ - : - 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 */ - - if (abs(v1_2.x * sizeViewport.x) < abs(v1_2.y * sizeViewport.y)) { - offset.y = 0.0; - } - else { - offset.x = 0.0; - } - - /* draw the transparent border (AA). */ - if (is_active_nurb != 0) { - offset *= 0.75; /* Don't make the active "halo" appear very thick. */ - output_line(offset * 2.0, vec4(colorActiveSpline.rgb, 0.0)); - } - - /* draw the outline. */ - output_line(offset, outer_color); - - /* draw the core of the line. */ - output_line(vec2(0.0), inner_color); - - /* draw the outline. */ - output_line(-offset, outer_color); - - /* draw the transparent border (AA). */ - if (is_active_nurb != 0) { - output_line(offset * -2.0, vec4(colorActiveSpline.rgb, 0.0)); - } - - EndPrimitive(); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_curve_handle_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_curve_handle_vert.glsl deleted file mode 100644 index 186cc010f45..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_curve_handle_vert.glsl +++ /dev/null @@ -1,14 +0,0 @@ - -#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/edit_curve_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_curve_point_vert.glsl deleted file mode 100644 index a30496177c3..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_curve_point_vert.glsl +++ /dev/null @@ -1,37 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - /* Reuse the FREESTYLE flag to determine is GPencil. */ - bool is_gpencil = ((data & EDGE_FREESTYLE) != 0); - if ((data & VERT_SELECTED) != 0) { - if ((data & VERT_ACTIVE) != 0) { - finalColor = colorEditMeshActive; - } - else { - finalColor = (!is_gpencil) ? colorVertexSelect : colorGpencilVertexSelect; - } - } - else { - finalColor = (!is_gpencil) ? colorVertex : colorGpencilVertex; - } - - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); - gl_PointSize = (!is_gpencil) ? sizeVertex * 2.0 : sizeVertexGpencil * 2.0; - view_clipping_distances(world_pos); - - bool show_handle = showCurveHandles; - if ((curveHandleDisplay == CURVE_HANDLE_SELECTED) && ((data & VERT_SELECTED_BEZT_HANDLE) == 0)) { - show_handle = false; - } - - if (!show_handle && ((data & BEZIER_HANDLE) != 0)) { - /* We set the vertex at the camera origin to generate 0 fragments. */ - gl_Position = vec4(0.0, 0.0, -3e36, 0.0); - } -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_curve_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_curve_wire_vert.glsl deleted file mode 100644 index 183df7e5450..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_curve_wire_vert.glsl +++ /dev/null @@ -1,23 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - vec3 final_pos = pos; - - float flip = (gl_InstanceID != 0) ? -1.0 : 1.0; - - if (gl_VertexID % 2 == 0) { - final_pos += normalSize * rad * (flip * nor - tan); - } - - vec3 world_pos = point_object_to_world(final_pos); - gl_Position = point_world_to_ndc(world_pos); - - finalColor = colorWireEdit; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_gpencil_canvas_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_gpencil_canvas_vert.glsl deleted file mode 100644 index 47d9439ed80..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_gpencil_canvas_vert.glsl +++ /dev/null @@ -1,30 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - vec2 pos; - pos.x = float(gl_VertexID % 2); - pos.y = float(gl_VertexID / 2) / float(halfLineCount - 1); - - if (pos.y > 1.0) { - pos.xy = pos.yx; - pos.x -= 1.0 + 1.0 / float(halfLineCount - 1); - } - - pos -= 0.5; - - vec3 world_pos = xAxis * pos.x + yAxis * pos.y + origin; - - gl_Position = point_world_to_ndc(world_pos); - - view_clipping_distances(world_pos); - - finalColor = color; - - /* Convert to screen position [0..sizeVp]. */ - edgePos = edgeStart = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_gpencil_guide_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_gpencil_guide_vert.glsl deleted file mode 100644 index a5091345539..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_gpencil_guide_vert.glsl +++ /dev/null @@ -1,14 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - gl_Position = point_world_to_ndc(pPosition); - finalColor = pColor; - gl_PointSize = pSize; - - view_clipping_distances(pPosition); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl deleted file mode 100644 index f5d6e89d016..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl +++ /dev/null @@ -1,87 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void discard_vert() -{ - /* We set the vertex at the camera origin to generate 0 fragments. */ - gl_Position = vec4(0.0, 0.0, -3e36, 0.0); -} - -#ifdef USE_POINTS -# define gp_colorUnselect colorGpencilVertex -# define gp_colorSelect colorGpencilVertexSelect -#else -# define gp_colorUnselect gpEditColor -# define gp_colorSelect (hideSelect ? gp_colorUnselect : colorGpencilVertexSelect) -#endif - -vec3 weight_to_rgb(float t) -{ - if (t < 0.0) { - /* No weight */ - return gp_colorUnselect.rgb; - } - else if (t > 1.0) { - /* Error color */ - return vec3(1.0, 0.0, 1.0); - } - else { - return texture(weightTex, t).rgb; - } -} - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); - - bool is_multiframe = (vflag & GP_EDIT_MULTIFRAME) != 0u; - bool is_stroke_sel = (vflag & GP_EDIT_STROKE_SELECTED) != 0u; - bool is_point_sel = (vflag & GP_EDIT_POINT_SELECTED) != 0u; - bool is_point_dimmed = (vflag & GP_EDIT_POINT_DIMMED) != 0u; - - if (doWeightColor) { - finalColor.rgb = weight_to_rgb(weight); - finalColor.a = gpEditOpacity; - } - else { - finalColor = (is_point_sel) ? gp_colorSelect : gp_colorUnselect; - finalColor.a *= gpEditOpacity; - } - -#ifdef USE_POINTS - gl_PointSize = sizeVertexGpencil * 2.0; - - if (is_point_dimmed) { - finalColor.rgb = clamp(gp_colorUnselect.rgb + vec3(0.3), 0.0, 1.0); - } - - if (doStrokeEndpoints && !doWeightColor) { - bool is_stroke_start = (vflag & GP_EDIT_STROKE_START) != 0u; - bool is_stroke_end = (vflag & GP_EDIT_STROKE_END) != 0u; - - if (is_stroke_start) { - gl_PointSize *= 2.0; - finalColor.rgb = vec3(0.0, 1.0, 0.0); - } - else if (is_stroke_end) { - gl_PointSize *= 1.5; - finalColor.rgb = vec3(1.0, 0.0, 0.0); - } - } - - if ((!is_stroke_sel && !doWeightColor) || (!doMultiframe && is_multiframe)) { - discard_vert(); - } -#endif - - /* Discard unwanted padding vertices. */ - if (ma == -1 || (is_multiframe && !doMultiframe)) { - discard_vert(); - } - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_lattice_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_lattice_point_vert.glsl deleted file mode 100644 index 38ba80a981a..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_lattice_point_vert.glsl +++ /dev/null @@ -1,28 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - if ((data & VERT_SELECTED) != 0) { - finalColor = colorVertexSelect; - } - else if ((data & VERT_ACTIVE) != 0) { - finalColor = colorEditMeshActive; - } - else { - finalColor = colorVertex; - } - - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); - - /* Small offset in Z */ - gl_Position.z -= 3e-4; - - gl_PointSize = sizeVertex * 2.0; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_lattice_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_lattice_wire_vert.glsl deleted file mode 100644 index 440dfdc1482..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_lattice_wire_vert.glsl +++ /dev/null @@ -1,32 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -#define no_active_weight 666.0 - -vec3 weight_to_rgb(float t) -{ - if (t == no_active_weight) { - /* No weight. */ - return colorWire.rgb; - } - if (t > 1.0 || t < 0.0) { - /* Error color */ - return vec3(1.0, 0.0, 1.0); - } - else { - return texture(weightTex, t).rgb; - } -} - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - finalColor = vec4(weight_to_rgb(weight), 1.0); - - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_mesh_analysis_frag.glsl b/source/blender/draw/engines/overlay/shaders/edit_mesh_analysis_frag.glsl deleted file mode 100644 index 430ace8726a..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_mesh_analysis_frag.glsl +++ /dev/null @@ -1,5 +0,0 @@ - -void main() -{ - fragColor = weightColor; -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_mesh_analysis_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_mesh_analysis_vert.glsl deleted file mode 100644 index 1e163dc9a9a..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_mesh_analysis_vert.glsl +++ /dev/null @@ -1,29 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -vec3 weight_to_rgb(float t) -{ - if (t < 0.0) { - /* Minimum color, grey */ - return vec3(0.25, 0.25, 0.25); - } - else if (t > 1.0) { - /* Error color */ - return vec3(1.0, 0.0, 1.0); - } - else { - return texture(weightTex, t).rgb; - } -} - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); - weightColor = vec4(weight_to_rgb(weight), 1.0); - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_mesh_common_lib.glsl b/source/blender/draw/engines/overlay/shaders/edit_mesh_common_lib.glsl deleted file mode 100644 index 72b0a43cdb4..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_mesh_common_lib.glsl +++ /dev/null @@ -1,77 +0,0 @@ - -vec4 EDIT_MESH_edge_color_outer(int edge_flag, int face_flag, float crease, float bweight) -{ - vec4 color = vec4(0.0); - color = ((edge_flag & EDGE_FREESTYLE) != 0) ? colorEdgeFreestyle : color; - color = ((edge_flag & EDGE_SHARP) != 0) ? colorEdgeSharp : color; - color = (crease > 0.0) ? vec4(colorEdgeCrease.rgb, crease) : color; - color = (bweight > 0.0) ? vec4(colorEdgeBWeight.rgb, bweight) : color; - color = ((edge_flag & EDGE_SEAM) != 0) ? colorEdgeSeam : color; - return color; -} - -vec4 EDIT_MESH_edge_color_inner(int edge_flag) -{ - vec4 color = colorWireEdit; - vec4 color_select = (selectEdges) ? colorEdgeSelect : mix(colorEdgeSelect, colorWireEdit, .45); - color = ((edge_flag & EDGE_SELECTED) != 0) ? color_select : color; - color = ((edge_flag & EDGE_ACTIVE) != 0) ? colorEditMeshActive : color; - - color.a = (selectEdges || (edge_flag & (EDGE_SELECTED | EDGE_ACTIVE)) != 0) ? 1.0 : 0.7; - return color; -} - -vec4 EDIT_MESH_edge_vertex_color(int vertex_flag) -{ - vec4 color = colorWireEdit; - vec4 color_select = (selectEdges) ? colorEdgeSelect : mix(colorEdgeSelect, colorWireEdit, .45); - - bool edge_selected = (vertex_flag & (VERT_ACTIVE | VERT_SELECTED)) != 0; - color = (edge_selected) ? color_select : color; - - color.a = (selectEdges || edge_selected) ? 1.0 : 0.7; - return color; -} - -vec4 EDIT_MESH_vertex_color(int vertex_flag, float vertex_crease) -{ - if ((vertex_flag & VERT_ACTIVE) != 0) { - return vec4(colorEditMeshActive.xyz, 1.0); - } - else if ((vertex_flag & VERT_SELECTED) != 0) { - return colorVertexSelect; - } - else { - /* Full crease color if not selected nor active. */ - if (vertex_crease > 0.0) { - return mix(colorVertex, colorEdgeCrease, vertex_crease); - } - return colorVertex; - } -} - -vec4 EDIT_MESH_face_color(int face_flag) -{ - vec4 color = colorFace; - vec4 color_active = mix(colorFaceSelect, colorEditMeshActive, 0.5); - color = ((face_flag & FACE_FREESTYLE) != 0) ? colorFaceFreestyle : color; - color = ((face_flag & FACE_SELECTED) != 0) ? colorFaceSelect : color; - color = ((face_flag & FACE_ACTIVE) != 0) ? color_active : color; - color.a *= ((face_flag & (FACE_FREESTYLE | FACE_SELECTED | FACE_ACTIVE)) == 0 || selectFaces) ? - 1.0 : - 0.5; - return color; -} - -vec4 EDIT_MESH_facedot_color(float facedot_flag) -{ - if (facedot_flag < 0.0f) { - return vec4(colorEditMeshActive.xyz, 1.0); - } - else if (facedot_flag > 0.0f) { - return colorFaceDot; - } - else { - return colorVertex; - } -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_mesh_frag.glsl b/source/blender/draw/engines/overlay/shaders/edit_mesh_frag.glsl deleted file mode 100644 index 2fd155f715c..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_mesh_frag.glsl +++ /dev/null @@ -1,44 +0,0 @@ - -#define M_1_SQRTPI 0.5641895835477563 /* 1/sqrt(pi) */ - -/** - * 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. - */ -#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) - -bool test_occlusion() -{ - return gl_FragCoord.z > texelFetch(depthTex, ivec2(gl_FragCoord.xy), 0).r; -} - -float edge_step(float dist) -{ - if (do_smooth_wire) { - return smoothstep(GRID_LINE_SMOOTH_START, GRID_LINE_SMOOTH_END, dist); - } - else { - return step(0.5, dist); - } -} - -void main() -{ - float dist = abs(geometry_out.edgeCoord) - max(sizeEdge - 0.5, 0.0); - float dist_outer = dist - max(sizeEdge, 1.0); - float mix_w = edge_step(dist); - float mix_w_outer = edge_step(dist_outer); - /* Line color & alpha. */ - fragColor = mix(geometry_out.finalColorOuter, - geometry_out.finalColor, - 1.0 - mix_w * geometry_out.finalColorOuter.a); - /* Line edges shape. */ - fragColor.a *= 1.0 - (geometry_out.finalColorOuter.a > 0.0 ? mix_w_outer : mix_w); - - fragColor.a *= test_occlusion() ? alpha : 1.0; -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_mesh_geom.glsl b/source/blender/draw/engines/overlay/shaders/edit_mesh_geom.glsl deleted file mode 100644 index 82f957b2071..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_mesh_geom.glsl +++ /dev/null @@ -1,77 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -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; - /* Correct but fails due to an AMD compiler bug, see: T62792. - * Do inline instead. */ -#if 0 - view_clipping_distances_set(gl_in[i]); -#endif - EmitVertex(); -} - -void main() -{ - vec2 ss_pos[2]; - - /* Clip line against near plane to avoid deformed lines. */ - vec4 pos0 = gl_in[0].gl_Position; - vec4 pos1 = gl_in[1].gl_Position; - 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. */ - return; - } - - 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 = geometry_in[0].finalColorOuter_; - float half_size = sizeEdge; - /* Enlarge edge for flag display. */ - half_size += (geometry_out.finalColorOuter.a > 0.0) ? max(sizeEdge, 1.0) : 0.0; - - if (do_smooth_wire) { - /* Add 1 px for AA */ - half_size += 0.5; - } - - vec3 edge_ofs = vec3(half_size * drw_view.viewport_size_inverse, 0.0); - - bool horizontal = line.x > line.y; - edge_ofs = (horizontal) ? edge_ofs.zyz : edge_ofs.xzz; - - /* Due to an AMD glitch, this line was moved out of the `do_vertex` - * function (see T62792). */ - view_clipping_distances_set(gl_in[0]); - do_vertex(geometry_in[0].finalColor_, pos0, half_size, edge_ofs.xy); - do_vertex(geometry_in[0].finalColor_, pos0, -half_size, -edge_ofs.xy); - - view_clipping_distances_set(gl_in[1]); - vec4 final_color = (geometry_in[0].selectOverride_ == 0) ? geometry_in[1].finalColor_ : - geometry_in[0].finalColor_; - do_vertex(final_color, pos1, half_size, edge_ofs.xy); - do_vertex(final_color, pos1, -half_size, -edge_ofs.xy); - - EndPrimitive(); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_mesh_normal_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_mesh_normal_vert.glsl deleted file mode 100644 index 6ff8d0665d1..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_mesh_normal_vert.glsl +++ /dev/null @@ -1,69 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -bool test_occlusion() -{ - vec3 ndc = (gl_Position.xyz / gl_Position.w) * 0.5 + 0.5; - return (ndc.z - 0.00035) > texture(depthTex, ndc.xy).r; -} - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - /* Avoid undefined behavior after return. */ - finalColor = vec4(0.0); - gl_Position = vec4(0.0); - - vec3 nor; - /* Select the right normal by checking if the generic attribute is used. */ - if (!all(equal(lnor.xyz, vec3(0)))) { - if (lnor.w < 0.0) { - return; - } - nor = lnor.xyz; - finalColor = colorLNormal; - } - else if (!all(equal(vnor.xyz, vec3(0)))) { - if (vnor.w < 0.0) { - return; - } - nor = vnor.xyz; - finalColor = colorVNormal; - } - else { - nor = norAndFlag.xyz; - if (all(equal(nor, vec3(0)))) { - return; - } - finalColor = colorNormal; - } - - vec3 n = normalize(normal_object_to_world(nor)); - vec3 world_pos = point_object_to_world(pos); - - if (gl_VertexID == 0) { - if (isConstantScreenSizeNormals) { - bool is_persp = (ProjectionMatrix[3][3] == 0.0); - if (is_persp) { - float dist_fac = length(cameraPos - world_pos); - float cos_fac = dot(cameraForward, cameraVec(world_pos)); - world_pos += n * normalScreenSize * dist_fac * cos_fac * pixelFac * sizePixel; - } - else { - float frustrum_fac = mul_project_m4_v3_zfac(n) * sizePixel; - world_pos += n * normalScreenSize * frustrum_fac; - } - } - else { - world_pos += n * normalSize; - } - } - - gl_Position = point_world_to_ndc(world_pos); - - finalColor.a *= (test_occlusion()) ? alpha : 1.0; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_mesh_skin_root_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_mesh_skin_root_vert.glsl deleted file mode 100644 index f1fbdac7847..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_mesh_skin_root_vert.glsl +++ /dev/null @@ -1,17 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - mat3 imat = mat3(ModelMatrixInverse); - vec3 right = normalize(imat * screenVecs[0].xyz); - vec3 up = normalize(imat * screenVecs[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 = ViewProjectionMatrix * pos_4d; - /* Manual stipple: one segment out of 2 is transparent. */ - finalColor = ((gl_VertexID & 1) == 0) ? colorSkinRoot : vec4(0.0); - - view_clipping_distances(pos_4d.xyz); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_mesh_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_mesh_vert.glsl deleted file mode 100644 index 166ac1a37b0..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_mesh_vert.glsl +++ /dev/null @@ -1,99 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) -#pragma BLENDER_REQUIRE(edit_mesh_common_lib.glsl) - -#ifdef EDGE -/* Ugly but needed to keep the same vertex shader code for other passes. */ -# define finalColor geometry_in.finalColor_ -# define finalColorOuter geometry_in.finalColorOuter_ -# define selectOverride geometry_in.selectOverride_ -#endif - -bool test_occlusion() -{ - vec3 ndc = (gl_Position.xyz / gl_Position.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)); -} - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); - - ivec4 m_data = data & dataMask; - -#if defined(VERT) - vertexCrease = float(m_data.z >> 4) / 15.0; - finalColor = EDIT_MESH_vertex_color(m_data.y, vertexCrease); - gl_PointSize = sizeVertex * ((vertexCrease > 0.0) ? 3.0 : 2.0); - /* Make selected and active vertex always on top. */ - if ((data.x & VERT_SELECTED) != 0) { - gl_Position.z -= 5e-7 * abs(gl_Position.w); - } - if ((data.x & VERT_ACTIVE) != 0) { - gl_Position.z -= 5e-7 * abs(gl_Position.w); - } - - bool occluded = test_occlusion(); - -#elif defined(EDGE) -# ifdef FLAT - finalColor = EDIT_MESH_edge_color_inner(m_data.y); - selectOverride = 1; -# else - finalColor = EDIT_MESH_edge_vertex_color(m_data.y); - selectOverride = (m_data.y & EDGE_SELECTED); -# endif - - float edge_crease = float(m_data.z & 0xF) / 15.0; - float bweight = float(m_data.w) / 255.0; - finalColorOuter = EDIT_MESH_edge_color_outer(m_data.y, m_data.x, edge_crease, bweight); - - if (finalColorOuter.a > 0.0) { - gl_Position.z -= 5e-7 * abs(gl_Position.w); - } - - bool occluded = false; /* Done in fragment shader */ - -#elif defined(FACE) - finalColor = EDIT_MESH_face_color(m_data.x); - bool occluded = true; - -#elif defined(FACEDOT) - finalColor = EDIT_MESH_facedot_color(norAndFlag.w); - - /* Bias Facedot Z position in clipspace. */ - gl_Position.z -= (ProjectionMatrix[3][3] == 0.0) ? 0.00035 : 1e-6; - gl_PointSize = sizeFaceDot; - - bool occluded = test_occlusion(); - -#endif - - finalColor.a *= (occluded) ? alpha : 1.0; - -#if !defined(FACE) - /* Facing based color blend */ - vec3 vpos = point_world_to_view(world_pos); - vec3 view_normal = normalize(normal_object_to_view(vnor) + 1e-4); - vec3 view_vec = (ProjectionMatrix[3][3] == 0.0) ? normalize(vpos) : vec3(0.0, 0.0, 1.0); - float facing = dot(view_vec, view_normal); - facing = 1.0 - abs(facing) * 0.2; - - /* Do interpolation in a non-linear space to have a better visual result. */ - finalColor.rgb = non_linear_blend_color(colorEditMeshMiddle.rgb, finalColor.rgb, facing); -#endif - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_particle_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_particle_point_vert.glsl deleted file mode 100644 index 956b27e948d..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_particle_point_vert.glsl +++ /dev/null @@ -1,15 +0,0 @@ - -#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 = mix(colorWire, colorVertexSelect, color); - - gl_PointSize = sizeVertex * 2.0; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_particle_strand_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_particle_strand_vert.glsl deleted file mode 100644 index 6a92206d524..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_particle_strand_vert.glsl +++ /dev/null @@ -1,35 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -#define no_active_weight 666.0 - -vec3 weight_to_rgb(float t) -{ - if (t == no_active_weight) { - /* No weight. */ - return colorWire.rgb; - } - if (t > 1.0 || t < 0.0) { - /* Error color */ - return vec3(1.0, 0.0, 1.0); - } - else { - return texture(weightTex, t).rgb; - } -} - -void main() -{ - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); - - if (useWeight) { - finalColor = vec4(weight_to_rgb(color), 1.0); - } - else { - finalColor = mix(colorWire, colorVertexSelect, color); - } - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_edges_frag.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_edges_frag.glsl deleted file mode 100644 index 9c0ce4ecc8a..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_edges_frag.glsl +++ /dev/null @@ -1,69 +0,0 @@ -#pragma BLENDER_REQUIRE(common_overlay_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. - */ -#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) - -void main() -{ - vec4 inner_color = vec4(vec3(0.0), 1.0); - vec4 outer_color = vec4(0.0); - - vec2 dd = fwidth(geom_out.stipplePos); - float line_distance = distance(geom_out.stipplePos, geom_out.stippleStart) / max(dd.x, dd.y); - - if (lineStyle == OVERLAY_UV_LINE_STYLE_OUTLINE) { -#ifdef USE_EDGE_SELECT - /* TODO(@campbellbarton): The current wire-edit color contrast enough against the selection. - * Look into changing the default theme color instead of reducing contrast with edge-select. */ - inner_color = (geom_out.selectionFac != 0.0) ? colorEdgeSelect : (colorWireEdit * 0.5); -#else - inner_color = mix(colorWireEdit, colorEdgeSelect, geom_out.selectionFac); -#endif - outer_color = vec4(vec3(0.0), 1.0); - } - else if (lineStyle == OVERLAY_UV_LINE_STYLE_DASH) { - if (fract(line_distance / dashLength) < 0.5) { - inner_color = mix(vec4(vec3(0.35), 1.0), colorEdgeSelect, geom_out.selectionFac); - } - } - else if (lineStyle == OVERLAY_UV_LINE_STYLE_BLACK) { - vec4 base_color = vec4(vec3(0.0), 1.0); - inner_color = mix(base_color, colorEdgeSelect, geom_out.selectionFac); - } - else if (lineStyle == OVERLAY_UV_LINE_STYLE_WHITE) { - vec4 base_color = vec4(1.0); - inner_color = mix(base_color, colorEdgeSelect, geom_out.selectionFac); - } - else if (lineStyle == OVERLAY_UV_LINE_STYLE_SHADOW) { - inner_color = colorUVShadow; - } - - float dist = abs(geom_out.edgeCoord) - max(sizeEdge - 0.5, 0.0); - float dist_outer = dist - max(sizeEdge, 1.0); - float mix_w; - float mix_w_outer; - - if (doSmoothWire) { - mix_w = smoothstep(GRID_LINE_SMOOTH_START, GRID_LINE_SMOOTH_END, dist); - mix_w_outer = smoothstep(GRID_LINE_SMOOTH_START, GRID_LINE_SMOOTH_END, dist_outer); - } - else { - mix_w = step(0.5, dist); - mix_w_outer = step(0.5, dist_outer); - } - - vec4 final_color = mix(outer_color, inner_color, 1.0 - mix_w * outer_color.a); - final_color.a *= 1.0 - (outer_color.a > 0.0 ? mix_w_outer : mix_w); - final_color.a *= alpha; - - fragColor = final_color; -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_edges_geom.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_edges_geom.glsl deleted file mode 100644 index ac8d33cd727..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_edges_geom.glsl +++ /dev/null @@ -1,57 +0,0 @@ -#pragma BLENDER_REQUIRE(common_overlay_lib.glsl) - -void do_vertex( - vec4 pos, float selection_fac, vec2 stipple_start, vec2 stipple_pos, float coord, vec2 offset) -{ - geom_out.selectionFac = selection_fac; - geom_out.edgeCoord = coord; - geom_out.stippleStart = stipple_start; - geom_out.stipplePos = stipple_pos; - - gl_Position = pos; - /* Multiply offset by 2 because gl_Position range is [-1..1]. */ - gl_Position.xy += offset * 2.0; - EmitVertex(); -} - -void main() -{ - vec2 ss_pos[2]; - vec4 pos0 = gl_in[0].gl_Position; - vec4 pos1 = gl_in[1].gl_Position; - ss_pos[0] = pos0.xy / pos0.w; - ss_pos[1] = pos1.xy / pos1.w; - - float half_size = sizeEdge; - /* Enlarge edge for outline drawing. */ - /* Factor of 3.0 out of nowhere! Seems to fix issues with float imprecision. */ - half_size += (lineStyle == OVERLAY_UV_LINE_STYLE_OUTLINE) ? - max(sizeEdge * (doSmoothWire ? 1.0 : 3.0), 1.0) : - 0.0; - /* Add 1 px for AA */ - if (doSmoothWire) { - half_size += 0.5; - } - - 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); - float selectFac0 = geom_in[0].selectionFac; - float selectFac1 = geom_in[1].selectionFac; -#ifdef USE_EDGE_SELECT - /* No blending with edge selection. */ - selectFac1 = selectFac0; -#endif - - do_vertex( - pos0, selectFac0, geom_in[0].stippleStart, geom_in[0].stipplePos, half_size, edge_ofs.xy); - do_vertex( - pos0, selectFac0, geom_in[0].stippleStart, geom_in[0].stipplePos, -half_size, -edge_ofs.xy); - do_vertex( - pos1, selectFac1, geom_in[1].stippleStart, geom_in[1].stipplePos, half_size, edge_ofs.xy); - do_vertex( - pos1, selectFac1, geom_in[1].stippleStart, geom_in[1].stipplePos, -half_size, -edge_ofs.xy); - - EndPrimitive(); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_edges_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_edges_vert.glsl deleted file mode 100644 index 23f1a44c321..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_edges_vert.glsl +++ /dev/null @@ -1,27 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -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; - gl_Position.xy = floor(gl_Position.xy * half_viewport_res) / half_viewport_res + - half_pixel_offset; - -#ifdef USE_EDGE_SELECT - bool is_select = (flag & EDGE_UV_SELECT) != 0; -#else - bool is_select = (flag & VERT_UV_SELECT) != 0; -#endif - geom_in.selectionFac = is_select ? 1.0 : 0.0; - /* Move selected edges to the top - * Vertices are between 0.0 and 0.2, Edges between 0.2 and 0.4 - * actual pixels are at 0.75, 1.0 is used for the background. */ - float depth = is_select ? 0.25 : 0.35; - gl_Position.z = depth; - - /* Avoid precision loss. */ - geom_in.stippleStart = geom_in.stipplePos = 500.0 + 500.0 * (gl_Position.xy / gl_Position.w); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_face_dots_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_face_dots_vert.glsl deleted file mode 100644 index 280b31ea463..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_face_dots_vert.glsl +++ /dev/null @@ -1,10 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - vec3 world_pos = point_object_to_world(vec3(au, 0.0)); - gl_Position = point_world_to_ndc(world_pos); - - finalColor = ((flag & FACE_UV_SELECT) != 0) ? colorVertexSelect : vec4(colorWire.rgb, 1.0); - gl_PointSize = pointSize; -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_faces_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_faces_vert.glsl deleted file mode 100644 index 80ea6228675..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_faces_vert.glsl +++ /dev/null @@ -1,14 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - vec3 world_pos = point_object_to_world(vec3(au, 0.0)); - gl_Position = point_world_to_ndc(world_pos); - - bool is_selected = (flag & FACE_UV_SELECT) != 0; - bool is_active = (flag & FACE_UV_ACTIVE) != 0; - - finalColor = (is_selected) ? colorFaceSelect : colorFace; - finalColor = (is_active) ? colorEditMeshActive : finalColor; - finalColor.a *= uvOpacity; -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_image_mask_frag.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_image_mask_frag.glsl deleted file mode 100644 index a1392abbb92..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_image_mask_frag.glsl +++ /dev/null @@ -1,8 +0,0 @@ -#pragma BLENDER_REQUIRE(common_colormanagement_lib.glsl) - -void main() -{ - vec2 uvs_clamped = clamp(uvs, 0.0, 1.0); - float mask_value = texture_read_as_linearrgb(imgTexture, true, uvs_clamped).r; - fragColor = vec4(color.rgb * mask_value, color.a); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_image_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_image_vert.glsl deleted file mode 100644 index 7ecbb513265..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_image_vert.glsl +++ /dev/null @@ -1,11 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - /* `pos` contains the coordinates of a quad (-1..1). but we need the coordinates of an image - * plane (0..1) */ - vec3 image_pos = pos * 0.5 + 0.5; - vec4 position = point_object_to_ndc(image_pos); - gl_Position = position; - uvs = image_pos.xy; -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_stretching_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_stretching_vert.glsl deleted file mode 100644 index bb086e8d9f5..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_stretching_vert.glsl +++ /dev/null @@ -1,82 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -vec3 weight_to_rgb(float weight) -{ - vec3 r_rgb; - float blend = ((weight / 2.0) + 0.5); - - if (weight <= 0.25) { /* blue->cyan */ - r_rgb[0] = 0.0; - r_rgb[1] = blend * weight * 4.0; - r_rgb[2] = blend; - } - else if (weight <= 0.50) { /* cyan->green */ - r_rgb[0] = 0.0; - r_rgb[1] = blend; - r_rgb[2] = blend * (1.0 - ((weight - 0.25) * 4.0)); - } - else if (weight <= 0.75) { /* green->yellow */ - r_rgb[0] = blend * ((weight - 0.50) * 4.0); - r_rgb[1] = blend; - r_rgb[2] = 0.0; - } - else if (weight <= 1.0) { /* yellow->red */ - r_rgb[0] = blend; - r_rgb[1] = blend * (1.0 - ((weight - 0.75) * 4.0)); - r_rgb[2] = 0.0; - } - else { - /* exceptional value, unclamped or nan, - * avoid uninitialized memory use */ - r_rgb[0] = 1.0; - r_rgb[1] = 0.0; - r_rgb[2] = 1.0; - } - - return r_rgb; -} - -#define M_PI 3.1415926535897932 - -vec2 angle_to_v2(float angle) -{ - return vec2(cos(angle), sin(angle)); -} - -/* Adapted from BLI_math_vector.h */ -float angle_normalized_v2v2(vec2 v1, vec2 v2) -{ - v1 = normalize(v1 * aspect); - v2 = normalize(v2 * aspect); - /* this is the same as acos(dot_v3v3(v1, v2)), but more accurate */ - bool q = (dot(v1, v2) >= 0.0); - vec2 v = (q) ? (v1 - v2) : (v1 + v2); - float a = 2.0 * asin(length(v) / 2.0); - return (q) ? a : M_PI - a; -} - -float area_ratio_to_stretch(float ratio, float tot_ratio, float inv_tot_ratio) -{ - ratio *= (ratio > 0.0f) ? tot_ratio : -inv_tot_ratio; - return (ratio > 1.0f) ? (1.0f / ratio) : ratio; -} - -void main() -{ - vec3 world_pos = point_object_to_world(vec3(pos, 0.0)); - gl_Position = point_world_to_ndc(world_pos); - -#ifdef STRETCH_ANGLE - vec2 v1 = angle_to_v2(uv_angles.x * M_PI); - vec2 v2 = angle_to_v2(uv_angles.y * M_PI); - float uv_angle = angle_normalized_v2v2(v1, v2) / M_PI; - float stretch = 1.0 - abs(uv_angle - angle); - stretch = stretch; - stretch = 1.0 - stretch * stretch; -#else - float stretch = 1.0 - area_ratio_to_stretch(ratio, totalAreaRatio, totalAreaRatioInv); - -#endif - - finalColor = vec4(weight_to_rgb(stretch), 1.0); -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_tiled_image_borders_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_tiled_image_borders_vert.glsl deleted file mode 100644 index bc5235b9cab..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_tiled_image_borders_vert.glsl +++ /dev/null @@ -1,14 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -#ifndef USE_GPU_SHADER_CREATE_INFO -in vec3 pos; -#endif - -void main() -{ - /* `pos` contains the coordinates of a quad (-1..1). but we need the coordinates of an image - * plane (0..1) */ - vec3 image_pos = pos * 0.5 + 0.5; - vec4 position = point_object_to_ndc(image_pos); - gl_Position = position; -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_verts_frag.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_verts_frag.glsl deleted file mode 100644 index c0ea6aebe10..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_verts_frag.glsl +++ /dev/null @@ -1,27 +0,0 @@ - -void main() -{ - float dist = length(gl_PointCoord - vec2(0.5)); - - /* transparent outside of point - * --- 0 --- - * smooth transition - * --- 1 --- - * pure outline color - * --- 2 --- - * smooth transition - * --- 3 --- - * pure fill color - * ... - * dist = 0 at center of point */ - - float midStroke = 0.5 * (radii[1] + radii[2]); - - if (dist > midStroke) { - fragColor.rgb = outlineColor.rgb; - fragColor.a = mix(outlineColor.a, 0.0, smoothstep(radii[1], radii[0], dist)); - } - else { - fragColor = mix(fillColor, outlineColor, smoothstep(radii[3], radii[2], dist)); - } -} diff --git a/source/blender/draw/engines/overlay/shaders/edit_uv_verts_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_uv_verts_vert.glsl deleted file mode 100644 index 9f9b02ce19d..00000000000 --- a/source/blender/draw/engines/overlay/shaders/edit_uv_verts_vert.glsl +++ /dev/null @@ -1,33 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -/* TODO: Theme? */ -const vec4 pinned_col = vec4(1.0, 0.0, 0.0, 1.0); - -void main() -{ - bool is_selected = (flag & (VERT_UV_SELECT | FACE_UV_SELECT)) != 0; - bool is_pinned = (flag & VERT_UV_PINNED) != 0; - vec4 deselect_col = (is_pinned) ? pinned_col : vec4(color.rgb, 1.0); - fillColor = (is_selected) ? colorVertexSelect : deselect_col; - outlineColor = (is_pinned) ? pinned_col : vec4(fillColor.rgb, 0.0); - - vec3 world_pos = point_object_to_world(vec3(au, 0.0)); - /* Move selected vertices to the top - * Vertices are between 0.0 and 0.2, Edges between 0.2 and 0.4 - * actual pixels are at 0.75, 1.0 is used for the background. */ - float depth = is_selected ? (is_pinned ? 0.05 : 0.10) : 0.15; - gl_Position = vec4(point_world_to_ndc(world_pos).xy, depth, 1.0); - gl_PointSize = pointSize; - - /* calculate concentric radii in pixels */ - float radius = 0.5 * pointSize; - - /* start at the outside and progress toward the center */ - radii[0] = radius; - radii[1] = radius - 1.0; - radii[2] = radius - outlineWidth; - radii[3] = radius - outlineWidth - 1.0; - - /* convert to PointCoord units */ - radii /= pointSize; -} diff --git a/source/blender/draw/engines/overlay/shaders/extra_frag.glsl b/source/blender/draw/engines/overlay/shaders/extra_frag.glsl deleted file mode 100644 index bf29b2b057e..00000000000 --- a/source/blender/draw/engines/overlay/shaders/extra_frag.glsl +++ /dev/null @@ -1,8 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - fragColor = finalColor; - lineOutput = pack_line_data(gl_FragCoord.xy, edgeStart, edgePos); -} diff --git a/source/blender/draw/engines/overlay/shaders/extra_groundline_vert.glsl b/source/blender/draw/engines/overlay/shaders/extra_groundline_vert.glsl deleted file mode 100644 index ff7aae523e7..00000000000 --- a/source/blender/draw/engines/overlay/shaders/extra_groundline_vert.glsl +++ /dev/null @@ -1,22 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -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 p = inst_pos; - p.z *= (pos.z == 0.0) ? 0.0 : 1.0; - float screen_size = mul_project_m4_v3_zfac(p) * sizePixel; - vec3 world_pos = p + screen_pos * screen_size; - - gl_Position = point_world_to_ndc(world_pos); - - /* Convert to screen position [0..sizeVp]. */ - edgePos = edgeStart = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/extra_lightprobe_grid_vert.glsl b/source/blender/draw/engines/overlay/shaders/extra_lightprobe_grid_vert.glsl deleted file mode 100644 index 1eee7ab251b..00000000000 --- a/source/blender/draw/engines/overlay/shaders/extra_lightprobe_grid_vert.glsl +++ /dev/null @@ -1,61 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -vec4 color_from_id(float color_id) -{ - if (isTransform) { - return colorTransform; - } - else if (color_id == 1.0) { - return colorActive; - } - else /* 2.0 */ { - return colorSelect; - } - - return colorTransform; -} - -/* Replace top 2 bits (of the 16bit output) by outlineId. - * This leaves 16K different IDs to create outlines between objects. - * SHIFT = (32 - (16 - 2)) */ -#define SHIFT 18u - -void main() -{ - mat4 model_mat = gridModelMatrix; - model_mat[0][3] = model_mat[1][3] = model_mat[2][3] = 0.0; - model_mat[3][3] = 1.0; - float color_id = gridModelMatrix[3].w; - - ivec3 grid_resolution = ivec3(gridModelMatrix[0].w, gridModelMatrix[1].w, gridModelMatrix[2].w); - - vec3 ls_cell_location; - /* Keep in sync with update_irradiance_probe */ - ls_cell_location.z = float(gl_VertexID % grid_resolution.z); - ls_cell_location.y = float((gl_VertexID / grid_resolution.z) % grid_resolution.y); - ls_cell_location.x = float(gl_VertexID / (grid_resolution.z * grid_resolution.y)); - - ls_cell_location += 0.5; - ls_cell_location /= vec3(grid_resolution); - ls_cell_location = ls_cell_location * 2.0 - 1.0; - - vec3 ws_cell_location = (model_mat * vec4(ls_cell_location, 1.0)).xyz; - gl_Position = point_world_to_ndc(ws_cell_location); - gl_PointSize = sizeVertex * 2.0; - - finalColor = color_from_id(color_id); - - /* Shade occluded points differently. */ - vec4 p = gl_Position / gl_Position.w; - float z_depth = texture(depthBuffer, p.xy * 0.5 + 0.5).r * 2.0 - 1.0; - float z_delta = p.z - z_depth; - if (z_delta > 0.0) { - float fac = 1.0 - z_delta * 10000.0; - /* Smooth blend to avoid flickering. */ - finalColor = mix(colorBackground, finalColor, clamp(fac, 0.5, 1.0)); - } - - view_clipping_distances(ws_cell_location); -} diff --git a/source/blender/draw/engines/overlay/shaders/extra_loose_point_frag.glsl b/source/blender/draw/engines/overlay/shaders/extra_loose_point_frag.glsl deleted file mode 100644 index d92b947ef89..00000000000 --- a/source/blender/draw/engines/overlay/shaders/extra_loose_point_frag.glsl +++ /dev/null @@ -1,20 +0,0 @@ - -void main() -{ - vec2 centered = abs(gl_PointCoord - vec2(0.5)); - float dist = max(centered.x, centered.y); - - float fac = dist * dist * 4.0; - /* Non linear blend. */ - vec4 col1 = sqrt(colorEditMeshMiddle); - vec4 col2 = sqrt(finalColor); - fragColor = mix(col1, col2, 0.45 + fac * 0.65); - fragColor *= fragColor; - - lineOutput = vec4(0.0); - - /* Make the effect more like a fresnel by offsetting - * the depth and creating mini-spheres. - * Disabled as it has performance impact. */ - // gl_FragDepth = gl_FragCoord.z + 1e-6 * fac; -} diff --git a/source/blender/draw/engines/overlay/shaders/extra_loose_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/extra_loose_point_vert.glsl deleted file mode 100644 index f283934816c..00000000000 --- a/source/blender/draw/engines/overlay/shaders/extra_loose_point_vert.glsl +++ /dev/null @@ -1,17 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - /* Extract data packed inside the unused mat4 members. */ - mat4 obmat = ModelMatrix; - finalColor = vec4(obmat[0][3], obmat[1][3], obmat[2][3], obmat[3][3]); - - vec3 world_pos = (ModelMatrix * vec4(pos, 1.0)).xyz; - gl_Position = point_world_to_ndc(world_pos); - - gl_PointSize = sizeVertex * 2.0; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/extra_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/extra_point_vert.glsl deleted file mode 100644 index de999c241c0..00000000000 --- a/source/blender/draw/engines/overlay/shaders/extra_point_vert.glsl +++ /dev/null @@ -1,23 +0,0 @@ - -#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); - - gl_PointSize = sizeObjectCenter; - float radius = 0.5 * sizeObjectCenter; - float outline_width = sizePixel; - radii[0] = radius; - radii[1] = radius - 1.0; - radii[2] = radius - outline_width; - radii[3] = radius - outline_width - 1.0; - radii /= sizeObjectCenter; - - fillColor = color; - outlineColor = colorOutline; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/extra_vert.glsl b/source/blender/draw/engines/overlay/shaders/extra_vert.glsl deleted file mode 100644 index b2578970c9b..00000000000 --- a/source/blender/draw/engines/overlay/shaders/extra_vert.glsl +++ /dev/null @@ -1,226 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -#define lamp_area_size inst_data.xy -#define lamp_clip_sta inst_data.z -#define lamp_clip_end inst_data.w - -#define lamp_spot_cosine inst_data.x -#define lamp_spot_blend inst_data.y - -#define camera_corner inst_data.xy -#define camera_center inst_data.zw -#define camera_dist color.a -#define camera_dist_sta inst_data.z -#define camera_dist_end inst_data.w -#define camera_distance_color inst_data.x - -#define empty_size inst_data.xyz -#define empty_scale inst_data.w - -/* TODO(fclem): Share with C code. */ -#define VCLASS_LIGHT_AREA_SHAPE (1 << 0) -#define VCLASS_LIGHT_SPOT_SHAPE (1 << 1) -#define VCLASS_LIGHT_SPOT_BLEND (1 << 2) -#define VCLASS_LIGHT_SPOT_CONE (1 << 3) -#define VCLASS_LIGHT_DIST (1 << 4) - -#define VCLASS_CAMERA_FRAME (1 << 5) -#define VCLASS_CAMERA_DIST (1 << 6) -#define VCLASS_CAMERA_VOLUME (1 << 7) - -#define VCLASS_SCREENSPACE (1 << 8) -#define VCLASS_SCREENALIGNED (1 << 9) - -#define VCLASS_EMPTY_SCALED (1 << 10) -#define VCLASS_EMPTY_AXES (1 << 11) -#define VCLASS_EMPTY_AXES_NAME (1 << 12) -#define VCLASS_EMPTY_AXES_SHADOW (1 << 13) -#define VCLASS_EMPTY_SIZE (1 << 14) - -void main() -{ - /* Extract data packed inside the unused mat4 members. */ - vec4 inst_data = vec4(inst_obmat[0][3], inst_obmat[1][3], inst_obmat[2][3], inst_obmat[3][3]); - float inst_color_data = color.a; - mat4 obmat = inst_obmat; - obmat[0][3] = obmat[1][3] = obmat[2][3] = 0.0; - obmat[3][3] = 1.0; - - finalColor = color; - if (color.a < 0.0) { - finalColor.a = 1.0; - } - - float lamp_spot_sine; - vec3 vpos = pos; - vec3 vofs = vec3(0.0); - /* Lights */ - if ((vclass & VCLASS_LIGHT_AREA_SHAPE) != 0) { - /* HACK: use alpha color for spots to pass the area_size. */ - if (inst_color_data < 0.0) { - lamp_area_size.xy = vec2(-inst_color_data); - } - vpos.xy *= lamp_area_size.xy; - } - else if ((vclass & VCLASS_LIGHT_SPOT_SHAPE) != 0) { - lamp_spot_sine = sqrt(1.0 - lamp_spot_cosine * lamp_spot_cosine); - lamp_spot_sine *= ((vclass & VCLASS_LIGHT_SPOT_BLEND) != 0) ? lamp_spot_blend : 1.0; - vpos = vec3(pos.xy * lamp_spot_sine, -lamp_spot_cosine); - } - else if ((vclass & VCLASS_LIGHT_DIST) != 0) { - /* Meh nasty mess. Select one of the 6 axes to display on. (see light_distance_z_get()) */ - int dist_axis = int(pos.z); - float dist = pos.z - floor(pos.z) - 0.5; - float inv = sign(dist); - dist = (abs(dist) > 0.15) ? lamp_clip_end : lamp_clip_sta; - vofs[dist_axis] = inv * dist / length(obmat[dist_axis].xyz); - vpos.z = 0.0; - if (lamp_clip_end < 0.0) { - vpos = vofs = vec3(0.0); - } - } - /* Camera */ - else if ((vclass & VCLASS_CAMERA_FRAME) != 0) { - if ((vclass & VCLASS_CAMERA_VOLUME) != 0) { - vpos.z = mix(color.b, color.a, pos.z); - } - else if (camera_dist > 0.0) { - vpos.z = -abs(camera_dist); - } - else { - vpos.z *= -abs(camera_dist); - } - vpos.xy = (camera_center + camera_corner * vpos.xy) * abs(vpos.z); - } - else if ((vclass & VCLASS_CAMERA_DIST) != 0) { - vofs.xy = vec2(0.0); - vofs.z = -mix(camera_dist_sta, camera_dist_end, pos.z); - vpos.z = 0.0; - /* Distance line endpoints color */ - if (any(notEqual(pos.xy, vec2(0.0)))) { - /* Override color. */ - switch (int(camera_distance_color)) { - case 0: /* Mist */ - finalColor = vec4(0.5, 0.5, 0.5, 1.0); - break; - case 1: /* Mist Active */ - finalColor = vec4(1.0, 1.0, 1.0, 1.0); - break; - case 2: /* Clip */ - finalColor = vec4(0.5, 0.5, 0.25, 1.0); - break; - case 3: /* Clip Active */ - finalColor = vec4(1.0, 1.0, 0.5, 1.0); - break; - } - } - /* Focus cross */ - if (pos.z == 2.0) { - vofs.z = 0.0; - if (camera_dist < 0.0) { - vpos.z = -abs(camera_dist); - } - else { - /* Disabled */ - vpos = vec3(0.0); - } - } - } - /* Empties */ - else if ((vclass & VCLASS_EMPTY_SCALED) != 0) { - /* This is a bit silly but we avoid scaling the object matrix on CPU (saving a mat4 mul) */ - vpos *= empty_scale; - } - else if ((vclass & VCLASS_EMPTY_SIZE) != 0) { - /* This is a bit silly but we avoid scaling the object matrix on CPU (saving a mat4 mul) */ - vpos *= empty_size; - } - else if ((vclass & VCLASS_EMPTY_AXES) != 0) { - float axis = vpos.z; - vofs[int(axis)] = (1.0 + fract(axis)) * empty_scale; - /* Scale uniformly by axis length */ - vpos *= length(obmat[int(axis)].xyz) * empty_scale; - - vec3 axis_color = vec3(0.0); - axis_color[int(axis)] = 1.0; - finalColor.rgb = mix(axis_color + fract(axis), color.rgb, color.a); - finalColor.a = 1.0; - } - - /* Not exclusive with previous flags. */ - if ((vclass & VCLASS_CAMERA_VOLUME) != 0) { - /* Unpack final color. */ - int color_class = int(floor(color.r)); - float color_intensity = fract(color.r); - switch (color_class) { - case 0: /* No eye (convergence plane). */ - finalColor = vec4(1.0, 1.0, 1.0, 1.0); - break; - case 1: /* Left eye. */ - finalColor = vec4(0.0, 1.0, 1.0, 1.0); - break; - case 2: /* Right eye. */ - finalColor = vec4(1.0, 0.0, 0.0, 1.0); - break; - } - finalColor *= vec4(vec3(color_intensity), color.g); - } - - 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 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; - world_pos = (obmat * vec4(vofs, 1.0)).xyz + screen_pos; - } - else { - world_pos = (obmat * vec4(vofs + vpos, 1.0)).xyz; - } - - if ((vclass & VCLASS_LIGHT_SPOT_CONE) != 0) { - /* Compute point on the cone before and after this one. */ - vec2 perp = vec2(pos.y, -pos.x); - const float incr_angle = 2.0 * 3.1415 / 32.0; - const vec2 slope = vec2(cos(incr_angle), sin(incr_angle)); - vec3 p0 = vec3((pos.xy * slope.x + perp * slope.y) * lamp_spot_sine, -lamp_spot_cosine); - vec3 p1 = vec3((pos.xy * slope.x - perp * slope.y) * lamp_spot_sine, -lamp_spot_cosine); - p0 = (obmat * vec4(p0, 1.0)).xyz; - p1 = (obmat * vec4(p1, 1.0)).xyz; - /* Compute normals of each side. */ - vec3 edge = obmat[3].xyz - world_pos; - vec3 n0 = normalize(cross(edge, p0 - world_pos)); - vec3 n1 = normalize(cross(edge, world_pos - p1)); - bool persp = (ProjectionMatrix[3][3] == 0.0); - vec3 V = (persp) ? normalize(ViewMatrixInverse[3].xyz - world_pos) : ViewMatrixInverse[2].xyz; - /* Discard non-silhouette edges. */ - bool facing0 = dot(n0, V) > 0.0; - bool facing1 = dot(n1, V) > 0.0; - if (facing0 == facing1) { - /* Hide line by making it cover 0 pixels. */ - world_pos = obmat[3].xyz; - } - } - - gl_Position = point_world_to_ndc(world_pos); - - /* Convert to screen position [0..sizeVp]. */ - edgePos = edgeStart = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; - -#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. */ - /* 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); -#endif - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/extra_wire_frag.glsl b/source/blender/draw/engines/overlay/shaders/extra_wire_frag.glsl deleted file mode 100644 index f32e3a8564e..00000000000 --- a/source/blender/draw/engines/overlay/shaders/extra_wire_frag.glsl +++ /dev/null @@ -1,26 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - fragColor = finalColor; - - /* Stipple */ - const float dash_width = 6.0; - const float dash_factor = 0.5; - - lineOutput = pack_line_data(gl_FragCoord.xy, stipple_start, stipple_coord); - - float dist = distance(stipple_start, stipple_coord); - - if (fragColor.a == 0.0) { - /* Disable stippling. */ - dist = 0.0; - } - - fragColor.a = 1.0; - - if (fract(dist / dash_width) > dash_factor) { - discard; - } -} diff --git a/source/blender/draw/engines/overlay/shaders/extra_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/extra_wire_vert.glsl deleted file mode 100644 index cd217021e8f..00000000000 --- a/source/blender/draw/engines/overlay/shaders/extra_wire_vert.glsl +++ /dev/null @@ -1,47 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -vec2 screen_position(vec4 p) -{ - return ((p.xy / p.w) * 0.5 + 0.5) * sizeViewport.xy; -} - -void main() -{ - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); - -#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. */ - /* 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); -#endif - - stipple_coord = stipple_start = screen_position(gl_Position); - -#ifdef OBJECT_WIRE - /* Extract data packed inside the unused mat4 members. */ - finalColor = vec4(ModelMatrix[0][3], ModelMatrix[1][3], ModelMatrix[2][3], ModelMatrix[3][3]); -#else - - if (colorid != 0) { - /* TH_CAMERA_PATH is the only color code at the moment. - * Checking `colorid != 0` to avoid having to sync its value with the GLSL code. */ - finalColor = colorCameraPath; - finalColor.a = 0.0; /* No Stipple */ - } - else { - finalColor = color; - finalColor.a = 1.0; /* Stipple */ - } -#endif - -#ifdef SELECT_EDGES - finalColor.a = 0.0; /* No Stipple */ -#endif - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/facing_frag.glsl b/source/blender/draw/engines/overlay/shaders/facing_frag.glsl deleted file mode 100644 index 8208689d113..00000000000 --- a/source/blender/draw/engines/overlay/shaders/facing_frag.glsl +++ /dev/null @@ -1,5 +0,0 @@ - -void main() -{ - fragColor = gl_FrontFacing ? colorFaceFront : colorFaceBack; -} diff --git a/source/blender/draw/engines/overlay/shaders/facing_vert.glsl b/source/blender/draw/engines/overlay/shaders/facing_vert.glsl deleted file mode 100644 index d98caee6a25..00000000000 --- a/source/blender/draw/engines/overlay/shaders/facing_vert.glsl +++ /dev/null @@ -1,10 +0,0 @@ - -#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); - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/grid_background_frag.glsl b/source/blender/draw/engines/overlay/shaders/grid_background_frag.glsl deleted file mode 100644 index 37958319b44..00000000000 --- a/source/blender/draw/engines/overlay/shaders/grid_background_frag.glsl +++ /dev/null @@ -1,7 +0,0 @@ - -void main() -{ - fragColor = color; - float scene_depth = texelFetch(depthBuffer, ivec2(gl_FragCoord.xy), 0).r; - fragColor.a = (scene_depth == 1.0) ? 1.0 : 0.0; -} diff --git a/source/blender/draw/engines/overlay/shaders/grid_frag.glsl b/source/blender/draw/engines/overlay/shaders/grid_frag.glsl deleted file mode 100644 index 25f4984f119..00000000000 --- a/source/blender/draw/engines/overlay/shaders/grid_frag.glsl +++ /dev/null @@ -1,232 +0,0 @@ -/** - * Infinite grid: - * Draw antialiazed grid and axes of different sizes with smooth blending between Level of details. - * We draw multiple triangles to avoid float precision issues due to perspective interpolation. - **/ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) -#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. - */ -#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_STEP(dist) smoothstep(GRID_LINE_SMOOTH_START, GRID_LINE_SMOOTH_END, dist) - -float get_grid(vec2 co, vec2 fwidthCos, float grid_scale) -{ - float 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); - /* 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); -} - -vec3 get_axes(vec3 co, vec3 fwidthCos, float line_size) -{ - vec3 axes_domain = abs(co); - /* 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)); -} - -#define linearstep(p0, p1, v) (clamp(((v) - (p0)) / abs((p1) - (p0)), 0.0, 1.0)) - -void main() -{ - vec3 P = local_pos * grid_buf.size.xyz; - vec3 dFdxPos = dFdx(P); - vec3 dFdyPos = dFdy(P); - vec3 fwidthPos = abs(dFdxPos) + abs(dFdyPos); - P += cameraPos * plane_axes; - - float dist, fade; - bool is_persp = ProjectionMatrix[3][3] == 0.0; - if (is_persp) { - vec3 V = cameraPos - P; - dist = length(V); - V /= dist; - - float angle; - if (flag_test(grid_flag, PLANE_XZ)) { - angle = V.y; - } - else if (flag_test(grid_flag, PLANE_YZ)) { - angle = V.x; - } - else { - angle = V.z; - } - - angle = 1.0 - abs(angle); - angle *= angle; - fade = 1.0 - angle * angle; - fade *= 1.0 - smoothstep(0.0, grid_buf.distance, dist - grid_buf.distance); - } - else { - dist = gl_FragCoord.z * 2.0 - 1.0; - /* Avoid fading in +Z direction in camera view (see T70193). */ - dist = flag_test(grid_flag, GRID_CAMERA) ? clamp(dist, 0.0, 1.0) : abs(dist); - fade = 1.0 - smoothstep(0.0, 0.5, dist - 0.5); - dist = 1.0; /* Avoid branch after. */ - - if (flag_test(grid_flag, PLANE_XY)) { - float angle = 1.0 - abs(ViewMatrixInverse[2].z); - dist = 1.0 + angle * 2.0; - angle *= angle; - fade *= 1.0 - angle * angle; - } - } - - if (flag_test(grid_flag, SHOW_GRID)) { - /* Using `max(dot(dFdxPos, screenVecs[0]), dot(dFdyPos, screenVecs[1]))` - * would be more accurate, but not really necessary. */ - float grid_res = dot(dFdxPos, screenVecs[0].xyz); - - /* The grid begins to appear when it comprises 4 pixels. */ - grid_res *= 4; - - /* For UV/Image editor use grid_buf.zoom_factor. */ - if (flag_test(grid_flag, PLANE_IMAGE) && - /* Grid begins to appear when the length of one grid unit is at least - * (256/grid_size) pixels Value of grid_size defined in `overlay_grid.c`. */ - !flag_test(grid_flag, CUSTOM_GRID)) { - 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)); - } -#endif -#undef grid_step - - float blend = 1.0 - linearstep(scale[0], scale[1], grid_res); - blend = blend * blend * blend; - - vec2 grid_pos, grid_fwidth; - if (flag_test(grid_flag, PLANE_XZ)) { - grid_pos = P.xz; - grid_fwidth = fwidthPos.xz; - } - else if (flag_test(grid_flag, PLANE_YZ)) { - grid_pos = P.yz; - grid_fwidth = fwidthPos.yz; - } - else { - grid_pos = P.xy; - 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]); - - out_color = colorGrid; - out_color.a *= gridA * blend; - out_color = mix(out_color, mix(colorGrid, colorGridEmphasis, blend), gridB); - out_color = mix(out_color, colorGridEmphasis, gridC); - } - else { - out_color = vec4(colorGrid.rgb, 0.0); - } - - if (flag_test(grid_flag, (SHOW_AXIS_X | SHOW_AXIS_Y | SHOW_AXIS_Z))) { - /* Setup axes 'domains' */ - vec3 axes_dist, axes_fwidth; - - if (flag_test(grid_flag, SHOW_AXIS_X)) { - axes_dist.x = dot(P.yz, plane_axes.yz); - axes_fwidth.x = dot(fwidthPos.yz, plane_axes.yz); - } - if (flag_test(grid_flag, SHOW_AXIS_Y)) { - axes_dist.y = dot(P.xz, plane_axes.xz); - axes_fwidth.y = dot(fwidthPos.xz, plane_axes.xz); - } - if (flag_test(grid_flag, SHOW_AXIS_Z)) { - axes_dist.z = dot(P.xy, plane_axes.xy); - axes_fwidth.z = dot(fwidthPos.xy, plane_axes.xy); - } - - /* Computing all axes at once using vec3 */ - vec3 axes = get_axes(axes_dist, axes_fwidth, 0.1); - - if (flag_test(grid_flag, SHOW_AXIS_X)) { - out_color.a = max(out_color.a, axes.x); - out_color.rgb = (axes.x < 1e-8) ? out_color.rgb : colorGridAxisX.rgb; - } - if (flag_test(grid_flag, SHOW_AXIS_Y)) { - out_color.a = max(out_color.a, axes.y); - out_color.rgb = (axes.y < 1e-8) ? out_color.rgb : colorGridAxisY.rgb; - } - if (flag_test(grid_flag, SHOW_AXIS_Z)) { - out_color.a = max(out_color.a, axes.z); - out_color.rgb = (axes.z < 1e-8) ? out_color.rgb : colorGridAxisZ.rgb; - } - } - - float scene_depth = texelFetch(depth_tx, ivec2(gl_FragCoord.xy), 0).r; - if (flag_test(grid_flag, GRID_BACK)) { - fade *= (scene_depth == 1.0) ? 1.0 : 0.0; - } - else { - /* Add a small bias so the grid will always be below of a mesh with the same depth. */ - float grid_depth = gl_FragCoord.z + 4.8e-7; - /* Manual, non hard, depth test: - * Progressively fade the grid below occluders - * (avoids popping visuals due to depth buffer precision) */ - /* Harder settings tend to flicker more, - * but have less "see through" appearance. */ - float bias = max(fwidth(gl_FragCoord.z), 2.4e-7); - fade *= linearstep(grid_depth, grid_depth + bias, scene_depth); - } - - out_color.a *= fade; -} diff --git a/source/blender/draw/engines/overlay/shaders/grid_vert.glsl b/source/blender/draw/engines/overlay/shaders/grid_vert.glsl deleted file mode 100644 index b81f1a24358..00000000000 --- a/source/blender/draw/engines/overlay/shaders/grid_vert.glsl +++ /dev/null @@ -1,43 +0,0 @@ -/** - * Infinite grid: - * Draw antialiazed grid and axes of different sizes with smooth blending between Level of details. - * We draw multiple triangles to avoid float precision issues due to perspective interpolation. - **/ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) -#pragma BLENDER_REQUIRE(common_math_lib.glsl) - -void main() -{ - vec3 vert_pos; - - /* Project camera pos to the needed plane */ - if (flag_test(grid_flag, PLANE_XY)) { - vert_pos = vec3(pos.x, pos.y, 0.0); - } - else if (flag_test(grid_flag, PLANE_XZ)) { - vert_pos = vec3(pos.x, 0.0, pos.y); - } - else if (flag_test(grid_flag, PLANE_YZ)) { - vert_pos = vec3(0.0, pos.x, pos.y); - } - else /* PLANE_IMAGE */ { - vert_pos = vec3(pos.xy * 0.5 + 0.5, 0.0); - } - - local_pos = vert_pos; - - vec3 real_pos = cameraPos * plane_axes + vert_pos * grid_buf.size.xyz; - - /* Used for additional Z axis */ - if (flag_test(grid_flag, CLIP_ZPOS)) { - real_pos.z = clamp(real_pos.z, 0.0, 1e30); - local_pos.z = clamp(local_pos.z, 0.0, 1.0); - } - if (flag_test(grid_flag, CLIP_ZNEG)) { - real_pos.z = clamp(real_pos.z, -1e30, 0.0); - local_pos.z = clamp(local_pos.z, -1.0, 0.0); - } - - gl_Position = ViewProjectionMatrix * vec4(real_pos, 1.0); -} diff --git a/source/blender/draw/engines/overlay/shaders/image_frag.glsl b/source/blender/draw/engines/overlay/shaders/image_frag.glsl deleted file mode 100644 index e0339507e0f..00000000000 --- a/source/blender/draw/engines/overlay/shaders/image_frag.glsl +++ /dev/null @@ -1,24 +0,0 @@ -#pragma BLENDER_REQUIRE(common_colormanagement_lib.glsl) - -void main() -{ - vec2 uvs_clamped = clamp(uvs, 0.0, 1.0); - vec4 tex_color; - tex_color = texture_read_as_linearrgb(imgTexture, imgPremultiplied, uvs_clamped); - - fragColor = tex_color * color; - - if (!imgAlphaBlend) { - /* Arbitrary discard anything below 5% opacity. - * Note that this could be exposed to the User. */ - if (tex_color.a < 0.05) { - discard; - } - else { - fragColor.a = 1.0; - } - } - - /* Pre-multiplied blending. */ - fragColor.rgb *= fragColor.a; -} diff --git a/source/blender/draw/engines/overlay/shaders/image_vert.glsl b/source/blender/draw/engines/overlay/shaders/image_vert.glsl deleted file mode 100644 index 45cddb3610d..00000000000 --- a/source/blender/draw/engines/overlay/shaders/image_vert.glsl +++ /dev/null @@ -1,29 +0,0 @@ - -#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); - if (isCameraBackground) { - /* Model matrix converts to view position to avoid jittering (see T91398). */ - gl_Position = point_view_to_ndc(world_pos); - /* Camera background images are not really part of the 3D space. - * It makes no sense to apply clipping on them. */ - view_clipping_distances_bypass(); - } - else { - gl_Position = point_world_to_ndc(world_pos); - view_clipping_distances(world_pos); - } - - if (depthSet) { - /* Result in a position at 1.0 (far plane). Small epsilon to avoid precision issue. - * This mimics the effect of infinite projection matrix - * (see http://www.terathon.com/gdc07_lengyel.pdf). */ - gl_Position.z = gl_Position.w - 2.4e-7; - view_clipping_distances_bypass(); - } - - uvs = pos.xy * 0.5 + 0.5; -} diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_antialiasing_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_antialiasing_info.hh index fe67dd473b7..0dba8b54e35 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_antialiasing_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_antialiasing_info.hh @@ -9,7 +9,7 @@ GPU_SHADER_CREATE_INFO(overlay_antialiasing) .sampler(2, ImageType::FLOAT_2D, "lineTex") .push_constant(Type::BOOL, "doSmoothLines") .fragment_out(0, Type::VEC4, "fragColor") - .fragment_source("antialiasing_frag.glsl") + .fragment_source("overlay_antialiasing_frag.glsl") .additional_info("draw_fullscreen", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_xray_fade) @@ -18,5 +18,5 @@ GPU_SHADER_CREATE_INFO(overlay_xray_fade) .sampler(1, ImageType::DEPTH_2D, "xrayDepthTex") .push_constant(Type::FLOAT, "opacity") .fragment_out(0, Type::VEC4, "fragColor") - .fragment_source("xray_fade_frag.glsl") + .fragment_source("overlay_xray_fade_frag.glsl") .additional_info("draw_fullscreen"); 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 d89272a50cf..9f2acceed97 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 @@ -25,8 +25,8 @@ GPU_SHADER_CREATE_INFO(overlay_armature_sphere_outline) /* Per instance. */ .vertex_in(1, Type::MAT4, "inst_obmat") .vertex_out(overlay_armature_wire_iface) - .vertex_source("armature_sphere_outline_vert.glsl") - .fragment_source("armature_wire_frag.glsl") + .vertex_source("overlay_armature_sphere_outline_vert.glsl") + .fragment_source("overlay_armature_wire_frag.glsl") .additional_info("overlay_frag_output", "overlay_armature_common", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_armature_sphere_outline_clipped) @@ -47,8 +47,8 @@ GPU_SHADER_CREATE_INFO(overlay_armature_sphere_solid) .vertex_in(2, Type::MAT4, "inst_obmat") // .depth_layout(DepthLayout::GREATER) /* TODO */ .vertex_out(overlay_armature_sphere_solid_iface) - .vertex_source("armature_sphere_solid_vert.glsl") - .fragment_source("armature_sphere_solid_frag.glsl") + .vertex_source("overlay_armature_sphere_solid_vert.glsl") + .fragment_source("overlay_armature_sphere_solid_frag.glsl") .additional_info("overlay_frag_output", "overlay_armature_common", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_armature_sphere_solid_clipped) @@ -79,9 +79,9 @@ GPU_SHADER_CREATE_INFO(overlay_armature_shape_outline) .vertex_out(overlay_armature_shape_outline_iface) .geometry_layout(PrimitiveIn::LINES_ADJACENCY, PrimitiveOut::LINE_STRIP, 2) .geometry_out(overlay_armature_wire_iface) - .vertex_source("armature_shape_outline_vert.glsl") - .geometry_source("armature_shape_outline_geom.glsl") - .fragment_source("armature_wire_frag.glsl") + .vertex_source("overlay_armature_shape_outline_vert.glsl") + .geometry_source("overlay_armature_shape_outline_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) @@ -100,8 +100,8 @@ GPU_SHADER_CREATE_INFO(overlay_armature_shape_solid) .vertex_in(2, Type::MAT4, "inst_obmat") .depth_write(DepthWrite::GREATER) .vertex_out(overlay_armature_shape_solid_iface) - .vertex_source("armature_shape_solid_vert.glsl") - .fragment_source("armature_shape_solid_frag.glsl") + .vertex_source("overlay_armature_shape_solid_vert.glsl") + .fragment_source("overlay_armature_shape_solid_frag.glsl") .additional_info("overlay_frag_output", "overlay_armature_common", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_armature_shape_solid_clipped) @@ -115,8 +115,8 @@ GPU_SHADER_CREATE_INFO(overlay_armature_shape_wire) /* Per instance. */ .vertex_in(2, Type::MAT4, "inst_obmat") .vertex_out(overlay_armature_wire_iface) - .vertex_source("armature_shape_wire_vert.glsl") - .fragment_source("armature_wire_frag.glsl") + .vertex_source("overlay_armature_shape_wire_vert.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_wire_clipped) @@ -140,8 +140,8 @@ GPU_SHADER_CREATE_INFO(overlay_armature_envelope_outline) .vertex_in(5, Type::VEC4, "outlineColorSize") .vertex_in(6, Type::VEC3, "xAxis") .vertex_out(overlay_armature_wire_iface) - .vertex_source("armature_envelope_outline_vert.glsl") - .fragment_source("armature_wire_frag.glsl") + .vertex_source("overlay_armature_envelope_outline_vert.glsl") + .fragment_source("overlay_armature_wire_frag.glsl") .additional_info("overlay_frag_output", "overlay_armature_common", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_armature_envelope_outline_clipped) @@ -164,8 +164,8 @@ GPU_SHADER_CREATE_INFO(overlay_armature_envelope_solid) .vertex_in(5, Type::VEC3, "boneColor") .vertex_out(overlay_armature_envelope_solid_iface) .push_constant(Type::BOOL, "isDistance") - .vertex_source("armature_envelope_solid_vert.glsl") - .fragment_source("armature_envelope_solid_frag.glsl") + .vertex_source("overlay_armature_envelope_solid_vert.glsl") + .fragment_source("overlay_armature_envelope_solid_frag.glsl") .additional_info("overlay_frag_output", "overlay_armature_common"); GPU_SHADER_CREATE_INFO(overlay_armature_envelope_solid_clipped) @@ -198,8 +198,8 @@ GPU_SHADER_CREATE_INFO(overlay_armature_stick) .vertex_in(7, Type::VEC4, "tailColor") .define("do_wire", "(wireColor.a > 0.0)") .vertex_out(overlay_armature_stick_iface) - .vertex_source("armature_stick_vert.glsl") - .fragment_source("armature_stick_frag.glsl") + .vertex_source("overlay_armature_stick_vert.glsl") + .fragment_source("overlay_armature_stick_frag.glsl") .additional_info("overlay_frag_output", "overlay_armature_common", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_armature_stick_clipped) @@ -218,12 +218,12 @@ GPU_SHADER_CREATE_INFO(overlay_armature_dof) .vertex_in(1, Type::VEC4, "color") .vertex_in(2, Type::MAT4, "inst_obmat") .vertex_out(overlay_armature_wire_iface) - .vertex_source("armature_dof_vert.glsl") + .vertex_source("overlay_armature_dof_vert.glsl") .additional_info("overlay_frag_output", "overlay_armature_common", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_armature_dof_wire) .do_static_compilation(true) - .fragment_source("armature_dof_solid_frag.glsl") + .fragment_source("overlay_armature_dof_solid_frag.glsl") .additional_info("overlay_armature_dof"); GPU_SHADER_CREATE_INFO(overlay_armature_dof_wire_clipped) @@ -232,7 +232,7 @@ GPU_SHADER_CREATE_INFO(overlay_armature_dof_wire_clipped) GPU_SHADER_CREATE_INFO(overlay_armature_dof_solid) .do_static_compilation(true) - .fragment_source("armature_dof_solid_frag.glsl") + .fragment_source("overlay_armature_dof_solid_frag.glsl") .additional_info("overlay_armature_dof"); GPU_SHADER_CREATE_INFO(overlay_armature_dof_solid_clipped) @@ -251,8 +251,8 @@ GPU_SHADER_CREATE_INFO(overlay_armature_wire) .vertex_in(1, Type::VEC4, "color") .push_constant(Type::FLOAT, "alpha") .vertex_out(overlay_armature_wire_iface) - .vertex_source("armature_wire_vert.glsl") - .fragment_source("armature_wire_frag.glsl") + .vertex_source("overlay_armature_wire_vert.glsl") + .fragment_source("overlay_armature_wire_frag.glsl") .additional_info("overlay_frag_output", "draw_mesh", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_armature_wire_clipped) 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 c96d302d861..8fc07b831e3 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 @@ -9,7 +9,7 @@ GPU_SHADER_CREATE_INFO(overlay_background) .sampler(1, ImageType::DEPTH_2D, "depthBuffer") .push_constant(Type::INT, "bgType") .push_constant(Type::VEC4, "colorOverride") - .fragment_source("background_frag.glsl") + .fragment_source("overlay_background_frag.glsl") .fragment_out(0, Type::VEC4, "fragColor") .additional_info("draw_fullscreen", "draw_globals"); @@ -19,7 +19,7 @@ GPU_SHADER_CREATE_INFO(overlay_clipbound) .define("srgbTarget", "false") .push_constant(Type::VEC4, "color") .push_constant(Type::VEC3, "boundbox", 8) - .vertex_source("clipbound_vert.glsl") + .vertex_source("overlay_clipbound_vert.glsl") .fragment_out(0, Type::VEC4, "fragColor") .fragment_source("gpu_shader_uniform_color_frag.glsl") .additional_info("draw_view"); 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 e6f15046838..3624f26a4c3 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 @@ -19,7 +19,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_mesh_common) .push_constant(Type::BOOL, "selectEdges") .push_constant(Type::FLOAT, "alpha") .push_constant(Type::IVEC4, "dataMask") - .vertex_source("edit_mesh_vert.glsl") + .vertex_source("overlay_edit_mesh_vert.glsl") .additional_info("draw_modelmat", "draw_globals"); GPU_SHADER_INTERFACE_INFO(overlay_edit_mesh_vert_iface, "") @@ -58,8 +58,8 @@ GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge) .vertex_out(overlay_edit_mesh_edge_iface) .geometry_out(overlay_edit_mesh_edge_geom_iface) .geometry_layout(PrimitiveIn::LINES, PrimitiveOut::TRIANGLE_STRIP, 4) - .geometry_source("edit_mesh_geom.glsl") - .fragment_source("edit_mesh_frag.glsl") + .geometry_source("overlay_edit_mesh_geom.glsl") + .fragment_source("overlay_edit_mesh_frag.glsl") .additional_info("overlay_edit_mesh_common"); GPU_SHADER_CREATE_INFO(overlay_edit_mesh_edge_flat) @@ -103,7 +103,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_mesh_normal) .push_constant(Type::BOOL, "isConstantScreenSizeNormals") .vertex_out(overlay_edit_flat_color_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_mesh_normal_vert.glsl") + .vertex_source("overlay_edit_mesh_normal_vert.glsl") .fragment_source("gpu_shader_flat_color_frag.glsl") .additional_info("draw_modelmat_instanced_attr", "draw_globals"); @@ -116,8 +116,8 @@ GPU_SHADER_CREATE_INFO(overlay_edit_mesh_analysis) .sampler(0, ImageType::FLOAT_1D, "weightTex") .fragment_out(0, Type::VEC4, "fragColor") .vertex_out(overlay_edit_mesh_analysis_iface) - .vertex_source("edit_mesh_analysis_vert.glsl") - .fragment_source("edit_mesh_analysis_frag.glsl") + .vertex_source("overlay_edit_mesh_analysis_vert.glsl") + .fragment_source("overlay_edit_mesh_analysis_frag.glsl") .additional_info("draw_modelmat"); GPU_SHADER_CREATE_INFO(overlay_edit_mesh_skin_root) @@ -128,7 +128,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_mesh_skin_root) .vertex_in(2, Type::VEC3, "local_pos") .vertex_out(overlay_edit_flat_color_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_mesh_skin_root_vert.glsl") + .vertex_source("overlay_edit_mesh_skin_root_vert.glsl") .fragment_source("gpu_shader_flat_color_frag.glsl") .additional_info("draw_modelmat_instanced_attr", "draw_globals"); @@ -193,9 +193,9 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_edges) .push_constant(Type::FLOAT, "alpha") .push_constant(Type::FLOAT, "dashLength") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_uv_edges_vert.glsl") - .geometry_source("edit_uv_edges_geom.glsl") - .fragment_source("edit_uv_edges_frag.glsl") + .vertex_source("overlay_edit_uv_edges_vert.glsl") + .geometry_source("overlay_edit_uv_edges_geom.glsl") + .fragment_source("overlay_edit_uv_edges_frag.glsl") .additional_info("draw_mesh", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_edit_uv_edges_select) @@ -212,7 +212,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_faces) .push_constant(Type::FLOAT, "uvOpacity") .vertex_out(overlay_edit_flat_color_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_uv_faces_vert.glsl") + .vertex_source("overlay_edit_uv_faces_vert.glsl") .fragment_source("gpu_shader_flat_color_frag.glsl") .additional_info("draw_mesh", "draw_globals"); @@ -225,7 +225,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_face_dots) .push_constant(Type::FLOAT, "pointSize") .vertex_out(overlay_edit_flat_color_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_uv_face_dots_vert.glsl") + .vertex_source("overlay_edit_uv_face_dots_vert.glsl") .fragment_source("gpu_shader_flat_color_frag.glsl") .additional_info("draw_mesh", "draw_globals"); @@ -245,8 +245,8 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_verts) .push_constant(Type::VEC4, "color") .vertex_out(overlay_edit_uv_vert_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_uv_verts_vert.glsl") - .fragment_source("edit_uv_verts_frag.glsl") + .vertex_source("overlay_edit_uv_verts_vert.glsl") + .fragment_source("overlay_edit_uv_verts_frag.glsl") .additional_info("draw_mesh", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_edit_uv_tiled_image_borders) @@ -256,7 +256,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_tiled_image_borders) .vertex_in(0, Type::VEC3, "pos") .push_constant(Type::VEC4, "color") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_uv_tiled_image_borders_vert.glsl") + .vertex_source("overlay_edit_uv_tiled_image_borders_vert.glsl") .fragment_source("gpu_shader_uniform_color_frag.glsl") .additional_info("draw_mesh"); @@ -266,13 +266,13 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_stencil_image) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") .vertex_out(edit_uv_image_iface) - .vertex_source("edit_uv_image_vert.glsl") + .vertex_source("overlay_edit_uv_image_vert.glsl") .sampler(0, ImageType::FLOAT_2D, "imgTexture") .push_constant(Type::BOOL, "imgPremultiplied") .push_constant(Type::BOOL, "imgAlphaBlend") .push_constant(Type::VEC4, "color") .fragment_out(0, Type::VEC4, "fragColor") - .fragment_source("image_frag.glsl") + .fragment_source("overlay_image_frag.glsl") .additional_info("draw_mesh"); GPU_SHADER_CREATE_INFO(overlay_edit_uv_mask_image) @@ -282,8 +282,8 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_mask_image) .sampler(0, ImageType::FLOAT_2D, "imgTexture") .push_constant(Type::VEC4, "color") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_uv_image_vert.glsl") - .fragment_source("edit_uv_image_mask_frag.glsl") + .vertex_source("overlay_edit_uv_image_vert.glsl") + .fragment_source("overlay_edit_uv_image_mask_frag.glsl") .additional_info("draw_mesh"); /** \} */ @@ -299,7 +299,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_uv_stretching) .push_constant(Type::VEC2, "aspect") .vertex_out(overlay_edit_nopersp_color_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_uv_stretching_vert.glsl") + .vertex_source("overlay_edit_uv_stretching_vert.glsl") .fragment_source("gpu_shader_2D_smooth_color_frag.glsl") .additional_info("draw_mesh", "draw_globals"); @@ -338,8 +338,8 @@ GPU_SHADER_CREATE_INFO(overlay_edit_curve_handle) .push_constant(Type::BOOL, "showCurveHandles") .push_constant(Type::INT, "curveHandleDisplay") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_curve_handle_vert.glsl") - .geometry_source("edit_curve_handle_geom.glsl") + .vertex_source("overlay_edit_curve_handle_vert.glsl") + .geometry_source("overlay_edit_curve_handle_geom.glsl") .fragment_source("gpu_shader_3D_smooth_color_frag.glsl") .additional_info("draw_mesh", "draw_globals"); @@ -358,7 +358,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_curve_point) .push_constant(Type::BOOL, "showCurveHandles") .push_constant(Type::INT, "curveHandleDisplay") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_curve_point_vert.glsl") + .vertex_source("overlay_edit_curve_point_vert.glsl") .fragment_source("gpu_shader_point_varying_color_frag.glsl") .additional_info("draw_mesh", "draw_globals"); @@ -377,7 +377,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_curve_wire) .push_constant(Type::FLOAT, "normalSize") .vertex_out(overlay_edit_flat_color_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_curve_wire_vert.glsl") + .vertex_source("overlay_edit_curve_wire_vert.glsl") .fragment_source("gpu_shader_flat_color_frag.glsl") .additional_info("draw_modelmat", "draw_resource_id_uniform", "draw_globals"); @@ -399,7 +399,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_lattice_point) .vertex_in(1, Type::INT, "data") .vertex_out(overlay_edit_flat_color_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_lattice_point_vert.glsl") + .vertex_source("overlay_edit_lattice_point_vert.glsl") .fragment_source("gpu_shader_point_varying_color_frag.glsl") .additional_info("draw_mesh", "draw_globals"); @@ -416,7 +416,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_lattice_wire) .sampler(0, ImageType::FLOAT_1D, "weightTex") .vertex_out(overlay_edit_smooth_color_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_lattice_wire_vert.glsl") + .vertex_source("overlay_edit_lattice_wire_vert.glsl") .fragment_source("gpu_shader_3D_smooth_color_frag.glsl") .additional_info("draw_mesh", "draw_globals"); @@ -440,7 +440,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_particle_strand) .push_constant(Type::BOOL, "useWeight") .vertex_out(overlay_edit_smooth_color_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_particle_strand_vert.glsl") + .vertex_source("overlay_edit_particle_strand_vert.glsl") .fragment_source("gpu_shader_3D_smooth_color_frag.glsl") .additional_info("draw_mesh", "draw_globals"); @@ -456,7 +456,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_particle_point) .vertex_in(1, Type::FLOAT, "color") .vertex_out(overlay_edit_flat_color_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_particle_point_vert.glsl") + .vertex_source("overlay_edit_particle_point_vert.glsl") .fragment_source("gpu_shader_point_varying_color_frag.glsl") .additional_info("draw_mesh", "draw_globals"); @@ -487,7 +487,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_gpencil) .push_constant(Type::VEC4, "gpEditColor") .sampler(0, ImageType::FLOAT_1D, "weightTex") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_gpencil_vert.glsl") + .vertex_source("overlay_edit_gpencil_vert.glsl") .additional_info("draw_mesh", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_edit_gpencil_wire) @@ -523,7 +523,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_gpencil_guide_point) .push_constant(Type::FLOAT, "pSize") .push_constant(Type::VEC4, "pColor") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_gpencil_guide_vert.glsl") + .vertex_source("overlay_edit_gpencil_guide_vert.glsl") .fragment_source("gpu_shader_point_varying_color_frag.glsl") .additional_info("draw_mesh", "draw_globals"); @@ -542,7 +542,7 @@ GPU_SHADER_CREATE_INFO(overlay_edit_gpencil_guide_point_clipped) GPU_SHADER_CREATE_INFO(overlay_depth_only) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") - .vertex_source("depth_only_vert.glsl") + .vertex_source("overlay_depth_only_vert.glsl") .fragment_source("gpu_shader_depth_only_frag.glsl") .additional_info("draw_mesh"); @@ -563,7 +563,7 @@ GPU_SHADER_CREATE_INFO(overlay_uniform_color) .vertex_in(0, Type::VEC3, "pos") .push_constant(Type::VEC4, "color") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("depth_only_vert.glsl") + .vertex_source("overlay_depth_only_vert.glsl") .fragment_source("gpu_shader_uniform_color_frag.glsl") .additional_info("draw_mesh"); 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 b9b1b73dbd4..0a2fc164ea9 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 @@ -21,8 +21,8 @@ GPU_SHADER_CREATE_INFO(overlay_extra) .vertex_out(overlay_extra_iface) .fragment_out(0, Type::VEC4, "fragColor") .fragment_out(1, Type::VEC4, "lineOutput") - .vertex_source("extra_vert.glsl") - .fragment_source("extra_frag.glsl") + .vertex_source("overlay_extra_vert.glsl") + .fragment_source("overlay_extra_frag.glsl") .additional_info("draw_view", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_extra_select) @@ -53,7 +53,7 @@ GPU_SHADER_CREATE_INFO(overlay_extra_grid) .push_constant(Type::BOOL, "isTransform") .vertex_out(overlay_extra_grid_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("extra_lightprobe_grid_vert.glsl") + .vertex_source("overlay_extra_lightprobe_grid_vert.glsl") .fragment_source("gpu_shader_point_varying_color_frag.glsl") .additional_info("draw_view", "draw_globals"); @@ -75,8 +75,8 @@ GPU_SHADER_CREATE_INFO(overlay_extra_groundline) .vertex_out(overlay_extra_iface) .fragment_out(0, Type::VEC4, "fragColor") .fragment_out(1, Type::VEC4, "lineOutput") - .vertex_source("extra_groundline_vert.glsl") - .fragment_source("extra_frag.glsl") + .vertex_source("overlay_extra_groundline_vert.glsl") + .fragment_source("overlay_extra_frag.glsl") .additional_info("draw_view", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_extra_groundline_clipped) @@ -103,8 +103,8 @@ GPU_SHADER_CREATE_INFO(overlay_extra_wire) .vertex_out(overlay_extra_wire_iface) .fragment_out(0, Type::VEC4, "fragColor") .fragment_out(1, Type::VEC4, "lineOutput") - .vertex_source("extra_wire_vert.glsl") - .fragment_source("extra_wire_frag.glsl") + .vertex_source("overlay_extra_wire_vert.glsl") + .fragment_source("overlay_extra_wire_frag.glsl") .additional_info("draw_modelmat", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_extra_wire_select) @@ -148,7 +148,7 @@ GPU_SHADER_CREATE_INFO(overlay_extra_point) .push_constant(Type::VEC4, "color") .vertex_out(overlay_extra_point_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("extra_point_vert.glsl") + .vertex_source("overlay_extra_point_vert.glsl") .fragment_source("gpu_shader_point_varying_color_varying_outline_aa_frag.glsl") .additional_info("draw_modelmat", "draw_globals"); @@ -165,8 +165,8 @@ GPU_SHADER_CREATE_INFO(overlay_extra_loose_point) .vertex_out(overlay_extra_loose_point_iface) .fragment_out(0, Type::VEC4, "fragColor") .fragment_out(1, Type::VEC4, "lineOutput") - .vertex_source("extra_loose_point_vert.glsl") - .fragment_source("extra_loose_point_frag.glsl") + .vertex_source("overlay_extra_loose_point_vert.glsl") + .fragment_source("overlay_extra_loose_point_frag.glsl") .additional_info("draw_modelmat", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_extra_loose_point_clipped) @@ -194,9 +194,9 @@ GPU_SHADER_CREATE_INFO(overlay_motion_path_line) .geometry_out(overlay_motion_path_line_iface) .geometry_layout(PrimitiveIn::LINES, PrimitiveOut::TRIANGLE_STRIP, 4) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("motion_path_line_vert.glsl") - .geometry_source("motion_path_line_geom.glsl") - .fragment_source("motion_path_line_frag.glsl") + .vertex_source("overlay_motion_path_line_vert.glsl") + .geometry_source("overlay_motion_path_line_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) @@ -215,7 +215,7 @@ GPU_SHADER_CREATE_INFO(overlay_motion_path_point) .push_constant(Type::VEC3, "customColor") .vertex_out(overlay_motion_path_point_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("motion_path_point_vert.glsl") + .vertex_source("overlay_motion_path_point_vert.glsl") .fragment_source("gpu_shader_point_varying_color_frag.glsl") .additional_info("draw_view", "draw_globals"); @@ -242,8 +242,8 @@ GPU_SHADER_CREATE_INFO(overlay_image) .vertex_out(overlay_image_iface) .sampler(0, ImageType::FLOAT_2D, "imgTexture") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("image_vert.glsl") - .fragment_source("image_frag.glsl") + .vertex_source("overlay_image_vert.glsl") + .fragment_source("overlay_image_frag.glsl") .additional_info("draw_mesh"); GPU_SHADER_CREATE_INFO(overlay_image_clipped) @@ -266,8 +266,8 @@ GPU_SHADER_CREATE_INFO(overlay_gpencil_canvas) .push_constant(Type::INT, "halfLineCount") .fragment_out(0, Type::VEC4, "fragColor") .fragment_out(1, Type::VEC4, "lineOutput") - .vertex_source("edit_gpencil_canvas_vert.glsl") - .fragment_source("extra_frag.glsl") + .vertex_source("overlay_edit_gpencil_canvas_vert.glsl") + .fragment_source("overlay_extra_frag.glsl") .additional_info("draw_mesh", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_gpencil_canvas_clipped) @@ -289,7 +289,7 @@ GPU_SHADER_CREATE_INFO(overlay_particle) .vertex_in(1, Type::VEC4, "part_rot") .vertex_in(2, Type::FLOAT, "part_val") .vertex_out(overlay_particle_iface) - .vertex_source("particle_vert.glsl") + .vertex_source("overlay_particle_vert.glsl") .additional_info("draw_globals"); GPU_SHADER_CREATE_INFO(overlay_particle_dot) @@ -299,7 +299,7 @@ GPU_SHADER_CREATE_INFO(overlay_particle_dot) .define("pos", "vec3(0.0)") .fragment_out(0, Type::VEC4, "fragColor") .fragment_out(1, Type::VEC4, "lineOutput") - .fragment_source("particle_frag.glsl") + .fragment_source("overlay_particle_frag.glsl") .additional_info("overlay_particle", "draw_mesh"); GPU_SHADER_CREATE_INFO(overlay_particle_dot_clipped) diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_facing_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_facing_info.hh index 6d6806eaa80..6d528bbba62 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_facing_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_facing_info.hh @@ -5,8 +5,8 @@ GPU_SHADER_CREATE_INFO(overlay_facing) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") - .vertex_source("facing_vert.glsl") - .fragment_source("facing_frag.glsl") + .vertex_source("overlay_facing_vert.glsl") + .fragment_source("overlay_facing_frag.glsl") .fragment_out(0, Type::VEC4, "fragColor") .additional_info("draw_mesh", "draw_globals"); 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 d02014c98a0..39433b466d2 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 @@ -15,8 +15,8 @@ GPU_SHADER_CREATE_INFO(overlay_grid) .uniform_buf(3, "OVERLAY_GridData", "grid_buf") .push_constant(Type::VEC3, "plane_axes") .push_constant(Type::INT, "grid_flag") - .vertex_source("grid_vert.glsl") - .fragment_source("grid_frag.glsl") + .vertex_source("overlay_grid_vert.glsl") + .fragment_source("overlay_grid_frag.glsl") .additional_info("draw_view", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_grid_background) @@ -25,8 +25,8 @@ GPU_SHADER_CREATE_INFO(overlay_grid_background) .sampler(0, ImageType::DEPTH_2D, "depthBuffer") .push_constant(Type::VEC4, "color") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_uv_tiled_image_borders_vert.glsl") - .fragment_source("grid_background_frag.glsl") + .vertex_source("overlay_edit_uv_tiled_image_borders_vert.glsl") + .fragment_source("overlay_grid_background_frag.glsl") .additional_info("draw_modelmat"); GPU_SHADER_CREATE_INFO(overlay_grid_image) @@ -36,6 +36,6 @@ GPU_SHADER_CREATE_INFO(overlay_grid_image) .vertex_in(0, Type::VEC3, "pos") .push_constant(Type::VEC4, "color") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("edit_uv_tiled_image_borders_vert.glsl") + .vertex_source("overlay_edit_uv_tiled_image_borders_vert.glsl") .fragment_source("gpu_shader_uniform_color_frag.glsl") .additional_info("draw_modelmat"); 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 21575747efa..6f6a9c1622d 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 @@ -13,13 +13,13 @@ GPU_SHADER_CREATE_INFO(overlay_outline_prepass) .vertex_out(overlay_outline_prepass_iface) /* Using uint because 16bit uint can contain more ids than int. */ .fragment_out(0, Type::UINT, "out_object_id") - .fragment_source("outline_prepass_frag.glsl") + .fragment_source("overlay_outline_prepass_frag.glsl") .additional_info("draw_resource_handle"); GPU_SHADER_CREATE_INFO(overlay_outline_prepass_mesh) .do_static_compilation(true) .vertex_in(0, Type::VEC3, "pos") - .vertex_source("outline_prepass_vert.glsl") + .vertex_source("overlay_outline_prepass_vert.glsl") .additional_info("draw_mesh", "overlay_outline_prepass") .additional_info("draw_object_infos"); @@ -36,8 +36,8 @@ GPU_SHADER_CREATE_INFO(overlay_outline_prepass_wire) .vertex_out(overlay_outline_prepass_wire_iface) .geometry_layout(PrimitiveIn::LINES_ADJACENCY, PrimitiveOut::LINE_STRIP, 2) .geometry_out(overlay_outline_prepass_iface) - .vertex_source("outline_prepass_vert.glsl") - .geometry_source("outline_prepass_geom.glsl") + .vertex_source("overlay_outline_prepass_vert.glsl") + .geometry_source("overlay_outline_prepass_geom.glsl") .additional_info("draw_mesh", "overlay_outline_prepass") .additional_info("draw_object_infos"); @@ -56,12 +56,12 @@ GPU_SHADER_CREATE_INFO(overlay_outline_prepass_gpencil) .push_constant(Type::BOOL, "isTransform") .vertex_out(overlay_outline_prepass_iface) .vertex_out(overlay_outline_prepass_gpencil_iface) - .vertex_source("outline_prepass_gpencil_vert.glsl") + .vertex_source("overlay_outline_prepass_gpencil_vert.glsl") .push_constant(Type::BOOL, "gpStrokeOrder3d") /* TODO(fclem): Move to a GPencil object UBO. */ .push_constant(Type::VEC4, "gpDepthPlane") /* TODO(fclem): Move to a GPencil object UBO. */ /* Using uint because 16bit uint can contain more ids than int. */ .fragment_out(0, Type::UINT, "out_object_id") - .fragment_source("outline_prepass_gpencil_frag.glsl") + .fragment_source("overlay_outline_prepass_gpencil_frag.glsl") .additional_info("draw_gpencil", "draw_resource_handle"); GPU_SHADER_CREATE_INFO(overlay_outline_prepass_gpencil_clipped) @@ -70,7 +70,7 @@ GPU_SHADER_CREATE_INFO(overlay_outline_prepass_gpencil_clipped) GPU_SHADER_CREATE_INFO(overlay_outline_prepass_pointcloud) .do_static_compilation(true) - .vertex_source("outline_prepass_pointcloud_vert.glsl") + .vertex_source("overlay_outline_prepass_pointcloud_vert.glsl") .additional_info("draw_pointcloud", "overlay_outline_prepass") .additional_info("draw_object_infos"); @@ -95,7 +95,7 @@ GPU_SHADER_CREATE_INFO(overlay_outline_detect) .sampler(2, ImageType::DEPTH_2D, "sceneDepth") .fragment_out(0, Type::VEC4, "fragColor") .fragment_out(1, Type::VEC4, "lineOutput") - .fragment_source("outline_detect_frag.glsl") + .fragment_source("overlay_outline_detect_frag.glsl") .additional_info("draw_fullscreen", "draw_view", "draw_globals"); /** \} */ 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 bbec79d515f..207f18523a0 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 @@ -15,7 +15,7 @@ GPU_SHADER_CREATE_INFO(overlay_paint_face) .vertex_in(1, Type::VEC4, "nor") /* Select flag on the 4th component. */ .push_constant(Type::VEC4, "color") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("paint_face_vert.glsl") + .vertex_source("overlay_paint_face_vert.glsl") .fragment_source("gpu_shader_uniform_color_frag.glsl") .additional_info("draw_modelmat"); @@ -40,7 +40,7 @@ GPU_SHADER_CREATE_INFO(overlay_paint_point) .vertex_in(1, Type::VEC4, "nor") /* Select flag on the 4th component. */ .vertex_out(overlay_overlay_paint_point_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("paint_point_vert.glsl") + .vertex_source("overlay_paint_point_vert.glsl") .fragment_source("gpu_shader_point_varying_color_frag.glsl") .additional_info("draw_modelmat", "draw_globals"); @@ -70,8 +70,8 @@ GPU_SHADER_CREATE_INFO(overlay_paint_texture) .push_constant(Type::BOOL, "maskInvertStencil") .push_constant(Type::BOOL, "maskImagePremultiplied") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("paint_texture_vert.glsl") - .fragment_source("paint_texture_frag.glsl") + .vertex_source("overlay_paint_texture_vert.glsl") + .fragment_source("overlay_paint_texture_frag.glsl") .additional_info("draw_modelmat"); GPU_SHADER_CREATE_INFO(overlay_paint_texture_clipped) @@ -97,8 +97,8 @@ GPU_SHADER_CREATE_INFO(overlay_paint_vertcol) .push_constant(Type::FLOAT, "opacity") /* `1.0` by default. */ .push_constant(Type::BOOL, "useAlphaBlend") /* `false` by default. */ .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("paint_vertcol_vert.glsl") - .fragment_source("paint_vertcol_frag.glsl") + .vertex_source("overlay_paint_vertcol_vert.glsl") + .fragment_source("overlay_paint_vertcol_frag.glsl") .additional_info("draw_modelmat"); GPU_SHADER_CREATE_INFO(overlay_paint_vertcol_clipped) @@ -129,8 +129,8 @@ GPU_SHADER_CREATE_INFO(overlay_paint_weight) .push_constant(Type::FLOAT, "opacity") /* `1.0` by default. */ .push_constant(Type::BOOL, "drawContours") /* `false` by default. */ .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("paint_weight_vert.glsl") - .fragment_source("paint_weight_frag.glsl") + .vertex_source("overlay_paint_weight_vert.glsl") + .fragment_source("overlay_paint_weight_frag.glsl") .additional_info("draw_modelmat", "draw_globals"); GPU_SHADER_CREATE_INFO(overlay_paint_weight_fake_shading) @@ -168,7 +168,7 @@ GPU_SHADER_CREATE_INFO(overlay_paint_wire) .vertex_out(overlay_paint_wire_iface) .push_constant(Type::BOOL, "useSelect") .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("paint_wire_vert.glsl") + .vertex_source("overlay_paint_wire_vert.glsl") .fragment_source("gpu_shader_flat_color_frag.glsl") .additional_info("draw_modelmat", "draw_globals"); diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_sculpt_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_sculpt_info.hh index d4f1ca44362..3a53bd388a6 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_sculpt_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_sculpt_info.hh @@ -15,8 +15,8 @@ GPU_SHADER_CREATE_INFO(overlay_sculpt_mask) .vertex_in(1, Type::VEC3, "fset") .vertex_in(2, Type::FLOAT, "msk") .vertex_out(overlay_sculpt_mask_iface) - .vertex_source("sculpt_mask_vert.glsl") - .fragment_source("sculpt_mask_frag.glsl") + .vertex_source("overlay_sculpt_mask_vert.glsl") + .fragment_source("overlay_sculpt_mask_frag.glsl") .fragment_out(0, Type::VEC4, "fragColor") .additional_info("draw_mesh", "draw_object_infos", "draw_globals"); diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_volume_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_volume_info.hh index 5853e974eeb..b142ccbad1b 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_volume_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_volume_info.hh @@ -28,7 +28,7 @@ GPU_SHADER_CREATE_INFO(overlay_volume_velocity) .push_constant(Type::IVEC3, "adaptiveCellOffset") .vertex_out(overlay_volume_velocity_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("volume_velocity_vert.glsl") + .vertex_source("overlay_volume_velocity_vert.glsl") .fragment_source("gpu_shader_3D_smooth_color_frag.glsl") .additional_info("draw_volume"); @@ -69,7 +69,7 @@ GPU_SHADER_CREATE_INFO(overlay_volume_gridlines) .push_constant(Type::IVEC3, "adaptiveCellOffset") .vertex_out(overlay_volume_gridlines_iface) .fragment_out(0, Type::VEC4, "fragColor") - .vertex_source("volume_gridlines_vert.glsl") + .vertex_source("overlay_volume_gridlines_vert.glsl") .fragment_source("gpu_shader_flat_color_frag.glsl") .additional_info("draw_volume"); diff --git a/source/blender/draw/engines/overlay/shaders/infos/overlay_wireframe_info.hh b/source/blender/draw/engines/overlay/shaders/infos/overlay_wireframe_info.hh index 16b59f6bb7d..1899b191741 100644 --- a/source/blender/draw/engines/overlay/shaders/infos/overlay_wireframe_info.hh +++ b/source/blender/draw/engines/overlay/shaders/infos/overlay_wireframe_info.hh @@ -23,8 +23,8 @@ GPU_SHADER_CREATE_INFO(overlay_wireframe) .vertex_in(1, Type::VEC3, "nor") .vertex_in(2, Type::FLOAT, "wd") /* wire-data. */ .vertex_out(overlay_wireframe_iface) - .vertex_source("wireframe_vert.glsl") - .fragment_source("wireframe_frag.glsl") + .vertex_source("overlay_wireframe_vert.glsl") + .fragment_source("overlay_wireframe_frag.glsl") .fragment_out(0, Type::VEC4, "fragColor") .fragment_out(1, Type::VEC4, "lineOutput") .additional_info("draw_mesh", "draw_object_infos", "draw_globals"); diff --git a/source/blender/draw/engines/overlay/shaders/motion_path_line_frag.glsl b/source/blender/draw/engines/overlay/shaders/motion_path_line_frag.glsl deleted file mode 100644 index 324d22501f9..00000000000 --- a/source/blender/draw/engines/overlay/shaders/motion_path_line_frag.glsl +++ /dev/null @@ -1,5 +0,0 @@ - -void main() -{ - fragColor = interp.color; -} diff --git a/source/blender/draw/engines/overlay/shaders/motion_path_line_geom.glsl b/source/blender/draw/engines/overlay/shaders/motion_path_line_geom.glsl deleted file mode 100644 index 29346a44863..00000000000 --- a/source/blender/draw/engines/overlay/shaders/motion_path_line_geom.glsl +++ /dev/null @@ -1,37 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -vec2 compute_dir(vec2 v0, vec2 v1) -{ - vec2 dir = normalize(v1 - v0 + 1e-8); - dir = vec2(-dir.y, dir.x); - return dir; -} - -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; - - bool is_persp = (ProjectionMatrix[3][3] == 0.0); - float line_size = float(lineThickness) * sizePixel; - - view_clipping_distances_set(gl_in[0]); - interp_out.color = interp_in[0].color; - t = edge_dir * (line_size * (is_persp ? gl_in[0].gl_Position.w : 1.0)); - gl_Position = gl_in[0].gl_Position + vec4(t, 0.0, 0.0); - EmitVertex(); - gl_Position = gl_in[0].gl_Position - vec4(t, 0.0, 0.0); - EmitVertex(); - - view_clipping_distances_set(gl_in[1]); - interp_out.color = interp_in[1].color; - t = edge_dir * (line_size * (is_persp ? gl_in[1].gl_Position.w : 1.0)); - gl_Position = gl_in[1].gl_Position + vec4(t, 0.0, 0.0); - EmitVertex(); - gl_Position = gl_in[1].gl_Position - vec4(t, 0.0, 0.0); - EmitVertex(); - EndPrimitive(); -} diff --git a/source/blender/draw/engines/overlay/shaders/motion_path_line_vert.glsl b/source/blender/draw/engines/overlay/shaders/motion_path_line_vert.glsl deleted file mode 100644 index bc74a436f5e..00000000000 --- a/source/blender/draw/engines/overlay/shaders/motion_path_line_vert.glsl +++ /dev/null @@ -1,87 +0,0 @@ - -#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) - -void main() -{ - gl_Position = ViewProjectionMatrix * vec4(pos, 1.0); - - interp.ss_pos = proj(gl_Position); - - int frame = gl_VertexID + 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 */ - interp.color.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); - } - interp.color.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 */ - interp.color.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); - } - - interp.color.rgb = mix(colorBonePose.rgb, blend_base, intensity); - } - } - else { - if (use_custom_color) { - /* Custom color: current frame color is slightly darker than user selected color */ - interp.color.rgb = customColor * 0.5; - } - else { - /* green - on frameCurrent */ - if (selected) { - intensity = 0.92f; - } - else { - intensity = 0.75f; - } - interp.color.rgb = mix(colorBackground.rgb, blend_base, intensity); - } - } - - interp.color.a = 1.0; - - view_clipping_distances(pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/motion_path_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/motion_path_point_vert.glsl deleted file mode 100644 index 5027525b9b3..00000000000 --- a/source/blender/draw/engines/overlay/shaders/motion_path_point_vert.glsl +++ /dev/null @@ -1,47 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -#define pointSize mpathPointSettings.x -#define frameCurrent mpathPointSettings.y -#define cacheStart mpathPointSettings.z -#define stepSize mpathPointSettings.w - -void main() -{ - gl_Position = ViewProjectionMatrix * vec4(pos, 1.0); - gl_PointSize = float(pointSize + 2); - - int frame = gl_VertexID + cacheStart; - bool use_custom_color = customColor.x >= 0.0; - finalColor = (use_custom_color) ? vec4(customColor, 1.0) : vec4(1.0); - - /* Bias to reduce z fighting with the path */ - gl_Position.z -= 1e-4; - - if (gl_VertexID % stepSize == 0) { - gl_PointSize = float(pointSize) + 4; - } - - if (showKeyFrames) { - if ((flag & MOTIONPATH_VERT_KEY) != 0) { - gl_PointSize = float(pointSize + 5); - finalColor = colorVertexSelect; - /* Bias more to get these on top of regular points */ - gl_Position.z -= 1e-4; - } - /* Draw big green dot where the current frame is. - * NOTE: this is only done when keyframes are shown, since this adds similar types of clutter - */ - if (frame == frameCurrent) { - gl_PointSize = float(pointSize + 8); - finalColor = colorCurrentFrame; - /* Bias more to get these on top of keyframes */ - gl_Position.z -= 1e-4; - } - } - - gl_PointSize *= sizePixel; - - view_clipping_distances(pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/outline_detect_frag.glsl b/source/blender/draw/engines/overlay/shaders/outline_detect_frag.glsl deleted file mode 100644 index 472a589f441..00000000000 --- a/source/blender/draw/engines/overlay/shaders/outline_detect_frag.glsl +++ /dev/null @@ -1,360 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -#define XPOS (1 << 0) -#define XNEG (1 << 1) -#define YPOS (1 << 2) -#define YNEG (1 << 3) - -#define ALL (XPOS | XNEG | YPOS | YNEG) -#define NONE 0 - -#define DIAG_XNEG_YPOS (XNEG | YPOS) -#define DIAG_XPOS_YPOS (XPOS | YPOS) -#define DIAG_XPOS_YNEG (XPOS | YNEG) -#define DIAG_XNEG_YNEG (XNEG | YNEG) - -#define APEX_XPOS (ALL & (~XPOS)) -#define APEX_XNEG (ALL & (~XNEG)) -#define APEX_YPOS (ALL & (~YPOS)) -#define APEX_YNEG (ALL & (~YNEG)) - -bool has_edge(uint id, vec2 uv, uint ref, inout uint ref_col, inout vec2 depth_uv) -{ - if (ref_col == 0u) { - /* Make outline bleed on the background. */ - ref_col = id; - depth_uv = uv; - } - return (id != ref); -} - -/* A gather4 + check against ref. */ -bvec4 gather_edges(vec2 uv, uint ref) -{ - uvec4 ids; -#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; - 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; - ids.w = textureLod(outlineId, uv - ofs.xy, 0.0).r; -#endif - - return notEqual(ids, uvec4(ref)); -} - -/* Clockwise */ -vec2 rotate_90(vec2 v) -{ - return vec2(v.y, -v.x); -} -vec2 rotate_180(vec2 v) -{ - return vec2(-v.x, -v.y); -} -vec2 rotate_270(vec2 v) -{ - return vec2(-v.y, v.x); -} - -/* Counter-Clockwise */ -bvec4 rotate_90(bvec4 v) -{ - return v.yzwx; -} -bvec4 rotate_180(bvec4 v) -{ - return v.zwxy; -} -bvec4 rotate_270(bvec4 v) -{ - return v.wxyz; -} - -/* Apply offset to line endpoint based on surrounding edges infos. */ -bool line_offset(bvec2 edges, vec2 ofs, inout vec2 line_point) -{ - if (all(edges.xy)) { - line_point.y -= ofs.y; - } - else if (!edges.x) { - line_point.y += ofs.y; - } - else /* !edges.y */ { - line_point.x += ofs.x; - return true; - } - return false; -} - -/* Changes Antialiasing pattern and makes line thicker. 0.0 is thin. */ -#define PROXIMITY_OFS -0.35 - -/* Use surrounding edges to approximate the outline direction to create smooth lines. */ -void straight_line_dir(bvec4 edges1, bvec4 edges2, out vec2 line_start, out vec2 line_end) -{ - /* Y_POS as reference. Other cases are rotated to match reference. */ - line_end = vec2(1.5, 0.5 + PROXIMITY_OFS); - line_start = vec2(-line_end.x, line_end.y); - - vec2 line_ofs = vec2(1.0, 0.5); - if (line_offset(edges1.xw, line_ofs, line_end)) { - line_offset(edges1.yz, line_ofs, line_end); - } - line_ofs = vec2(-line_ofs.x, line_ofs.y); - if (line_offset(edges2.yz, line_ofs, line_start)) { - line_offset(edges2.xw, line_ofs, line_start); - } -} - -vec2 diag_offset(bvec4 edges) -{ - /* X_NEG | Y_POS as reference. Other cases are rotated to match reference. - * So the line is coming from bottom left. */ - if (all(edges.wz)) { - /* Horizontal line. */ - return vec2(2.5, 0.5); - } - else if (all(not(edges.xw))) { - /* Vertical line. */ - return vec2(0.5, 2.5); - } - else if (edges.w) { - /* Less horizontal Line. */ - return vec2(2.5, 0.5); - } - else { - /* Less vertical Line. */ - return vec2(0.5, 2.5); - } -} - -/* Compute line direction vector from the bottom left corner. */ -void diag_dir(bvec4 edges1, bvec4 edges2, out vec2 line_start, out vec2 line_end) -{ - /* Negate instead of rotating back the result of diag_offset. */ - edges2 = not(edges2); - edges2 = rotate_180(edges2); - line_end = diag_offset(edges1); - line_end += diag_offset(edges2); - - if (line_end.x == line_end.y) { - /* Perfect diagonal line. Push line start towards edge. */ - line_start = vec2(-1.0, 1.0) * PROXIMITY_OFS * 0.4; - } - else if (line_end.x > line_end.y) { - /* Horizontal Line. Lower line start. */ - line_start = vec2(0.0, PROXIMITY_OFS); - } - else { - /* Vertical Line. Push line start to the right. */ - line_start = -vec2(PROXIMITY_OFS, 0.0); - } - line_end += line_start; -} - -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 depth_uv = uvs; - - uvec4 ids; -#ifdef GPU_ARB_texture_gather - /* Reminder: Samples order is CW starting from top left. */ - uvec2 tmp1, tmp2, tmp3, tmp4; - if (doThickOutlines) { - tmp1 = textureGather(outlineId, uvs + ofs.xy * vec2(1.5, -0.5)).xy; - tmp2 = textureGather(outlineId, uvs + ofs.xy * vec2(-1.5, -0.5)).yx; - tmp3 = textureGather(outlineId, uvs + ofs.xy * vec2(0.5, 1.5)).wx; - tmp4 = textureGather(outlineId, uvs + ofs.xy * vec2(0.5, -1.5)).xw; - ids.x = tmp1.x; - ids.y = tmp2.x; - ids.z = tmp3.x; - ids.w = tmp4.x; - } - else { - ids.xz = textureGather(outlineId, uvs + ofs.xy * 0.5).zx; - ids.yw = textureGather(outlineId, uvs - ofs.xy * 0.5).xz; - } -#else - ids.x = textureLod(outlineId, uvs + ofs.xz, 0.0).r; - ids.y = textureLod(outlineId, uvs - ofs.xz, 0.0).r; - ids.z = textureLod(outlineId, uvs + ofs.zy, 0.0).r; - ids.w = textureLod(outlineId, uvs - ofs.zy, 0.0).r; -#endif - - bool has_edge_pos_x = has_edge(ids.x, uvs + ofs.xz, ref, ref_col, depth_uv); - bool has_edge_neg_x = has_edge(ids.y, uvs - ofs.xz, ref, ref_col, depth_uv); - bool has_edge_pos_y = has_edge(ids.z, uvs + ofs.zy, ref, ref_col, depth_uv); - bool has_edge_neg_y = has_edge(ids.w, uvs - ofs.zy, ref, ref_col, depth_uv); - - if (doThickOutlines) { - if (!any(bvec4(has_edge_pos_x, has_edge_neg_x, has_edge_pos_y, has_edge_neg_y))) { -#ifdef GPU_ARB_texture_gather - ids.x = tmp1.y; - ids.y = tmp2.y; - ids.z = tmp3.y; - ids.w = tmp4.y; -#else - ids.x = textureLod(outlineId, uvs + 2.0 * ofs.xz, 0.0).r; - ids.y = textureLod(outlineId, uvs - 2.0 * ofs.xz, 0.0).r; - ids.z = textureLod(outlineId, uvs + 2.0 * ofs.zy, 0.0).r; - ids.w = textureLod(outlineId, uvs - 2.0 * ofs.zy, 0.0).r; -#endif - - has_edge_pos_x = has_edge(ids.x, uvs + 2.0 * ofs.xz, ref, ref_col, depth_uv); - has_edge_neg_x = has_edge(ids.y, uvs - 2.0 * ofs.xz, ref, ref_col, depth_uv); - has_edge_pos_y = has_edge(ids.z, uvs + 2.0 * ofs.zy, ref, ref_col, depth_uv); - has_edge_neg_y = has_edge(ids.w, uvs - 2.0 * ofs.zy, ref, ref_col, depth_uv); - } - } - - if (isXrayWires) { - /* Don't inflate the wire outlines too much. */ - has_edge_neg_x = has_edge_neg_y = false; - } - - /* WATCH: Keep in sync with outlineId of the prepass. */ - uint color_id = ref_col >> 14u; - if (ref_col == 0u) { - fragColor = vec4(0.0); - } - else if (color_id == 1u) { - fragColor = colorSelect; - } - else if (color_id == 3u) { - fragColor = colorActive; - } - else { - fragColor = colorTransform; - } - - float ref_depth = textureLod(outlineDepth, depth_uv, 0.0).r; - float scene_depth = textureLod(sceneDepth, depth_uv, 0.0).r; - - /* Avoid bad cases of zfighting for occlusion only. */ - const float epsilon = 3.0 / 8388608.0; - bool occluded = (ref_depth > scene_depth + epsilon); - - /* NOTE: We never set alpha to 1.0 to avoid Antialiasing destroying the line. */ - fragColor *= (occluded ? alphaOcclu : 1.0) * (254.0 / 255.0); - - int edge_case = 0; - edge_case += int(has_edge_pos_x) * XPOS; - edge_case += int(has_edge_neg_x) * XNEG; - edge_case += int(has_edge_pos_y) * YPOS; - edge_case += int(has_edge_neg_y) * YNEG; - - if (edge_case == ALL || edge_case == NONE) { - discard; - } - - if (!doAntiAliasing) { - lineOutput = vec4(0.0); - return; - } - - vec2 line_start, line_end; - vec2 line_ofs; - bvec4 extra_edges, extra_edges2; - /* TODO: simplify this branching hell. */ - 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); - 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 = rotate_180(extra_edges); - extra_edges2 = rotate_180(extra_edges2); - straight_line_dir(extra_edges, extra_edges2, line_start, line_end); - line_start = rotate_180(line_start); - 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 = rotate_90(extra_edges); - extra_edges2 = rotate_90(extra_edges2); - straight_line_dir(extra_edges, extra_edges2, line_start, line_end); - line_start = rotate_90(line_start); - 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 = rotate_270(extra_edges); - extra_edges2 = rotate_270(extra_edges2); - straight_line_dir(extra_edges, extra_edges2, line_start, line_end); - line_start = rotate_270(line_start); - line_end = rotate_270(line_end); - break; - - /* Diagonal */ - case DIAG_XNEG_YPOS: - extra_edges = gather_edges(uvs + ofs.xy * vec2(1.5), ref); - extra_edges2 = gather_edges(uvs + ofs.xy * vec2(-1.5), ref); - diag_dir(extra_edges, extra_edges2, line_start, line_end); - break; - case DIAG_XPOS_YNEG: - extra_edges = gather_edges(uvs - ofs.xy * vec2(1.5), ref); - extra_edges2 = gather_edges(uvs - ofs.xy * vec2(-1.5), ref); - extra_edges = rotate_180(extra_edges); - extra_edges2 = rotate_180(extra_edges2); - diag_dir(extra_edges, extra_edges2, line_start, line_end); - line_start = rotate_180(line_start); - line_end = rotate_180(line_end); - break; - case DIAG_XPOS_YPOS: - extra_edges = gather_edges(uvs + ofs.xy * vec2(1.5, -1.5), ref); - extra_edges2 = gather_edges(uvs - ofs.xy * vec2(1.5, -1.5), ref); - extra_edges = rotate_90(extra_edges); - extra_edges2 = rotate_90(extra_edges2); - diag_dir(extra_edges, extra_edges2, line_start, line_end); - line_start = rotate_90(line_start); - line_end = rotate_90(line_end); - break; - case DIAG_XNEG_YNEG: - extra_edges = gather_edges(uvs - ofs.xy * vec2(1.5, -1.5), ref); - extra_edges2 = gather_edges(uvs + ofs.xy * vec2(1.5, -1.5), ref); - extra_edges = rotate_270(extra_edges); - extra_edges2 = rotate_270(extra_edges2); - diag_dir(extra_edges, extra_edges2, line_start, line_end); - line_start = rotate_270(line_start); - line_end = rotate_270(line_end); - break; - - /* Apex */ - case APEX_XPOS: - case APEX_XNEG: - line_start = vec2(-0.5, 0.0); - line_end = vec2(0.5, 0.0); - break; - case APEX_YPOS: - case APEX_YNEG: - line_start = vec2(0.0, -0.5); - line_end = vec2(0.0, 0.5); - break; - default: - /* Ensure values are assigned to, avoids undefined behavior for - * divergent control-flow. This can occur if discard is called - * as discard is not treated as a return in Metal 2.2. So - * side-effects can still cause problems. */ - line_start = vec2(0.0); - line_end = vec2(0.0); - break; - } - - lineOutput = pack_line_data(vec2(0.0), line_start, line_end); -} diff --git a/source/blender/draw/engines/overlay/shaders/outline_prepass_frag.glsl b/source/blender/draw/engines/overlay/shaders/outline_prepass_frag.glsl deleted file mode 100644 index d1abd74a7b3..00000000000 --- a/source/blender/draw/engines/overlay/shaders/outline_prepass_frag.glsl +++ /dev/null @@ -1,5 +0,0 @@ - -void main() -{ - out_object_id = interp.ob_id; -} diff --git a/source/blender/draw/engines/overlay/shaders/outline_prepass_geom.glsl b/source/blender/draw/engines/overlay/shaders/outline_prepass_geom.glsl deleted file mode 100644 index 8a196620af9..00000000000 --- a/source/blender/draw/engines/overlay/shaders/outline_prepass_geom.glsl +++ /dev/null @@ -1,47 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void vert_from_gl_in(int v) -{ - gl_Position = gl_in[v].gl_Position; - interp_out.ob_id = interp_in[v].ob_id; - view_clipping_distances_set(gl_in[v]); -} - -void main() -{ - bool is_persp = (ProjectionMatrix[3][3] == 0.0); - - vec3 view_vec = (is_persp) ? normalize(vert[1].pos) : vec3(0.0, 0.0, -1.0); - - vec3 v10 = vert[0].pos - vert[1].pos; - vec3 v12 = vert[2].pos - vert[1].pos; - vec3 v13 = vert[3].pos - vert[1].pos; - - vec3 n0 = cross(v12, v10); - vec3 n3 = cross(v13, v12); - - float fac0 = dot(view_vec, n0); - float fac3 = dot(view_vec, n3); - - /* If both adjacent verts are facing the camera the same way, - * then it isn't an outline edge. */ - if (sign(fac0) == sign(fac3)) { - return; - } - - /* Don't outline if concave edge. */ - /* That would hide a lot of non useful edge but it flickers badly. - * TODO: revisit later... */ - // if (dot(n0, v13) > 0.01) - // return; - - vert_from_gl_in(1); - EmitVertex(); - - vert_from_gl_in(2); - EmitVertex(); - - EndPrimitive(); -} diff --git a/source/blender/draw/engines/overlay/shaders/outline_prepass_gpencil_frag.glsl b/source/blender/draw/engines/overlay/shaders/outline_prepass_gpencil_frag.glsl deleted file mode 100644 index b6d5cd96c12..00000000000 --- a/source/blender/draw/engines/overlay/shaders/outline_prepass_gpencil_frag.glsl +++ /dev/null @@ -1,42 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_gpencil_lib.glsl) - -vec3 ray_plane_intersection(vec3 ray_ori, vec3 ray_dir, vec4 plane) -{ - float d = dot(plane.xyz, ray_dir); - vec3 plane_co = plane.xyz * (-plane.w / dot(plane.xyz, plane.xyz)); - vec3 h = ray_ori - plane_co; - float lambda = -dot(plane.xyz, h) / ((abs(d) < 1e-8) ? 1e-8 : d); - return ray_ori + ray_dir * lambda; -} - -void main() -{ - if (gpencil_stroke_round_cap_mask(gp_interp.sspos.xy, - gp_interp.sspos.zw, - gp_interp.aspect, - gp_interp.thickness.x, - gp_interp.hardness) < 0.001) { - discard; - } - - if (!gpStrokeOrder3d) { - /* Stroke order 2D. Project to gpDepthPlane. */ - bool is_persp = ProjectionMatrix[3][3] == 0.0; - vec2 uvs = vec2(gl_FragCoord.xy) * drw_view.viewport_size_inverse; - vec3 pos_ndc = vec3(uvs, gl_FragCoord.z) * 2.0 - 1.0; - vec4 pos_world = ViewProjectionMatrixInverse * vec4(pos_ndc, 1.0); - vec3 pos = pos_world.xyz / pos_world.w; - - vec3 ray_ori = pos; - vec3 ray_dir = (is_persp) ? (ViewMatrixInverse[3].xyz - pos) : ViewMatrixInverse[2].xyz; - vec3 isect = ray_plane_intersection(ray_ori, ray_dir, gpDepthPlane); - vec4 ndc = point_world_to_ndc(isect); - gl_FragDepth = (ndc.z / ndc.w) * 0.5 + 0.5; - } - else { - gl_FragDepth = gl_FragCoord.z; - } - - out_object_id = interp.ob_id; -} diff --git a/source/blender/draw/engines/overlay/shaders/outline_prepass_gpencil_vert.glsl b/source/blender/draw/engines/overlay/shaders/outline_prepass_gpencil_vert.glsl deleted file mode 100644 index 4b1470e5723..00000000000 --- a/source/blender/draw/engines/overlay/shaders/outline_prepass_gpencil_vert.glsl +++ /dev/null @@ -1,74 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) -#pragma BLENDER_REQUIRE(common_gpencil_lib.glsl) - -uint outline_colorid_get(void) -{ - int flag = int(abs(ObjectInfo.w)); - bool is_active = (flag & DRW_BASE_ACTIVE) != 0; - - if (isTransform) { - return 0u; /* colorTransform */ - } - else if (is_active) { - return 3u; /* colorActive */ - } - else { - return 1u; /* colorSelect */ - } - - return 0u; -} - -/* Replace top 2 bits (of the 16bit output) by outlineId. - * This leaves 16K different IDs to create outlines between objects. - * SHIFT = (32 - (16 - 2)) */ -#define SHIFT 18u - -void main() -{ - vec3 world_pos; - vec3 unused_N; - vec4 unused_color; - 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), - world_pos, - unused_N, - unused_color, - unused_strength, - unused_uv, - gp_interp.sspos, - gp_interp.aspect, - gp_interp.thickness, - gp_interp.hardness); - - /* Small bias to always be on top of the geom. */ - gl_Position.z -= 1e-3; - - /* ID 0 is nothing (background) */ - interp.ob_id = uint(resource_handle + 1); - - /* Should be 2 bits only [0..3]. */ - uint outline_id = outline_colorid_get(); - - /* Combine for 16bit uint target. */ - interp.ob_id = (outline_id << 14u) | ((interp.ob_id << SHIFT) >> SHIFT); - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/outline_prepass_pointcloud_vert.glsl b/source/blender/draw/engines/overlay/shaders/outline_prepass_pointcloud_vert.glsl deleted file mode 100644 index 371ff628c59..00000000000 --- a/source/blender/draw/engines/overlay/shaders/outline_prepass_pointcloud_vert.glsl +++ /dev/null @@ -1,48 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) -#pragma BLENDER_REQUIRE(common_pointcloud_lib.glsl) - -uint outline_colorid_get(void) -{ - int flag = int(abs(ObjectInfo.w)); - bool is_active = (flag & DRW_BASE_ACTIVE) != 0; - - if (isTransform) { - return 0u; /* colorTransform */ - } - else if (is_active) { - return 3u; /* colorActive */ - } - else { - return 1u; /* colorSelect */ - } - - return 0u; -} - -/* Replace top 2 bits (of the 16bit output) by outlineId. - * This leaves 16K different IDs to create outlines between objects. - * SHIFT = (32 - (16 - 2)) */ -#define SHIFT 18u - -void main() -{ - vec3 world_pos = pointcloud_get_pos(); - - gl_Position = point_world_to_ndc(world_pos); - - /* Small bias to always be on top of the geom. */ - gl_Position.z -= 1e-3; - - /* ID 0 is nothing (background) */ - interp.ob_id = uint(resource_handle + 1); - - /* Should be 2 bits only [0..3]. */ - uint outline_id = outline_colorid_get(); - - /* Combine for 16bit uint target. */ - interp.ob_id = (outline_id << 14u) | ((interp.ob_id << SHIFT) >> SHIFT); - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/outline_prepass_vert.glsl b/source/blender/draw/engines/overlay/shaders/outline_prepass_vert.glsl deleted file mode 100644 index 1d0b08f51b2..00000000000 --- a/source/blender/draw/engines/overlay/shaders/outline_prepass_vert.glsl +++ /dev/null @@ -1,50 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -uint outline_colorid_get(void) -{ - int flag = int(abs(ObjectInfo.w)); - bool is_active = (flag & DRW_BASE_ACTIVE) != 0; - - if (isTransform) { - return 0u; /* colorTransform */ - } - else if (is_active) { - return 3u; /* colorActive */ - } - else { - return 1u; /* colorSelect */ - } - - return 0u; -} - -/* Replace top 2 bits (of the 16bit output) by outlineId. - * This leaves 16K different IDs to create outlines between objects. - * SHIFT = (32 - (16 - 2)) */ -#define SHIFT 18u - -void main() -{ - vec3 world_pos = point_object_to_world(pos); - - gl_Position = point_world_to_ndc(world_pos); -#ifdef USE_GEOM - vert.pos = point_world_to_view(world_pos); -#endif - - /* Small bias to always be on top of the geom. */ - gl_Position.z -= 1e-3; - - /* ID 0 is nothing (background) */ - interp.ob_id = uint(resource_handle + 1); - - /* Should be 2 bits only [0..3]. */ - uint outline_id = outline_colorid_get(); - - /* Combine for 16bit uint target. */ - interp.ob_id = (outline_id << 14u) | ((interp.ob_id << SHIFT) >> SHIFT); - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_antialiasing_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_antialiasing_frag.glsl new file mode 100644 index 00000000000..f28a809fdab --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_antialiasing_frag.glsl @@ -0,0 +1,146 @@ + +#pragma BLENDER_REQUIRE(common_math_lib.glsl) + +#define M_1_SQRTPI 0.5641895835477563 /* 1/sqrt(pi) */ + +/** + * 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. + */ +#define DISC_RADIUS (M_1_SQRTPI * 1.05) +#define LINE_SMOOTH_START (0.5 - DISC_RADIUS) +#define LINE_SMOOTH_END (0.5 + DISC_RADIUS) + +/** + * Returns coverage of a line onto a sample that is distance_to_line (in pixels) far from the line. + * line_kernel_size is the inner size of the line with 100% coverage. + */ +float line_coverage(float distance_to_line, float line_kernel_size) +{ + if (doSmoothLines) { + return smoothstep( + LINE_SMOOTH_END, LINE_SMOOTH_START, abs(distance_to_line) - line_kernel_size); + } + else { + return step(-0.5, line_kernel_size - abs(distance_to_line)); + } +} +vec4 line_coverage(vec4 distance_to_line, float line_kernel_size) +{ + if (doSmoothLines) { + return smoothstep( + LINE_SMOOTH_END, LINE_SMOOTH_START, abs(distance_to_line) - line_kernel_size); + } + else { + return step(-0.5, line_kernel_size - abs(distance_to_line)); + } +} + +vec2 decode_line_dir(vec2 dir) +{ + return dir * 2.0 - 1.0; +} + +float decode_line_dist(float dist) +{ + return (dist - 0.1) * 4.0 - 2.0; +} + +float neighbor_dist(vec3 line_dir_and_dist, vec2 ofs) +{ + float dist = decode_line_dist(line_dir_and_dist.z); + vec2 dir = decode_line_dir(line_dir_and_dist.xy); + + bool is_line = line_dir_and_dist.z != 0.0; + bool dir_horiz = abs(dir.x) > abs(dir.y); + bool ofs_horiz = (ofs.x != 0); + + if (!is_line || (ofs_horiz != dir_horiz)) { + dist += 1e10; /* No line. */ + } + else { + dist += dot(ofs, -dir); + } + return dist; +} + +void neighbor_blend( + float line_coverage, float line_depth, vec4 line_color, inout float frag_depth, inout vec4 col) +{ + line_color *= line_coverage; + if (line_coverage > 0.0 && line_depth < frag_depth) { + /* Alpha over. */ + col = col * (1.0 - line_color.a) + line_color; + frag_depth = line_depth; + } + else { + /* Alpha under. */ + col = col + line_color * (1.0 - col.a); + } +} + +void main() +{ + ivec2 center_texel = ivec2(gl_FragCoord.xy); + float line_kernel = sizePixel * 0.5 - 0.5; + + fragColor = texelFetch(colorTex, center_texel, 0); + + bool original_col_has_alpha = fragColor.a < 1.0; + + float depth = texelFetch(depthTex, center_texel, 0).r; + + float dist_raw = texelFetch(lineTex, center_texel, 0).b; + float dist = decode_line_dist(dist_raw); + + /* TODO: Opti: use textureGather. */ + vec4 neightbor_col0 = texelFetchOffset(colorTex, center_texel, 0, ivec2(1, 0)); + vec4 neightbor_col1 = texelFetchOffset(colorTex, center_texel, 0, ivec2(-1, 0)); + vec4 neightbor_col2 = texelFetchOffset(colorTex, center_texel, 0, ivec2(0, 1)); + vec4 neightbor_col3 = texelFetchOffset(colorTex, center_texel, 0, ivec2(0, -1)); + + vec3 neightbor_line0 = texelFetchOffset(lineTex, center_texel, 0, ivec2(1, 0)).rgb; + vec3 neightbor_line1 = texelFetchOffset(lineTex, center_texel, 0, ivec2(-1, 0)).rgb; + vec3 neightbor_line2 = texelFetchOffset(lineTex, center_texel, 0, ivec2(0, 1)).rgb; + vec3 neightbor_line3 = texelFetchOffset(lineTex, center_texel, 0, ivec2(0, -1)).rgb; + + vec4 depths; + depths.x = texelFetchOffset(depthTex, center_texel, 0, ivec2(1, 0)).r; + depths.y = texelFetchOffset(depthTex, center_texel, 0, ivec2(-1, 0)).r; + depths.z = texelFetchOffset(depthTex, center_texel, 0, ivec2(0, 1)).r; + depths.w = texelFetchOffset(depthTex, center_texel, 0, ivec2(0, -1)).r; + + vec4 line_dists; + line_dists.x = neighbor_dist(neightbor_line0, vec2(1, 0)); + line_dists.y = neighbor_dist(neightbor_line1, vec2(-1, 0)); + line_dists.z = neighbor_dist(neightbor_line2, vec2(0, 1)); + line_dists.w = neighbor_dist(neightbor_line3, vec2(0, -1)); + + vec4 coverage = line_coverage(line_dists, line_kernel); + + if (dist_raw > 0.0) { + fragColor *= line_coverage(dist, line_kernel); + } + + /* We don't order fragments but use alpha over/alpha under based on current minimum frag depth. + */ + neighbor_blend(coverage.x, depths.x, neightbor_col0, depth, fragColor); + neighbor_blend(coverage.y, depths.y, neightbor_col1, depth, fragColor); + neighbor_blend(coverage.z, depths.z, neightbor_col2, depth, fragColor); + neighbor_blend(coverage.w, depths.w, neightbor_col3, depth, fragColor); + +#if 1 + /* Fix aliasing issue with really dense meshes and 1 pixel sized lines. */ + if (!original_col_has_alpha && dist_raw > 0.0 && line_kernel < 0.45) { + vec4 lines = vec4(neightbor_line0.z, neightbor_line1.z, neightbor_line2.z, neightbor_line3.z); + /* Count number of line neighbors. */ + float blend = dot(vec4(0.25), step(0.001, lines)); + /* Only do blend if there are more than 2 neighbors. This avoids losing too much AA. */ + blend = clamp(blend * 2.0 - 1.0, 0.0, 1.0); + fragColor = mix(fragColor, fragColor / fragColor.a, blend); + } +#endif +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_dof_solid_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_dof_solid_frag.glsl new file mode 100644 index 00000000000..d46abbf79ee --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_dof_solid_frag.glsl @@ -0,0 +1,6 @@ + +void main() +{ + fragColor = vec4(finalColor.rgb, finalColor.a * alpha); + lineOutput = vec4(0.0); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_dof_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_dof_vert.glsl new file mode 100644 index 00000000000..b3c9ce5dfd2 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_dof_vert.glsl @@ -0,0 +1,32 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +vec3 sphere_project(float ax, float az) +{ + float sine = 1.0 - ax * ax - az * az; + float q3 = sqrt(max(0.0, sine)); + + return vec3(-az * q3, 0.5 - sine, ax * q3) * 2.0; +} + +void main() +{ + mat4 model_mat = inst_obmat; + model_mat[0][3] = model_mat[1][3] = model_mat[2][3] = 0.0; + model_mat[3][3] = 1.0; + + vec2 amin = vec2(inst_obmat[0][3], inst_obmat[1][3]); + vec2 amax = vec2(inst_obmat[2][3], inst_obmat[3][3]); + + vec3 final_pos = sphere_project(pos.x * abs((pos.x > 0.0) ? amax.x : amin.x), + pos.y * abs((pos.y > 0.0) ? amax.y : amin.y)); + + vec3 world_pos = (model_mat * vec4(final_pos, 1.0)).xyz; + gl_Position = point_world_to_ndc(world_pos); + finalColor = color; + + edgeStart = edgePos = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport; + + view_clipping_distances(world_pos); +} 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 new file mode 100644 index 00000000000..0a8e279e9b0 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_outline_vert.glsl @@ -0,0 +1,145 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +/* project to screen space */ +vec2 proj(vec4 pos) +{ + return (0.5 * (pos.xy / pos.w) + 0.5) * sizeViewport.xy; +} + +vec2 compute_dir(vec2 v0, vec2 v1, vec2 v2) +{ + vec2 dir = normalize(v2 - v0); + dir = vec2(dir.y, -dir.x); + return dir; +} + +mat3 compute_mat(vec4 sphere, vec3 bone_vec, out float z_ofs) +{ + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + vec3 cam_ray = (is_persp) ? sphere.xyz - ViewMatrixInverse[3].xyz : -ViewMatrixInverse[2].xyz; + + /* Sphere center distance from the camera (persp) in world space. */ + float cam_dist = length(cam_ray); + + /* Compute view aligned orthonormal space. */ + vec3 z_axis = cam_ray / cam_dist; + vec3 x_axis = normalize(cross(bone_vec, z_axis)); + vec3 y_axis = cross(z_axis, x_axis); + z_ofs = 0.0; + + if (is_persp) { + /* For perspective, the projected sphere radius + * can be bigger than the center disc. Compute the + * max angular size and compensate by sliding the disc + * towards the camera and scale it accordingly. */ + const float half_pi = 3.1415926 * 0.5; + float rad = sphere.w; + /* Let be : + * V the view vector origin. + * O the sphere origin. + * T the point on the target circle. + * We compute the angle between (OV) and (OT). */ + float a = half_pi - asin(rad / cam_dist); + float cos_b = cos(a); + float sin_b = sqrt(clamp(1.0 - cos_b * cos_b, 0.0, 1.0)); + + x_axis *= sin_b; + y_axis *= sin_b; + z_ofs = -rad * cos_b; + } + + return mat3(x_axis, y_axis, z_axis); +} + +struct Bone { + vec3 vec; + float sinb; +}; + +bool bone_blend_starts(vec3 p, Bone b) +{ + /* we just want to know when the head sphere starts interpolating. */ + return dot(p, b.vec) > -b.sinb; +} + +vec3 get_outline_point(vec2 pos, + vec4 sph_near, + vec4 sph_far, + mat3 mat_near, + mat3 mat_far, + float z_ofs_near, + float z_ofs_far, + Bone b) +{ + /* Compute outline position on the nearest sphere and check + * if it penetrates the capsule body. If it does, put this + * vertex on the farthest sphere. */ + vec3 wpos = mat_near * vec3(pos * sph_near.w, z_ofs_near); + if (bone_blend_starts(wpos, b)) { + wpos = sph_far.xyz + mat_far * vec3(pos * sph_far.w, z_ofs_far); + } + else { + wpos += sph_near.xyz; + } + return wpos; +} + +void main() +{ + float dst_head = distance(headSphere.xyz, ViewMatrixInverse[3].xyz); + float dst_tail = distance(tailSphere.xyz, ViewMatrixInverse[3].xyz); + // float dst_head = -dot(headSphere.xyz, ViewMatrix[2].xyz); + // float dst_tail = -dot(tailSphere.xyz, ViewMatrix[2].xyz); + + vec4 sph_near, sph_far; + if ((dst_head > dst_tail) && (ProjectionMatrix[3][3] == 0.0)) { + sph_near = tailSphere; + sph_far = headSphere; + } + else { + sph_near = headSphere; + sph_far = tailSphere; + } + + vec3 bone_vec = (sph_far.xyz - sph_near.xyz) + 1e-8; + + Bone b; + float bone_lenrcp = 1.0 / max(1e-8, sqrt(dot(bone_vec, bone_vec))); + b.sinb = (sph_far.w - sph_near.w) * bone_lenrcp * sph_near.w; + b.vec = bone_vec * bone_lenrcp; + + float z_ofs_near, z_ofs_far; + mat3 mat_near = compute_mat(sph_near, bone_vec, z_ofs_near); + mat3 mat_far = compute_mat(sph_far, bone_vec, z_ofs_far); + + vec3 wpos0 = get_outline_point( + pos0, sph_near, sph_far, mat_near, mat_far, z_ofs_near, z_ofs_far, b); + vec3 wpos1 = get_outline_point( + pos1, sph_near, sph_far, mat_near, mat_far, z_ofs_near, z_ofs_far, b); + vec3 wpos2 = get_outline_point( + pos2, sph_near, sph_far, mat_near, mat_far, z_ofs_near, z_ofs_far, b); + + view_clipping_distances(wpos1); + + vec4 p0 = point_world_to_ndc(wpos0); + vec4 p1 = point_world_to_ndc(wpos1); + vec4 p2 = point_world_to_ndc(wpos2); + + gl_Position = p1; + + /* compute position from 3 vertex because the change in direction + * can happen very quicky and lead to very thin edges. */ + vec2 ss0 = proj(p0); + vec2 ss1 = proj(p1); + vec2 ss2 = proj(p2); + 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; + + edgeStart = edgePos = proj(gl_Position); + + finalColor = vec4(outlineColorSize.rgb, 1.0); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_frag.glsl new file mode 100644 index 00000000000..a90d2e3e406 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_frag.glsl @@ -0,0 +1,17 @@ + +void main() +{ + float n = normalize(normalView).z; + if (isDistance) { + n = 1.0 - clamp(-n, 0.0, 1.0); + fragColor = vec4(1.0, 1.0, 1.0, 0.33 * alpha) * n; + } + else { + /* Smooth lighting factor. */ + const float s = 0.2; /* [0.0-0.5] range */ + float fac = clamp((n * (1.0 - s)) + s, 0.0, 1.0); + fragColor.rgb = mix(finalStateColor, finalBoneColor, fac * fac); + fragColor.a = alpha; + } + lineOutput = vec4(0.0); +} 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 new file mode 100644 index 00000000000..2dd86a57dfd --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_envelope_solid_vert.glsl @@ -0,0 +1,42 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + vec3 bone_vec = tailSphere.xyz - headSphere.xyz; + float bone_len = max(1e-8, sqrt(dot(bone_vec, bone_vec))); + float bone_lenrcp = 1.0 / bone_len; +#ifdef SMOOTH_ENVELOPE + float sinb = (tailSphere.w - headSphere.w) * bone_lenrcp; +#else + const float sinb = 0.0; +#endif + + vec3 y_axis = bone_vec * bone_lenrcp; + vec3 z_axis = normalize(cross(xAxis, -y_axis)); + vec3 x_axis = cross(y_axis, z_axis); /* cannot trust xAxis to be orthogonal. */ + + vec3 sp, nor; + nor = sp = pos.xyz; + + /* In bone space */ + bool is_head = (pos.z < -sinb); + sp *= (is_head) ? headSphere.w : tailSphere.w; + sp.z += (is_head) ? 0.0 : bone_len; + + /* Convert to world space */ + mat3 bone_mat = mat3(x_axis, y_axis, z_axis); + sp = bone_mat * sp.xzy + headSphere.xyz; + nor = bone_mat * nor.xzy; + + normalView = mat3(ViewMatrix) * nor; + + finalStateColor = stateColor; + finalBoneColor = boneColor; + + view_clipping_distances(sp); + + vec4 pos_4d = vec4(sp, 1.0); + gl_Position = ViewProjectionMatrix * 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 new file mode 100644 index 00000000000..47c5dada708 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_geom.glsl @@ -0,0 +1,76 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) + +void main(void) +{ + finalColor = vec4(geom_in[0].vColSize.rgb, 1.0); + + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + + vec3 view_vec = (is_persp) ? normalize(geom_in[1].vPos) : vec3(0.0, 0.0, -1.0); + vec3 v10 = geom_in[0].vPos - geom_in[1].vPos; + vec3 v12 = geom_in[2].vPos - geom_in[1].vPos; + vec3 v13 = geom_in[3].vPos - geom_in[1].vPos; + + 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)) { + return; + } + } + + n0 = (geom_in[0].inverted == 1) ? -n0 : n0; + /* Don't outline if concave edge. */ + if (dot(n0, v13) > 0.0001) { + return; + } + + vec2 perp = normalize(geom_in[2].ssPos - geom_in[1].ssPos); + 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 (geom_in[0].vPos.z < geom_in[3].vPos.z) { + hidden_point = (abs(fac0) > 1e-5) ? geom_in[0].ssPos : geom_in[3].ssPos; + } + else { + hidden_point = (abs(fac3) > 1e-5) ? geom_in[3].ssPos : geom_in[0].ssPos; + } + vec2 hidden_dir = normalize(hidden_point - geom_in[1].ssPos); + + float fac = dot(-hidden_dir, edge_dir); + edge_dir *= (fac < 0.0) ? -1.0 : 1.0; + + 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; + /* 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; + view_clipping_distances_set(gl_in[1]); + EmitVertex(); + + 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; + /* 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_set(gl_in[2]); + EmitVertex(); + + EndPrimitive(); +} 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 new file mode 100644 index 00000000000..29319b3f7ac --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_outline_vert.glsl @@ -0,0 +1,37 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +/* project to screen space */ +vec2 proj(vec4 pos) +{ + return (0.5 * (pos.xy / pos.w) + 0.5) * sizeViewport.xy; +} + +void main() +{ + vec4 bone_color, state_color; + mat4 model_mat = extract_matrix_packed_data(inst_obmat, state_color, bone_color); + + vec4 world_pos = model_mat * vec4(pos, 1.0); + vec4 view_pos = ViewMatrix * world_pos; + + geom_in.vPos = view_pos.xyz; + geom_in.pPos = ProjectionMatrix * view_pos; + + geom_in.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. */ + geom_in.ssNor = normalize(normal_world_to_view(normal_mat * snor).xy); + + geom_in.ssPos = proj(geom_in.pPos); + + geom_in.vColSize = bone_color; + + view_clipping_distances(world_pos.xyz); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_frag.glsl new file mode 100644 index 00000000000..8e1768846dc --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_frag.glsl @@ -0,0 +1,12 @@ + +void main() +{ + /* Manual back-face culling. Not ideal for performance + * but needed for view clarity in X-ray mode and support + * for inverted bone matrices. */ + if ((inverted == 1) == gl_FrontFacing) { + discard; + } + fragColor = vec4(finalColor.rgb, alpha); + lineOutput = vec4(0.0); +} 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 new file mode 100644 index 00000000000..cdbe8c3d7df --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_solid_vert.glsl @@ -0,0 +1,31 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + vec4 bone_color, state_color; + mat4 model_mat = extract_matrix_packed_data(inst_obmat, state_color, bone_color); + + /* 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))); + vec3 normal = normalize(normal_world_to_view(normal_mat * nor)); + + inverted = int(dot(cross(model_mat[0].xyz, model_mat[1].xyz), model_mat[2].xyz) < 0.0); + + /* Do lighting at an angle to avoid flat shading on front facing bone. */ + const vec3 light = vec3(0.1, 0.1, 0.8); + float n = dot(normal, light); + + /* Smooth lighting factor. */ + const float s = 0.2; /* [0.0-0.5] range */ + float fac = clamp((n * (1.0 - s)) + s, 0.0, 1.0); + finalColor.rgb = mix(state_color.rgb, bone_color.rgb, fac * fac); + finalColor.a = 1.0; + + vec4 world_pos = model_mat * vec4(pos, 1.0); + gl_Position = ViewProjectionMatrix * world_pos; + + view_clipping_distances(world_pos.xyz); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_wire_vert.glsl new file mode 100644 index 00000000000..cee86956c43 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_shape_wire_vert.glsl @@ -0,0 +1,19 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + vec4 bone_color, state_color; + mat4 model_mat = extract_matrix_packed_data(inst_obmat, state_color, bone_color); + + vec3 world_pos = (model_mat * vec4(pos, 1.0)).xyz; + gl_Position = point_world_to_ndc(world_pos); + + finalColor.rgb = mix(state_color.rgb, bone_color.rgb, 0.5); + finalColor.a = 1.0; + + edgeStart = edgePos = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; + + view_clipping_distances(world_pos); +} 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 new file mode 100644 index 00000000000..31369e0c3df --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_outline_vert.glsl @@ -0,0 +1,74 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +/* project to screen space */ +vec2 proj(vec4 pos) +{ + return (0.5 * (pos.xy / pos.w) + 0.5) * sizeViewport.xy; +} + +void main() +{ + vec4 bone_color, state_color; + mat4 model_mat = extract_matrix_packed_data(inst_obmat, state_color, bone_color); + + mat4 model_view_matrix = ViewMatrix * model_mat; + mat4 sphereMatrix = inverse(model_view_matrix); + + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + + /* This is the local space camera ray (not normalize). + * In perspective mode it's also the viewspace position + * of the sphere center. */ + vec3 cam_ray = (is_persp) ? model_view_matrix[3].xyz : vec3(0.0, 0.0, -1.0); + cam_ray = mat3(sphereMatrix) * cam_ray; + + /* Sphere center distance from the camera (persp) in local space. */ + float cam_dist = length(cam_ray); + + /* Compute view aligned orthonormal space. */ + vec3 z_axis = cam_ray / cam_dist; + vec3 x_axis = normalize(cross(sphereMatrix[1].xyz, z_axis)); + vec3 y_axis = cross(z_axis, x_axis); + float z_ofs = 0.0; + + if (is_persp) { + /* For perspective, the projected sphere radius + * can be bigger than the center disc. Compute the + * max angular size and compensate by sliding the disc + * towards the camera and scale it accordingly. */ + const float half_pi = 3.1415926 * 0.5; + const float rad = 0.05; + /* Let be (in local space): + * V the view vector origin. + * O the sphere origin. + * T the point on the target circle. + * We compute the angle between (OV) and (OT). */ + float a = half_pi - asin(rad / cam_dist); + float cos_b = cos(a); + float sin_b = sqrt(clamp(1.0 - cos_b * cos_b, 0.0, 1.0)); + + x_axis *= sin_b; + y_axis *= sin_b; + z_ofs = -rad * cos_b; + } + + /* Camera oriented position (but still in local space) */ + vec3 cam_pos0 = x_axis * pos.x + y_axis * pos.y + z_axis * z_ofs; + + vec4 V = model_view_matrix * vec4(cam_pos0, 1.0); + gl_Position = ProjectionMatrix * V; + vec4 center = ProjectionMatrix * vec4(model_view_matrix[3].xyz, 1.0); + + /* 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; + + edgeStart = edgePos = proj(gl_Position); + + finalColor = vec4(bone_color.rgb, 1.0); + + vec4 world_pos = model_mat * vec4(cam_pos0, 1.0); + view_clipping_distances(world_pos.xyz); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_frag.glsl new file mode 100644 index 00000000000..e60b6e94492 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_frag.glsl @@ -0,0 +1,52 @@ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + const float sphere_radius = 0.05; + + bool is_perp = (ProjectionMatrix[3][3] == 0.0); + vec3 ray_ori_view = (is_perp) ? vec3(0.0) : viewPosition.xyz; + vec3 ray_dir_view = (is_perp) ? viewPosition : vec3(0.0, 0.0, -1.0); + + /* Single matrix mul without branch. */ + vec4 mul_vec = (is_perp) ? vec4(ray_dir_view, 0.0) : vec4(ray_ori_view, 1.0); + vec3 mul_res = (sphereMatrix * mul_vec).xyz; + + /* Reminder : + * sphereMatrix[3] is the view space origin in sphere space (sph_ori -> view_ori). + * sphereMatrix[2] is the view space Z axis in sphere space. */ + + /* convert to sphere local space */ + vec3 ray_ori = (is_perp) ? sphereMatrix[3].xyz : mul_res; + vec3 ray_dir = (is_perp) ? mul_res : -sphereMatrix[2].xyz; + float ray_len = length(ray_dir); + ray_dir /= ray_len; + + /* Line to sphere intersect */ + const float sphere_radius_sqr = sphere_radius * sphere_radius; + float b = dot(ray_ori, ray_dir); + float c = dot(ray_ori, ray_ori) - sphere_radius_sqr; + float h = b * b - c; + float t = -sqrt(max(0.0, h)) - b; + + /* Compute dot product for lighting */ + vec3 p = ray_dir * t + ray_ori; /* Point on sphere */ + vec3 n = normalize(p); /* Normal is just the point in sphere space, normalized. */ + vec3 l = normalize(sphereMatrix[2].xyz); /* Just the view Z axis in the sphere space. */ + + /* Smooth lighting factor. */ + const float s = 0.2; /* [0.0-0.5] range */ + float fac = clamp((dot(n, l) * (1.0 - s)) + s, 0.0, 1.0); + fragColor.rgb = mix(finalStateColor, finalBoneColor, fac * fac); + + /* 2x2 dither pattern to smooth the lighting. */ + float dither = (0.5 + dot(vec2(ivec2(gl_FragCoord.xy) & ivec2(1)), vec2(1.0, 2.0))) * 0.25; + dither *= (1.0 / 255.0); /* Assume 8bit per color buffer. */ + + fragColor = vec4(fragColor.rgb + dither, alpha); + lineOutput = vec4(0.0); + + t /= ray_len; + gl_FragDepth = get_depth_from_view_z(ray_dir_view.z * t + ray_ori_view.z); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_vert.glsl new file mode 100644 index 00000000000..abbaad8cd10 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_sphere_solid_vert.glsl @@ -0,0 +1,76 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +/* Sphere radius */ +const float rad = 0.05; + +void main() +{ + vec4 bone_color, state_color; + mat4 model_mat = extract_matrix_packed_data(inst_obmat, state_color, bone_color); + + mat4 model_view_matrix = ViewMatrix * model_mat; + sphereMatrix = inverse(model_view_matrix); + + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + + /* This is the local space camera ray (not normalize). + * In perspective mode it's also the viewspace position + * of the sphere center. */ + vec3 cam_ray = (is_persp) ? model_view_matrix[3].xyz : vec3(0.0, 0.0, -1.0); + cam_ray = mat3(sphereMatrix) * cam_ray; + + /* Sphere center distance from the camera (persp) in local space. */ + float cam_dist = length(cam_ray); + + /* Compute view aligned orthonormal space. */ + vec3 z_axis = cam_ray / cam_dist; + vec3 x_axis = normalize(cross(sphereMatrix[1].xyz, z_axis)); + vec3 y_axis = cross(z_axis, x_axis); + + float z_ofs = -rad - 1e-8; /* offset to the front of the sphere */ + if (is_persp) { + /* For perspective, the projected sphere radius + * can be bigger than the center disc. Compute the + * max angular size and compensate by sliding the disc + * towards the camera and scale it accordingly. */ + const float half_pi = 3.1415926 * 0.5; + /* Let be (in local space): + * V the view vector origin. + * O the sphere origin. + * T the point on the target circle. + * We compute the angle between (OV) and (OT). */ + float a = half_pi - asin(rad / cam_dist); + float cos_b = cos(a); + float sin_b = sqrt(clamp(1.0 - cos_b * cos_b, 0.0, 1.0)); +#if 1 + /* Instead of choosing the biggest circle in screenspace, + * we choose the nearest with the same angular size. This + * permit us to leverage GL_ARB_conservative_depth in the + * fragment shader. */ + float minor = cam_dist - rad; + float major = cam_dist - cos_b * rad; + float fac = minor / major; + sin_b *= fac; +#else + z_ofs = -rad * cos_b; +#endif + x_axis *= sin_b; + y_axis *= sin_b; + } + + /* Camera oriented position (but still in local space) */ + vec3 cam_pos = x_axis * pos.x + y_axis * pos.y + z_axis * z_ofs; + + vec4 pos_4d = vec4(cam_pos, 1.0); + vec4 V = model_view_matrix * pos_4d; + gl_Position = ProjectionMatrix * V; + viewPosition = V.xyz; + + finalStateColor = state_color.xyz; + finalBoneColor = bone_color.xyz; + + vec4 world_pos = model_mat * pos_4d; + view_clipping_distances(world_pos.xyz); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_frag.glsl new file mode 100644 index 00000000000..2e42cdf0517 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_frag.glsl @@ -0,0 +1,8 @@ + +void main() +{ + float fac = smoothstep(1.0, 0.2, colorFac); + fragColor.rgb = mix(finalInnerColor.rgb, finalWireColor.rgb, fac); + fragColor.a = alpha; + lineOutput = vec4(0.0); +} 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 new file mode 100644 index 00000000000..b5edcd2858b --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_stick_vert.glsl @@ -0,0 +1,74 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +/* TODO(@fclem): Share definition with C code. */ +#define COL_WIRE 1u /* (1 << 0) */ +#define COL_HEAD 2u /* (1 << 1) */ +#define COL_TAIL 4u /* (1 << 2) */ +#define COL_BONE 8u /* (1 << 3) */ + +#define POS_HEAD 16u /* (1 << 4) */ +#define POS_TAIL 32u /* (1 << 5) */ /* UNUSED */ +#define POS_BONE 64u /* (1 << 6) */ + +#define is_head bool(flag & POS_HEAD) +#define is_bone bool(flag & POS_BONE) + +/* project to screen space */ +vec2 proj(vec4 pos) +{ + return (0.5 * (pos.xy / pos.w) + 0.5) * sizeViewport.xy; +} + +void main() +{ + finalInnerColor = ((flag & COL_HEAD) != 0u) ? headColor : tailColor; + finalInnerColor = ((flag & COL_BONE) != 0u) ? boneColor : finalInnerColor; + finalWireColor = (do_wire) ? wireColor : finalInnerColor; + /* Make the color */ + colorFac = ((flag & COL_WIRE) == 0u) ? ((flag & COL_BONE) != 0u) ? 1.0 : 2.0 : 0.0; + + vec4 boneStart_4d = vec4(boneStart, 1.0); + vec4 boneEnd_4d = vec4(boneEnd, 1.0); + vec4 v0 = ViewMatrix * boneStart_4d; + vec4 v1 = ViewMatrix * boneEnd_4d; + + /* Clip the bone to the camera origin plane (not the clip plane) + * to avoid glitches if one end is behind the camera origin (in persp). */ + float clip_dist = (ProjectionMatrix[3][3] == 0.0) ? + -1e-7 : + 1e20; /* hardcoded, -1e-8 is giving gliches. */ + vec3 bvec = v1.xyz - v0.xyz; + vec3 clip_pt = v0.xyz + bvec * ((v0.z - clip_dist) / -bvec.z); + if (v0.z > clip_dist) { + v0.xyz = clip_pt; + } + else if (v1.z > clip_dist) { + v1.xyz = clip_pt; + } + + vec4 p0 = ProjectionMatrix * v0; + vec4 p1 = ProjectionMatrix * v1; + + float h = (is_head) ? p0.w : p1.w; + + vec2 x_screen_vec = normalize(proj(p1) - proj(p0) + 1e-8); + vec2 y_screen_vec = vec2(x_screen_vec.y, -x_screen_vec.x); + + /* 2D screen aligned pos at the point */ + vec2 vpos = pos.x * x_screen_vec + pos.y * y_screen_vec; + vpos *= (ProjectionMatrix[3][3] == 0.0) ? h : 1.0; + vpos *= (do_wire) ? 1.0 : 0.5; + + 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.z += (is_bone) ? 0.0 : 1e-6; /* Avoid Z fighting of head/tails. */ + view_clipping_distances((is_head ? boneStart_4d : boneEnd_4d).xyz); + } + else { + gl_Position = vec4(0.0); + } +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_wire_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_wire_frag.glsl new file mode 100644 index 00000000000..2c454a8becd --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_wire_frag.glsl @@ -0,0 +1,8 @@ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + lineOutput = pack_line_data(gl_FragCoord.xy, edgeStart, edgePos); + fragColor = vec4(finalColor.rgb, finalColor.a * alpha); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_armature_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_armature_wire_vert.glsl new file mode 100644 index 00000000000..c89d0249e4f --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_armature_wire_vert.glsl @@ -0,0 +1,16 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + finalColor.rgb = color.rgb; + finalColor.a = 1.0; + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + + edgeStart = edgePos = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_background_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_background_frag.glsl new file mode 100644 index 00000000000..b25dcae9fca --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_background_frag.glsl @@ -0,0 +1,86 @@ + + +#pragma BLENDER_REQUIRE(common_math_lib.glsl) + +/* 4x4 bayer matrix prepared for 8bit UNORM precision error. */ +#define P(x) (((x + 0.5) * (1.0 / 16.0) - 0.5) * (1.0 / 255.0)) +const vec4 dither_mat4x4[4] = vec4[4](vec4(P(0.0), P(8.0), P(2.0), P(10.0)), + vec4(P(12.0), P(4.0), P(14.0), P(6.0)), + vec4(P(3.0), P(11.0), P(1.0), P(9.0)), + vec4(P(15.0), P(7.0), P(13.0), P(5.0))); + +float dither(void) +{ + ivec2 co = ivec2(gl_FragCoord.xy) % 4; + return dither_mat4x4[co.x][co.y]; +} + +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 + * This removes the alpha channel and put the background behind reference images + * while masking the reference images by the render alpha. + */ + float alpha = texture(colorBuffer, uvcoordsvar.xy).a; + float depth = texture(depthBuffer, uvcoordsvar.xy).r; + + vec3 bg_col; + vec3 col_high; + vec3 col_low; + + /* BG_SOLID_CHECKER selects BG_SOLID when no pixel has been drawn otherwise use the BG_CHERKER. + */ + int bg_type = bgType == BG_SOLID_CHECKER ? (depth == 1.0 ? BG_SOLID : BG_CHECKER) : bgType; + + switch (bg_type) { + case BG_SOLID: + bg_col = colorBackground.rgb; + break; + case BG_GRADIENT: + /* XXX do interpolation in a non-linear space to have a better visual result. */ + col_high = pow(colorBackground.rgb, vec3(1.0 / 2.2)); + col_low = pow(colorBackgroundGradient.rgb, vec3(1.0 / 2.2)); + bg_col = mix(col_low, col_high, uvcoordsvar.y); + /* Convert back to linear. */ + bg_col = pow(bg_col, vec3(2.2)); + /* Dither to hide low precision buffer. (Could be improved) */ + bg_col += dither(); + break; + case BG_RADIAL: { + /* Do interpolation in a non-linear space to have a better visual result. */ + col_high = pow(colorBackground.rgb, vec3(1.0 / 2.2)); + col_low = pow(colorBackgroundGradient.rgb, vec3(1.0 / 2.2)); + + vec2 uv_n = uvcoordsvar.xy - 0.5; + bg_col = mix(col_high, col_low, length(uv_n) * M_SQRT2); + + /* Convert back to linear. */ + bg_col = pow(bg_col, vec3(2.2)); + /* Dither to hide low precision buffer. (Could be improved) */ + bg_col += dither(); + break; + } + case BG_CHECKER: { + float size = sizeChecker * sizePixel; + ivec2 p = ivec2(floor(gl_FragCoord.xy / size)); + bool check = mod(p.x, 2) == mod(p.y, 2); + bg_col = (check) ? colorCheckerPrimary.rgb : colorCheckerSecondary.rgb; + break; + } + case BG_MASK: + fragColor = vec4(vec3(1.0 - alpha), 0.0); + return; + } + + bg_col = mix(bg_col, colorOverride.rgb, colorOverride.a); + + /* Mimic alpha under behavior. Result is premultiplied. */ + fragColor = vec4(bg_col, 1.0) * (1.0 - alpha); + + /* Special case: If the render is not transparent, do not clear alpha values. */ + if (depth == 1.0 && alpha == 1.0) { + fragColor.a = 1.0; + } +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_clipbound_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_clipbound_vert.glsl new file mode 100644 index 00000000000..c065a66414f --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_clipbound_vert.glsl @@ -0,0 +1,13 @@ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + vec3 world_pos = boundbox[gl_VertexID]; + gl_Position = point_world_to_ndc(world_pos); + + /* Result in a position at 1.0 (far plane). Small epsilon to avoid precision issue. + * This mimics the effect of infinite projection matrix + * (see http://www.terathon.com/gdc07_lengyel.pdf). */ + gl_Position.z = gl_Position.w - 2.4e-7; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_common_lib.glsl b/source/blender/draw/engines/overlay/shaders/overlay_common_lib.glsl new file mode 100644 index 00000000000..65aeb81a4ef --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_common_lib.glsl @@ -0,0 +1,5 @@ +#define OVERLAY_UV_LINE_STYLE_OUTLINE 0 +#define OVERLAY_UV_LINE_STYLE_DASH 1 +#define OVERLAY_UV_LINE_STYLE_BLACK 2 +#define OVERLAY_UV_LINE_STYLE_WHITE 3 +#define OVERLAY_UV_LINE_STYLE_SHADOW 4 diff --git a/source/blender/draw/engines/overlay/shaders/overlay_depth_only_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_vert.glsl new file mode 100644 index 00000000000..d403890f44e --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_depth_only_vert.glsl @@ -0,0 +1,13 @@ + +#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); + + view_clipping_distances(world_pos); +} 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 new file mode 100644 index 00000000000..7d92baea595 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_geom.glsl @@ -0,0 +1,116 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void output_line(vec2 offset, vec4 color) +{ + finalColor = color; + + gl_Position = gl_in[0].gl_Position; + gl_Position.xy += offset * gl_in[0].gl_Position.w; + view_clipping_distances_set(gl_in[0]); + EmitVertex(); + + gl_Position = gl_in[1].gl_Position; + gl_Position.xy += offset * gl_in[1].gl_Position.w; + view_clipping_distances_set(gl_in[1]); + EmitVertex(); +} + +void main() +{ + vec4 v1 = gl_in[0].gl_Position; + vec4 v2 = gl_in[1].gl_Position; + + int is_active_nurb = (vert[1].flag & ACTIVE_NURB); + int color_id = (vert[1].flag >> COLOR_SHIFT); + + /* Don't output any edges if we don't show handles */ + if (!showCurveHandles && (color_id < 5)) { + return; + } + + bool edge_selected = (((vert[1].flag | vert[0].flag) & VERT_SELECTED) != 0); + bool handle_selected = (showCurveHandles && + (((vert[1].flag | vert[0].flag) & VERT_SELECTED_BEZT_HANDLE) != 0)); + + bool is_gpencil = ((vert[1].flag & VERT_GPENCIL_BEZT_HANDLE) != 0); + + /* If handle type is only selected and the edge is not selected, don't show. */ + if ((curveHandleDisplay != CURVE_HANDLE_ALL) && (!handle_selected)) { + /* Nurbs must show the handles always. */ + bool is_u_segment = (((vert[1].flag ^ vert[0].flag) & EVEN_U_BIT) != 0); + if ((!is_u_segment) && (color_id <= 4)) { + return; + } + if (is_gpencil) { + return; + } + } + + vec4 inner_color; + if (color_id == 0) { + inner_color = (edge_selected) ? colorHandleSelFree : colorHandleFree; + } + else if (color_id == 1) { + inner_color = (edge_selected) ? colorHandleSelAuto : colorHandleAuto; + } + else if (color_id == 2) { + inner_color = (edge_selected) ? colorHandleSelVect : colorHandleVect; + } + else if (color_id == 3) { + inner_color = (edge_selected) ? colorHandleSelAlign : colorHandleAlign; + } + else if (color_id == 4) { + inner_color = (edge_selected) ? colorHandleSelAutoclamp : colorHandleAutoclamp; + } + else { + bool is_selected = (((vert[1].flag & vert[0].flag) & VERT_SELECTED) != 0); + bool is_u_segment = (((vert[1].flag ^ vert[0].flag) & EVEN_U_BIT) != 0); + if (is_u_segment) { + inner_color = (is_selected) ? colorNurbSelUline : colorNurbUline; + } + else { + inner_color = (is_selected) ? colorNurbSelVline : colorNurbVline; + } + } + + vec4 outer_color = (is_active_nurb != 0) ? + mix(colorActiveSpline, + inner_color, + 0.25) /* Minimize active color bleeding on inner_color. */ + : + 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 */ + + if (abs(v1_2.x * sizeViewport.x) < abs(v1_2.y * sizeViewport.y)) { + offset.y = 0.0; + } + else { + offset.x = 0.0; + } + + /* draw the transparent border (AA). */ + if (is_active_nurb != 0) { + offset *= 0.75; /* Don't make the active "halo" appear very thick. */ + output_line(offset * 2.0, vec4(colorActiveSpline.rgb, 0.0)); + } + + /* draw the outline. */ + output_line(offset, outer_color); + + /* draw the core of the line. */ + output_line(vec2(0.0), inner_color); + + /* draw the outline. */ + output_line(-offset, outer_color); + + /* draw the transparent border (AA). */ + if (is_active_nurb != 0) { + output_line(offset * -2.0, vec4(colorActiveSpline.rgb, 0.0)); + } + + EndPrimitive(); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert.glsl new file mode 100644 index 00000000000..186cc010f45 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_handle_vert.glsl @@ -0,0 +1,14 @@ + +#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_curve_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_point_vert.glsl new file mode 100644 index 00000000000..a30496177c3 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_point_vert.glsl @@ -0,0 +1,37 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + /* Reuse the FREESTYLE flag to determine is GPencil. */ + bool is_gpencil = ((data & EDGE_FREESTYLE) != 0); + if ((data & VERT_SELECTED) != 0) { + if ((data & VERT_ACTIVE) != 0) { + finalColor = colorEditMeshActive; + } + else { + finalColor = (!is_gpencil) ? colorVertexSelect : colorGpencilVertexSelect; + } + } + else { + finalColor = (!is_gpencil) ? colorVertex : colorGpencilVertex; + } + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + gl_PointSize = (!is_gpencil) ? sizeVertex * 2.0 : sizeVertexGpencil * 2.0; + view_clipping_distances(world_pos); + + bool show_handle = showCurveHandles; + if ((curveHandleDisplay == CURVE_HANDLE_SELECTED) && ((data & VERT_SELECTED_BEZT_HANDLE) == 0)) { + show_handle = false; + } + + if (!show_handle && ((data & BEZIER_HANDLE) != 0)) { + /* We set the vertex at the camera origin to generate 0 fragments. */ + gl_Position = vec4(0.0, 0.0, -3e36, 0.0); + } +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_vert.glsl new file mode 100644 index 00000000000..183df7e5450 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_curve_wire_vert.glsl @@ -0,0 +1,23 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + vec3 final_pos = pos; + + float flip = (gl_InstanceID != 0) ? -1.0 : 1.0; + + if (gl_VertexID % 2 == 0) { + final_pos += normalSize * rad * (flip * nor - tan); + } + + vec3 world_pos = point_object_to_world(final_pos); + gl_Position = point_world_to_ndc(world_pos); + + finalColor = colorWireEdit; + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_canvas_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_canvas_vert.glsl new file mode 100644 index 00000000000..47d9439ed80 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_canvas_vert.glsl @@ -0,0 +1,30 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + vec2 pos; + pos.x = float(gl_VertexID % 2); + pos.y = float(gl_VertexID / 2) / float(halfLineCount - 1); + + if (pos.y > 1.0) { + pos.xy = pos.yx; + pos.x -= 1.0 + 1.0 / float(halfLineCount - 1); + } + + pos -= 0.5; + + vec3 world_pos = xAxis * pos.x + yAxis * pos.y + origin; + + gl_Position = point_world_to_ndc(world_pos); + + view_clipping_distances(world_pos); + + finalColor = color; + + /* Convert to screen position [0..sizeVp]. */ + edgePos = edgeStart = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_guide_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_guide_vert.glsl new file mode 100644 index 00000000000..a5091345539 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_guide_vert.glsl @@ -0,0 +1,14 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + gl_Position = point_world_to_ndc(pPosition); + finalColor = pColor; + gl_PointSize = pSize; + + view_clipping_distances(pPosition); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_vert.glsl new file mode 100644 index 00000000000..f5d6e89d016 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_gpencil_vert.glsl @@ -0,0 +1,87 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void discard_vert() +{ + /* We set the vertex at the camera origin to generate 0 fragments. */ + gl_Position = vec4(0.0, 0.0, -3e36, 0.0); +} + +#ifdef USE_POINTS +# define gp_colorUnselect colorGpencilVertex +# define gp_colorSelect colorGpencilVertexSelect +#else +# define gp_colorUnselect gpEditColor +# define gp_colorSelect (hideSelect ? gp_colorUnselect : colorGpencilVertexSelect) +#endif + +vec3 weight_to_rgb(float t) +{ + if (t < 0.0) { + /* No weight */ + return gp_colorUnselect.rgb; + } + else if (t > 1.0) { + /* Error color */ + return vec3(1.0, 0.0, 1.0); + } + else { + return texture(weightTex, t).rgb; + } +} + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + + bool is_multiframe = (vflag & GP_EDIT_MULTIFRAME) != 0u; + bool is_stroke_sel = (vflag & GP_EDIT_STROKE_SELECTED) != 0u; + bool is_point_sel = (vflag & GP_EDIT_POINT_SELECTED) != 0u; + bool is_point_dimmed = (vflag & GP_EDIT_POINT_DIMMED) != 0u; + + if (doWeightColor) { + finalColor.rgb = weight_to_rgb(weight); + finalColor.a = gpEditOpacity; + } + else { + finalColor = (is_point_sel) ? gp_colorSelect : gp_colorUnselect; + finalColor.a *= gpEditOpacity; + } + +#ifdef USE_POINTS + gl_PointSize = sizeVertexGpencil * 2.0; + + if (is_point_dimmed) { + finalColor.rgb = clamp(gp_colorUnselect.rgb + vec3(0.3), 0.0, 1.0); + } + + if (doStrokeEndpoints && !doWeightColor) { + bool is_stroke_start = (vflag & GP_EDIT_STROKE_START) != 0u; + bool is_stroke_end = (vflag & GP_EDIT_STROKE_END) != 0u; + + if (is_stroke_start) { + gl_PointSize *= 2.0; + finalColor.rgb = vec3(0.0, 1.0, 0.0); + } + else if (is_stroke_end) { + gl_PointSize *= 1.5; + finalColor.rgb = vec3(1.0, 0.0, 0.0); + } + } + + if ((!is_stroke_sel && !doWeightColor) || (!doMultiframe && is_multiframe)) { + discard_vert(); + } +#endif + + /* Discard unwanted padding vertices. */ + if (ma == -1 || (is_multiframe && !doMultiframe)) { + discard_vert(); + } + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_point_vert.glsl new file mode 100644 index 00000000000..38ba80a981a --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_point_vert.glsl @@ -0,0 +1,28 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + if ((data & VERT_SELECTED) != 0) { + finalColor = colorVertexSelect; + } + else if ((data & VERT_ACTIVE) != 0) { + finalColor = colorEditMeshActive; + } + else { + finalColor = colorVertex; + } + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + + /* Small offset in Z */ + gl_Position.z -= 3e-4; + + gl_PointSize = sizeVertex * 2.0; + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_wire_vert.glsl new file mode 100644 index 00000000000..440dfdc1482 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_lattice_wire_vert.glsl @@ -0,0 +1,32 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +#define no_active_weight 666.0 + +vec3 weight_to_rgb(float t) +{ + if (t == no_active_weight) { + /* No weight. */ + return colorWire.rgb; + } + if (t > 1.0 || t < 0.0) { + /* Error color */ + return vec3(1.0, 0.0, 1.0); + } + else { + return texture(weightTex, t).rgb; + } +} + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + finalColor = vec4(weight_to_rgb(weight), 1.0); + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_frag.glsl new file mode 100644 index 00000000000..430ace8726a --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_frag.glsl @@ -0,0 +1,5 @@ + +void main() +{ + fragColor = weightColor; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_vert.glsl new file mode 100644 index 00000000000..1e163dc9a9a --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_analysis_vert.glsl @@ -0,0 +1,29 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +vec3 weight_to_rgb(float t) +{ + if (t < 0.0) { + /* Minimum color, grey */ + return vec3(0.25, 0.25, 0.25); + } + else if (t > 1.0) { + /* Error color */ + return vec3(1.0, 0.0, 1.0); + } + else { + return texture(weightTex, t).rgb; + } +} + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + weightColor = vec4(weight_to_rgb(weight), 1.0); + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_common_lib.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_common_lib.glsl new file mode 100644 index 00000000000..72b0a43cdb4 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_common_lib.glsl @@ -0,0 +1,77 @@ + +vec4 EDIT_MESH_edge_color_outer(int edge_flag, int face_flag, float crease, float bweight) +{ + vec4 color = vec4(0.0); + color = ((edge_flag & EDGE_FREESTYLE) != 0) ? colorEdgeFreestyle : color; + color = ((edge_flag & EDGE_SHARP) != 0) ? colorEdgeSharp : color; + color = (crease > 0.0) ? vec4(colorEdgeCrease.rgb, crease) : color; + color = (bweight > 0.0) ? vec4(colorEdgeBWeight.rgb, bweight) : color; + color = ((edge_flag & EDGE_SEAM) != 0) ? colorEdgeSeam : color; + return color; +} + +vec4 EDIT_MESH_edge_color_inner(int edge_flag) +{ + vec4 color = colorWireEdit; + vec4 color_select = (selectEdges) ? colorEdgeSelect : mix(colorEdgeSelect, colorWireEdit, .45); + color = ((edge_flag & EDGE_SELECTED) != 0) ? color_select : color; + color = ((edge_flag & EDGE_ACTIVE) != 0) ? colorEditMeshActive : color; + + color.a = (selectEdges || (edge_flag & (EDGE_SELECTED | EDGE_ACTIVE)) != 0) ? 1.0 : 0.7; + return color; +} + +vec4 EDIT_MESH_edge_vertex_color(int vertex_flag) +{ + vec4 color = colorWireEdit; + vec4 color_select = (selectEdges) ? colorEdgeSelect : mix(colorEdgeSelect, colorWireEdit, .45); + + bool edge_selected = (vertex_flag & (VERT_ACTIVE | VERT_SELECTED)) != 0; + color = (edge_selected) ? color_select : color; + + color.a = (selectEdges || edge_selected) ? 1.0 : 0.7; + return color; +} + +vec4 EDIT_MESH_vertex_color(int vertex_flag, float vertex_crease) +{ + if ((vertex_flag & VERT_ACTIVE) != 0) { + return vec4(colorEditMeshActive.xyz, 1.0); + } + else if ((vertex_flag & VERT_SELECTED) != 0) { + return colorVertexSelect; + } + else { + /* Full crease color if not selected nor active. */ + if (vertex_crease > 0.0) { + return mix(colorVertex, colorEdgeCrease, vertex_crease); + } + return colorVertex; + } +} + +vec4 EDIT_MESH_face_color(int face_flag) +{ + vec4 color = colorFace; + vec4 color_active = mix(colorFaceSelect, colorEditMeshActive, 0.5); + color = ((face_flag & FACE_FREESTYLE) != 0) ? colorFaceFreestyle : color; + color = ((face_flag & FACE_SELECTED) != 0) ? colorFaceSelect : color; + color = ((face_flag & FACE_ACTIVE) != 0) ? color_active : color; + color.a *= ((face_flag & (FACE_FREESTYLE | FACE_SELECTED | FACE_ACTIVE)) == 0 || selectFaces) ? + 1.0 : + 0.5; + return color; +} + +vec4 EDIT_MESH_facedot_color(float facedot_flag) +{ + if (facedot_flag < 0.0f) { + return vec4(colorEditMeshActive.xyz, 1.0); + } + else if (facedot_flag > 0.0f) { + return colorFaceDot; + } + else { + return colorVertex; + } +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_frag.glsl new file mode 100644 index 00000000000..2fd155f715c --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_frag.glsl @@ -0,0 +1,44 @@ + +#define M_1_SQRTPI 0.5641895835477563 /* 1/sqrt(pi) */ + +/** + * 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. + */ +#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) + +bool test_occlusion() +{ + return gl_FragCoord.z > texelFetch(depthTex, ivec2(gl_FragCoord.xy), 0).r; +} + +float edge_step(float dist) +{ + if (do_smooth_wire) { + return smoothstep(GRID_LINE_SMOOTH_START, GRID_LINE_SMOOTH_END, dist); + } + else { + return step(0.5, dist); + } +} + +void main() +{ + float dist = abs(geometry_out.edgeCoord) - max(sizeEdge - 0.5, 0.0); + float dist_outer = dist - max(sizeEdge, 1.0); + float mix_w = edge_step(dist); + float mix_w_outer = edge_step(dist_outer); + /* Line color & alpha. */ + fragColor = mix(geometry_out.finalColorOuter, + geometry_out.finalColor, + 1.0 - mix_w * geometry_out.finalColorOuter.a); + /* Line edges shape. */ + fragColor.a *= 1.0 - (geometry_out.finalColorOuter.a > 0.0 ? mix_w_outer : mix_w); + + fragColor.a *= test_occlusion() ? alpha : 1.0; +} 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 new file mode 100644 index 00000000000..82f957b2071 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_geom.glsl @@ -0,0 +1,77 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +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; + /* Correct but fails due to an AMD compiler bug, see: T62792. + * Do inline instead. */ +#if 0 + view_clipping_distances_set(gl_in[i]); +#endif + EmitVertex(); +} + +void main() +{ + vec2 ss_pos[2]; + + /* Clip line against near plane to avoid deformed lines. */ + vec4 pos0 = gl_in[0].gl_Position; + vec4 pos1 = gl_in[1].gl_Position; + 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. */ + return; + } + + 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 = geometry_in[0].finalColorOuter_; + float half_size = sizeEdge; + /* Enlarge edge for flag display. */ + half_size += (geometry_out.finalColorOuter.a > 0.0) ? max(sizeEdge, 1.0) : 0.0; + + if (do_smooth_wire) { + /* Add 1 px for AA */ + half_size += 0.5; + } + + vec3 edge_ofs = vec3(half_size * drw_view.viewport_size_inverse, 0.0); + + bool horizontal = line.x > line.y; + edge_ofs = (horizontal) ? edge_ofs.zyz : edge_ofs.xzz; + + /* Due to an AMD glitch, this line was moved out of the `do_vertex` + * function (see T62792). */ + view_clipping_distances_set(gl_in[0]); + do_vertex(geometry_in[0].finalColor_, pos0, half_size, edge_ofs.xy); + do_vertex(geometry_in[0].finalColor_, pos0, -half_size, -edge_ofs.xy); + + view_clipping_distances_set(gl_in[1]); + vec4 final_color = (geometry_in[0].selectOverride_ == 0) ? geometry_in[1].finalColor_ : + geometry_in[0].finalColor_; + do_vertex(final_color, pos1, half_size, edge_ofs.xy); + do_vertex(final_color, pos1, -half_size, -edge_ofs.xy); + + EndPrimitive(); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_normal_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_normal_vert.glsl new file mode 100644 index 00000000000..6ff8d0665d1 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_normal_vert.glsl @@ -0,0 +1,69 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +bool test_occlusion() +{ + vec3 ndc = (gl_Position.xyz / gl_Position.w) * 0.5 + 0.5; + return (ndc.z - 0.00035) > texture(depthTex, ndc.xy).r; +} + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + /* Avoid undefined behavior after return. */ + finalColor = vec4(0.0); + gl_Position = vec4(0.0); + + vec3 nor; + /* Select the right normal by checking if the generic attribute is used. */ + if (!all(equal(lnor.xyz, vec3(0)))) { + if (lnor.w < 0.0) { + return; + } + nor = lnor.xyz; + finalColor = colorLNormal; + } + else if (!all(equal(vnor.xyz, vec3(0)))) { + if (vnor.w < 0.0) { + return; + } + nor = vnor.xyz; + finalColor = colorVNormal; + } + else { + nor = norAndFlag.xyz; + if (all(equal(nor, vec3(0)))) { + return; + } + finalColor = colorNormal; + } + + vec3 n = normalize(normal_object_to_world(nor)); + vec3 world_pos = point_object_to_world(pos); + + if (gl_VertexID == 0) { + if (isConstantScreenSizeNormals) { + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + if (is_persp) { + float dist_fac = length(cameraPos - world_pos); + float cos_fac = dot(cameraForward, cameraVec(world_pos)); + world_pos += n * normalScreenSize * dist_fac * cos_fac * pixelFac * sizePixel; + } + else { + float frustrum_fac = mul_project_m4_v3_zfac(n) * sizePixel; + world_pos += n * normalScreenSize * frustrum_fac; + } + } + else { + world_pos += n * normalSize; + } + } + + gl_Position = point_world_to_ndc(world_pos); + + finalColor.a *= (test_occlusion()) ? alpha : 1.0; + + view_clipping_distances(world_pos); +} 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 new file mode 100644 index 00000000000..f1fbdac7847 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_skin_root_vert.glsl @@ -0,0 +1,17 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + mat3 imat = mat3(ModelMatrixInverse); + vec3 right = normalize(imat * screenVecs[0].xyz); + vec3 up = normalize(imat * screenVecs[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 = ViewProjectionMatrix * pos_4d; + /* Manual stipple: one segment out of 2 is transparent. */ + finalColor = ((gl_VertexID & 1) == 0) ? colorSkinRoot : vec4(0.0); + + view_clipping_distances(pos_4d.xyz); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert.glsl new file mode 100644 index 00000000000..374fb50af75 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_mesh_vert.glsl @@ -0,0 +1,99 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) +#pragma BLENDER_REQUIRE(overlay_edit_mesh_common_lib.glsl) + +#ifdef EDGE +/* Ugly but needed to keep the same vertex shader code for other passes. */ +# define finalColor geometry_in.finalColor_ +# define finalColorOuter geometry_in.finalColorOuter_ +# define selectOverride geometry_in.selectOverride_ +#endif + +bool test_occlusion() +{ + vec3 ndc = (gl_Position.xyz / gl_Position.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)); +} + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + + ivec4 m_data = data & dataMask; + +#if defined(VERT) + vertexCrease = float(m_data.z >> 4) / 15.0; + finalColor = EDIT_MESH_vertex_color(m_data.y, vertexCrease); + gl_PointSize = sizeVertex * ((vertexCrease > 0.0) ? 3.0 : 2.0); + /* Make selected and active vertex always on top. */ + if ((data.x & VERT_SELECTED) != 0) { + gl_Position.z -= 5e-7 * abs(gl_Position.w); + } + if ((data.x & VERT_ACTIVE) != 0) { + gl_Position.z -= 5e-7 * abs(gl_Position.w); + } + + bool occluded = test_occlusion(); + +#elif defined(EDGE) +# ifdef FLAT + finalColor = EDIT_MESH_edge_color_inner(m_data.y); + selectOverride = 1; +# else + finalColor = EDIT_MESH_edge_vertex_color(m_data.y); + selectOverride = (m_data.y & EDGE_SELECTED); +# endif + + float edge_crease = float(m_data.z & 0xF) / 15.0; + float bweight = float(m_data.w) / 255.0; + finalColorOuter = EDIT_MESH_edge_color_outer(m_data.y, m_data.x, edge_crease, bweight); + + if (finalColorOuter.a > 0.0) { + gl_Position.z -= 5e-7 * abs(gl_Position.w); + } + + bool occluded = false; /* Done in fragment shader */ + +#elif defined(FACE) + finalColor = EDIT_MESH_face_color(m_data.x); + bool occluded = true; + +#elif defined(FACEDOT) + finalColor = EDIT_MESH_facedot_color(norAndFlag.w); + + /* Bias Facedot Z position in clipspace. */ + gl_Position.z -= (ProjectionMatrix[3][3] == 0.0) ? 0.00035 : 1e-6; + gl_PointSize = sizeFaceDot; + + bool occluded = test_occlusion(); + +#endif + + finalColor.a *= (occluded) ? alpha : 1.0; + +#if !defined(FACE) + /* Facing based color blend */ + vec3 vpos = point_world_to_view(world_pos); + vec3 view_normal = normalize(normal_object_to_view(vnor) + 1e-4); + vec3 view_vec = (ProjectionMatrix[3][3] == 0.0) ? normalize(vpos) : vec3(0.0, 0.0, 1.0); + float facing = dot(view_vec, view_normal); + facing = 1.0 - abs(facing) * 0.2; + + /* Do interpolation in a non-linear space to have a better visual result. */ + finalColor.rgb = non_linear_blend_color(colorEditMeshMiddle.rgb, finalColor.rgb, facing); +#endif + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_point_vert.glsl new file mode 100644 index 00000000000..956b27e948d --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_point_vert.glsl @@ -0,0 +1,15 @@ + +#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 = mix(colorWire, colorVertexSelect, color); + + gl_PointSize = sizeVertex * 2.0; + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_strand_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_strand_vert.glsl new file mode 100644 index 00000000000..6a92206d524 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_particle_strand_vert.glsl @@ -0,0 +1,35 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +#define no_active_weight 666.0 + +vec3 weight_to_rgb(float t) +{ + if (t == no_active_weight) { + /* No weight. */ + return colorWire.rgb; + } + if (t > 1.0 || t < 0.0) { + /* Error color */ + return vec3(1.0, 0.0, 1.0); + } + else { + return texture(weightTex, t).rgb; + } +} + +void main() +{ + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + + if (useWeight) { + finalColor = vec4(weight_to_rgb(color), 1.0); + } + else { + finalColor = mix(colorWire, colorVertexSelect, color); + } + + view_clipping_distances(world_pos); +} 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 new file mode 100644 index 00000000000..a849cb5160a --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_frag.glsl @@ -0,0 +1,69 @@ +#pragma BLENDER_REQUIRE(overlay_common_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. + */ +#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) + +void main() +{ + vec4 inner_color = vec4(vec3(0.0), 1.0); + vec4 outer_color = vec4(0.0); + + vec2 dd = fwidth(geom_out.stipplePos); + float line_distance = distance(geom_out.stipplePos, geom_out.stippleStart) / max(dd.x, dd.y); + + if (lineStyle == OVERLAY_UV_LINE_STYLE_OUTLINE) { +#ifdef USE_EDGE_SELECT + /* TODO(@campbellbarton): The current wire-edit color contrast enough against the selection. + * Look into changing the default theme color instead of reducing contrast with edge-select. */ + inner_color = (geom_out.selectionFac != 0.0) ? colorEdgeSelect : (colorWireEdit * 0.5); +#else + inner_color = mix(colorWireEdit, colorEdgeSelect, geom_out.selectionFac); +#endif + outer_color = vec4(vec3(0.0), 1.0); + } + else if (lineStyle == OVERLAY_UV_LINE_STYLE_DASH) { + if (fract(line_distance / dashLength) < 0.5) { + inner_color = mix(vec4(vec3(0.35), 1.0), colorEdgeSelect, geom_out.selectionFac); + } + } + else if (lineStyle == OVERLAY_UV_LINE_STYLE_BLACK) { + vec4 base_color = vec4(vec3(0.0), 1.0); + inner_color = mix(base_color, colorEdgeSelect, geom_out.selectionFac); + } + else if (lineStyle == OVERLAY_UV_LINE_STYLE_WHITE) { + vec4 base_color = vec4(1.0); + inner_color = mix(base_color, colorEdgeSelect, geom_out.selectionFac); + } + else if (lineStyle == OVERLAY_UV_LINE_STYLE_SHADOW) { + inner_color = colorUVShadow; + } + + float dist = abs(geom_out.edgeCoord) - max(sizeEdge - 0.5, 0.0); + float dist_outer = dist - max(sizeEdge, 1.0); + float mix_w; + float mix_w_outer; + + if (doSmoothWire) { + mix_w = smoothstep(GRID_LINE_SMOOTH_START, GRID_LINE_SMOOTH_END, dist); + mix_w_outer = smoothstep(GRID_LINE_SMOOTH_START, GRID_LINE_SMOOTH_END, dist_outer); + } + else { + mix_w = step(0.5, dist); + mix_w_outer = step(0.5, dist_outer); + } + + vec4 final_color = mix(outer_color, inner_color, 1.0 - mix_w * outer_color.a); + final_color.a *= 1.0 - (outer_color.a > 0.0 ? mix_w_outer : mix_w); + final_color.a *= alpha; + + fragColor = final_color; +} 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 new file mode 100644 index 00000000000..8b19f671139 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_geom.glsl @@ -0,0 +1,57 @@ +#pragma BLENDER_REQUIRE(overlay_common_lib.glsl) + +void do_vertex( + vec4 pos, float selection_fac, vec2 stipple_start, vec2 stipple_pos, float coord, vec2 offset) +{ + geom_out.selectionFac = selection_fac; + geom_out.edgeCoord = coord; + geom_out.stippleStart = stipple_start; + geom_out.stipplePos = stipple_pos; + + gl_Position = pos; + /* Multiply offset by 2 because gl_Position range is [-1..1]. */ + gl_Position.xy += offset * 2.0; + EmitVertex(); +} + +void main() +{ + vec2 ss_pos[2]; + vec4 pos0 = gl_in[0].gl_Position; + vec4 pos1 = gl_in[1].gl_Position; + ss_pos[0] = pos0.xy / pos0.w; + ss_pos[1] = pos1.xy / pos1.w; + + float half_size = sizeEdge; + /* Enlarge edge for outline drawing. */ + /* Factor of 3.0 out of nowhere! Seems to fix issues with float imprecision. */ + half_size += (lineStyle == OVERLAY_UV_LINE_STYLE_OUTLINE) ? + max(sizeEdge * (doSmoothWire ? 1.0 : 3.0), 1.0) : + 0.0; + /* Add 1 px for AA */ + if (doSmoothWire) { + half_size += 0.5; + } + + 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); + float selectFac0 = geom_in[0].selectionFac; + float selectFac1 = geom_in[1].selectionFac; +#ifdef USE_EDGE_SELECT + /* No blending with edge selection. */ + selectFac1 = selectFac0; +#endif + + do_vertex( + pos0, selectFac0, geom_in[0].stippleStart, geom_in[0].stipplePos, half_size, edge_ofs.xy); + do_vertex( + pos0, selectFac0, geom_in[0].stippleStart, geom_in[0].stipplePos, -half_size, -edge_ofs.xy); + do_vertex( + pos1, selectFac1, geom_in[1].stippleStart, geom_in[1].stipplePos, half_size, edge_ofs.xy); + do_vertex( + pos1, selectFac1, geom_in[1].stippleStart, geom_in[1].stipplePos, -half_size, -edge_ofs.xy); + + EndPrimitive(); +} 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 new file mode 100644 index 00000000000..23f1a44c321 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_edges_vert.glsl @@ -0,0 +1,27 @@ +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +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; + gl_Position.xy = floor(gl_Position.xy * half_viewport_res) / half_viewport_res + + half_pixel_offset; + +#ifdef USE_EDGE_SELECT + bool is_select = (flag & EDGE_UV_SELECT) != 0; +#else + bool is_select = (flag & VERT_UV_SELECT) != 0; +#endif + geom_in.selectionFac = is_select ? 1.0 : 0.0; + /* Move selected edges to the top + * Vertices are between 0.0 and 0.2, Edges between 0.2 and 0.4 + * actual pixels are at 0.75, 1.0 is used for the background. */ + float depth = is_select ? 0.25 : 0.35; + gl_Position.z = depth; + + /* Avoid precision loss. */ + geom_in.stippleStart = geom_in.stipplePos = 500.0 + 500.0 * (gl_Position.xy / gl_Position.w); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_face_dots_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_face_dots_vert.glsl new file mode 100644 index 00000000000..280b31ea463 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_face_dots_vert.glsl @@ -0,0 +1,10 @@ +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + vec3 world_pos = point_object_to_world(vec3(au, 0.0)); + gl_Position = point_world_to_ndc(world_pos); + + finalColor = ((flag & FACE_UV_SELECT) != 0) ? colorVertexSelect : vec4(colorWire.rgb, 1.0); + gl_PointSize = pointSize; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_faces_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_faces_vert.glsl new file mode 100644 index 00000000000..80ea6228675 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_faces_vert.glsl @@ -0,0 +1,14 @@ +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + vec3 world_pos = point_object_to_world(vec3(au, 0.0)); + gl_Position = point_world_to_ndc(world_pos); + + bool is_selected = (flag & FACE_UV_SELECT) != 0; + bool is_active = (flag & FACE_UV_ACTIVE) != 0; + + finalColor = (is_selected) ? colorFaceSelect : colorFace; + finalColor = (is_active) ? colorEditMeshActive : finalColor; + finalColor.a *= uvOpacity; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_image_mask_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_image_mask_frag.glsl new file mode 100644 index 00000000000..a1392abbb92 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_image_mask_frag.glsl @@ -0,0 +1,8 @@ +#pragma BLENDER_REQUIRE(common_colormanagement_lib.glsl) + +void main() +{ + vec2 uvs_clamped = clamp(uvs, 0.0, 1.0); + float mask_value = texture_read_as_linearrgb(imgTexture, true, uvs_clamped).r; + fragColor = vec4(color.rgb * mask_value, color.a); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_image_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_image_vert.glsl new file mode 100644 index 00000000000..7ecbb513265 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_image_vert.glsl @@ -0,0 +1,11 @@ +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + /* `pos` contains the coordinates of a quad (-1..1). but we need the coordinates of an image + * plane (0..1) */ + vec3 image_pos = pos * 0.5 + 0.5; + vec4 position = point_object_to_ndc(image_pos); + gl_Position = position; + uvs = image_pos.xy; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_stretching_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_stretching_vert.glsl new file mode 100644 index 00000000000..bb086e8d9f5 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_stretching_vert.glsl @@ -0,0 +1,82 @@ +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +vec3 weight_to_rgb(float weight) +{ + vec3 r_rgb; + float blend = ((weight / 2.0) + 0.5); + + if (weight <= 0.25) { /* blue->cyan */ + r_rgb[0] = 0.0; + r_rgb[1] = blend * weight * 4.0; + r_rgb[2] = blend; + } + else if (weight <= 0.50) { /* cyan->green */ + r_rgb[0] = 0.0; + r_rgb[1] = blend; + r_rgb[2] = blend * (1.0 - ((weight - 0.25) * 4.0)); + } + else if (weight <= 0.75) { /* green->yellow */ + r_rgb[0] = blend * ((weight - 0.50) * 4.0); + r_rgb[1] = blend; + r_rgb[2] = 0.0; + } + else if (weight <= 1.0) { /* yellow->red */ + r_rgb[0] = blend; + r_rgb[1] = blend * (1.0 - ((weight - 0.75) * 4.0)); + r_rgb[2] = 0.0; + } + else { + /* exceptional value, unclamped or nan, + * avoid uninitialized memory use */ + r_rgb[0] = 1.0; + r_rgb[1] = 0.0; + r_rgb[2] = 1.0; + } + + return r_rgb; +} + +#define M_PI 3.1415926535897932 + +vec2 angle_to_v2(float angle) +{ + return vec2(cos(angle), sin(angle)); +} + +/* Adapted from BLI_math_vector.h */ +float angle_normalized_v2v2(vec2 v1, vec2 v2) +{ + v1 = normalize(v1 * aspect); + v2 = normalize(v2 * aspect); + /* this is the same as acos(dot_v3v3(v1, v2)), but more accurate */ + bool q = (dot(v1, v2) >= 0.0); + vec2 v = (q) ? (v1 - v2) : (v1 + v2); + float a = 2.0 * asin(length(v) / 2.0); + return (q) ? a : M_PI - a; +} + +float area_ratio_to_stretch(float ratio, float tot_ratio, float inv_tot_ratio) +{ + ratio *= (ratio > 0.0f) ? tot_ratio : -inv_tot_ratio; + return (ratio > 1.0f) ? (1.0f / ratio) : ratio; +} + +void main() +{ + vec3 world_pos = point_object_to_world(vec3(pos, 0.0)); + gl_Position = point_world_to_ndc(world_pos); + +#ifdef STRETCH_ANGLE + vec2 v1 = angle_to_v2(uv_angles.x * M_PI); + vec2 v2 = angle_to_v2(uv_angles.y * M_PI); + float uv_angle = angle_normalized_v2v2(v1, v2) / M_PI; + float stretch = 1.0 - abs(uv_angle - angle); + stretch = stretch; + stretch = 1.0 - stretch * stretch; +#else + float stretch = 1.0 - area_ratio_to_stretch(ratio, totalAreaRatio, totalAreaRatioInv); + +#endif + + finalColor = vec4(weight_to_rgb(stretch), 1.0); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_tiled_image_borders_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_tiled_image_borders_vert.glsl new file mode 100644 index 00000000000..bc5235b9cab --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_tiled_image_borders_vert.glsl @@ -0,0 +1,14 @@ +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +#ifndef USE_GPU_SHADER_CREATE_INFO +in vec3 pos; +#endif + +void main() +{ + /* `pos` contains the coordinates of a quad (-1..1). but we need the coordinates of an image + * plane (0..1) */ + vec3 image_pos = pos * 0.5 + 0.5; + vec4 position = point_object_to_ndc(image_pos); + gl_Position = position; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_verts_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_verts_frag.glsl new file mode 100644 index 00000000000..c0ea6aebe10 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_verts_frag.glsl @@ -0,0 +1,27 @@ + +void main() +{ + float dist = length(gl_PointCoord - vec2(0.5)); + + /* transparent outside of point + * --- 0 --- + * smooth transition + * --- 1 --- + * pure outline color + * --- 2 --- + * smooth transition + * --- 3 --- + * pure fill color + * ... + * dist = 0 at center of point */ + + float midStroke = 0.5 * (radii[1] + radii[2]); + + if (dist > midStroke) { + fragColor.rgb = outlineColor.rgb; + fragColor.a = mix(outlineColor.a, 0.0, smoothstep(radii[1], radii[0], dist)); + } + else { + fragColor = mix(fillColor, outlineColor, smoothstep(radii[3], radii[2], dist)); + } +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_verts_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_verts_vert.glsl new file mode 100644 index 00000000000..9f9b02ce19d --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_edit_uv_verts_vert.glsl @@ -0,0 +1,33 @@ +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +/* TODO: Theme? */ +const vec4 pinned_col = vec4(1.0, 0.0, 0.0, 1.0); + +void main() +{ + bool is_selected = (flag & (VERT_UV_SELECT | FACE_UV_SELECT)) != 0; + bool is_pinned = (flag & VERT_UV_PINNED) != 0; + vec4 deselect_col = (is_pinned) ? pinned_col : vec4(color.rgb, 1.0); + fillColor = (is_selected) ? colorVertexSelect : deselect_col; + outlineColor = (is_pinned) ? pinned_col : vec4(fillColor.rgb, 0.0); + + vec3 world_pos = point_object_to_world(vec3(au, 0.0)); + /* Move selected vertices to the top + * Vertices are between 0.0 and 0.2, Edges between 0.2 and 0.4 + * actual pixels are at 0.75, 1.0 is used for the background. */ + float depth = is_selected ? (is_pinned ? 0.05 : 0.10) : 0.15; + gl_Position = vec4(point_world_to_ndc(world_pos).xy, depth, 1.0); + gl_PointSize = pointSize; + + /* calculate concentric radii in pixels */ + float radius = 0.5 * pointSize; + + /* start at the outside and progress toward the center */ + radii[0] = radius; + radii[1] = radius - 1.0; + radii[2] = radius - outlineWidth; + radii[3] = radius - outlineWidth - 1.0; + + /* convert to PointCoord units */ + radii /= pointSize; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_frag.glsl new file mode 100644 index 00000000000..bf29b2b057e --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_frag.glsl @@ -0,0 +1,8 @@ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + fragColor = finalColor; + lineOutput = pack_line_data(gl_FragCoord.xy, edgeStart, edgePos); +} 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 new file mode 100644 index 00000000000..ff7aae523e7 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_groundline_vert.glsl @@ -0,0 +1,22 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +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 p = inst_pos; + p.z *= (pos.z == 0.0) ? 0.0 : 1.0; + float screen_size = mul_project_m4_v3_zfac(p) * sizePixel; + vec3 world_pos = p + screen_pos * screen_size; + + gl_Position = point_world_to_ndc(world_pos); + + /* Convert to screen position [0..sizeVp]. */ + edgePos = edgeStart = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_lightprobe_grid_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_lightprobe_grid_vert.glsl new file mode 100644 index 00000000000..1eee7ab251b --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_lightprobe_grid_vert.glsl @@ -0,0 +1,61 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +vec4 color_from_id(float color_id) +{ + if (isTransform) { + return colorTransform; + } + else if (color_id == 1.0) { + return colorActive; + } + else /* 2.0 */ { + return colorSelect; + } + + return colorTransform; +} + +/* Replace top 2 bits (of the 16bit output) by outlineId. + * This leaves 16K different IDs to create outlines between objects. + * SHIFT = (32 - (16 - 2)) */ +#define SHIFT 18u + +void main() +{ + mat4 model_mat = gridModelMatrix; + model_mat[0][3] = model_mat[1][3] = model_mat[2][3] = 0.0; + model_mat[3][3] = 1.0; + float color_id = gridModelMatrix[3].w; + + ivec3 grid_resolution = ivec3(gridModelMatrix[0].w, gridModelMatrix[1].w, gridModelMatrix[2].w); + + vec3 ls_cell_location; + /* Keep in sync with update_irradiance_probe */ + ls_cell_location.z = float(gl_VertexID % grid_resolution.z); + ls_cell_location.y = float((gl_VertexID / grid_resolution.z) % grid_resolution.y); + ls_cell_location.x = float(gl_VertexID / (grid_resolution.z * grid_resolution.y)); + + ls_cell_location += 0.5; + ls_cell_location /= vec3(grid_resolution); + ls_cell_location = ls_cell_location * 2.0 - 1.0; + + vec3 ws_cell_location = (model_mat * vec4(ls_cell_location, 1.0)).xyz; + gl_Position = point_world_to_ndc(ws_cell_location); + gl_PointSize = sizeVertex * 2.0; + + finalColor = color_from_id(color_id); + + /* Shade occluded points differently. */ + vec4 p = gl_Position / gl_Position.w; + float z_depth = texture(depthBuffer, p.xy * 0.5 + 0.5).r * 2.0 - 1.0; + float z_delta = p.z - z_depth; + if (z_delta > 0.0) { + float fac = 1.0 - z_delta * 10000.0; + /* Smooth blend to avoid flickering. */ + finalColor = mix(colorBackground, finalColor, clamp(fac, 0.5, 1.0)); + } + + view_clipping_distances(ws_cell_location); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_frag.glsl new file mode 100644 index 00000000000..d92b947ef89 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_frag.glsl @@ -0,0 +1,20 @@ + +void main() +{ + vec2 centered = abs(gl_PointCoord - vec2(0.5)); + float dist = max(centered.x, centered.y); + + float fac = dist * dist * 4.0; + /* Non linear blend. */ + vec4 col1 = sqrt(colorEditMeshMiddle); + vec4 col2 = sqrt(finalColor); + fragColor = mix(col1, col2, 0.45 + fac * 0.65); + fragColor *= fragColor; + + lineOutput = vec4(0.0); + + /* Make the effect more like a fresnel by offsetting + * the depth and creating mini-spheres. + * Disabled as it has performance impact. */ + // gl_FragDepth = gl_FragCoord.z + 1e-6 * fac; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_vert.glsl new file mode 100644 index 00000000000..f283934816c --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_loose_point_vert.glsl @@ -0,0 +1,17 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + /* Extract data packed inside the unused mat4 members. */ + mat4 obmat = ModelMatrix; + finalColor = vec4(obmat[0][3], obmat[1][3], obmat[2][3], obmat[3][3]); + + vec3 world_pos = (ModelMatrix * vec4(pos, 1.0)).xyz; + gl_Position = point_world_to_ndc(world_pos); + + gl_PointSize = sizeVertex * 2.0; + + view_clipping_distances(world_pos); +} 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 new file mode 100644 index 00000000000..de999c241c0 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_point_vert.glsl @@ -0,0 +1,23 @@ + +#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); + + gl_PointSize = sizeObjectCenter; + float radius = 0.5 * sizeObjectCenter; + float outline_width = sizePixel; + radii[0] = radius; + radii[1] = radius - 1.0; + radii[2] = radius - outline_width; + radii[3] = radius - outline_width - 1.0; + radii /= sizeObjectCenter; + + fillColor = color; + 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 new file mode 100644 index 00000000000..b2578970c9b --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_vert.glsl @@ -0,0 +1,226 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +#define lamp_area_size inst_data.xy +#define lamp_clip_sta inst_data.z +#define lamp_clip_end inst_data.w + +#define lamp_spot_cosine inst_data.x +#define lamp_spot_blend inst_data.y + +#define camera_corner inst_data.xy +#define camera_center inst_data.zw +#define camera_dist color.a +#define camera_dist_sta inst_data.z +#define camera_dist_end inst_data.w +#define camera_distance_color inst_data.x + +#define empty_size inst_data.xyz +#define empty_scale inst_data.w + +/* TODO(fclem): Share with C code. */ +#define VCLASS_LIGHT_AREA_SHAPE (1 << 0) +#define VCLASS_LIGHT_SPOT_SHAPE (1 << 1) +#define VCLASS_LIGHT_SPOT_BLEND (1 << 2) +#define VCLASS_LIGHT_SPOT_CONE (1 << 3) +#define VCLASS_LIGHT_DIST (1 << 4) + +#define VCLASS_CAMERA_FRAME (1 << 5) +#define VCLASS_CAMERA_DIST (1 << 6) +#define VCLASS_CAMERA_VOLUME (1 << 7) + +#define VCLASS_SCREENSPACE (1 << 8) +#define VCLASS_SCREENALIGNED (1 << 9) + +#define VCLASS_EMPTY_SCALED (1 << 10) +#define VCLASS_EMPTY_AXES (1 << 11) +#define VCLASS_EMPTY_AXES_NAME (1 << 12) +#define VCLASS_EMPTY_AXES_SHADOW (1 << 13) +#define VCLASS_EMPTY_SIZE (1 << 14) + +void main() +{ + /* Extract data packed inside the unused mat4 members. */ + vec4 inst_data = vec4(inst_obmat[0][3], inst_obmat[1][3], inst_obmat[2][3], inst_obmat[3][3]); + float inst_color_data = color.a; + mat4 obmat = inst_obmat; + obmat[0][3] = obmat[1][3] = obmat[2][3] = 0.0; + obmat[3][3] = 1.0; + + finalColor = color; + if (color.a < 0.0) { + finalColor.a = 1.0; + } + + float lamp_spot_sine; + vec3 vpos = pos; + vec3 vofs = vec3(0.0); + /* Lights */ + if ((vclass & VCLASS_LIGHT_AREA_SHAPE) != 0) { + /* HACK: use alpha color for spots to pass the area_size. */ + if (inst_color_data < 0.0) { + lamp_area_size.xy = vec2(-inst_color_data); + } + vpos.xy *= lamp_area_size.xy; + } + else if ((vclass & VCLASS_LIGHT_SPOT_SHAPE) != 0) { + lamp_spot_sine = sqrt(1.0 - lamp_spot_cosine * lamp_spot_cosine); + lamp_spot_sine *= ((vclass & VCLASS_LIGHT_SPOT_BLEND) != 0) ? lamp_spot_blend : 1.0; + vpos = vec3(pos.xy * lamp_spot_sine, -lamp_spot_cosine); + } + else if ((vclass & VCLASS_LIGHT_DIST) != 0) { + /* Meh nasty mess. Select one of the 6 axes to display on. (see light_distance_z_get()) */ + int dist_axis = int(pos.z); + float dist = pos.z - floor(pos.z) - 0.5; + float inv = sign(dist); + dist = (abs(dist) > 0.15) ? lamp_clip_end : lamp_clip_sta; + vofs[dist_axis] = inv * dist / length(obmat[dist_axis].xyz); + vpos.z = 0.0; + if (lamp_clip_end < 0.0) { + vpos = vofs = vec3(0.0); + } + } + /* Camera */ + else if ((vclass & VCLASS_CAMERA_FRAME) != 0) { + if ((vclass & VCLASS_CAMERA_VOLUME) != 0) { + vpos.z = mix(color.b, color.a, pos.z); + } + else if (camera_dist > 0.0) { + vpos.z = -abs(camera_dist); + } + else { + vpos.z *= -abs(camera_dist); + } + vpos.xy = (camera_center + camera_corner * vpos.xy) * abs(vpos.z); + } + else if ((vclass & VCLASS_CAMERA_DIST) != 0) { + vofs.xy = vec2(0.0); + vofs.z = -mix(camera_dist_sta, camera_dist_end, pos.z); + vpos.z = 0.0; + /* Distance line endpoints color */ + if (any(notEqual(pos.xy, vec2(0.0)))) { + /* Override color. */ + switch (int(camera_distance_color)) { + case 0: /* Mist */ + finalColor = vec4(0.5, 0.5, 0.5, 1.0); + break; + case 1: /* Mist Active */ + finalColor = vec4(1.0, 1.0, 1.0, 1.0); + break; + case 2: /* Clip */ + finalColor = vec4(0.5, 0.5, 0.25, 1.0); + break; + case 3: /* Clip Active */ + finalColor = vec4(1.0, 1.0, 0.5, 1.0); + break; + } + } + /* Focus cross */ + if (pos.z == 2.0) { + vofs.z = 0.0; + if (camera_dist < 0.0) { + vpos.z = -abs(camera_dist); + } + else { + /* Disabled */ + vpos = vec3(0.0); + } + } + } + /* Empties */ + else if ((vclass & VCLASS_EMPTY_SCALED) != 0) { + /* This is a bit silly but we avoid scaling the object matrix on CPU (saving a mat4 mul) */ + vpos *= empty_scale; + } + else if ((vclass & VCLASS_EMPTY_SIZE) != 0) { + /* This is a bit silly but we avoid scaling the object matrix on CPU (saving a mat4 mul) */ + vpos *= empty_size; + } + else if ((vclass & VCLASS_EMPTY_AXES) != 0) { + float axis = vpos.z; + vofs[int(axis)] = (1.0 + fract(axis)) * empty_scale; + /* Scale uniformly by axis length */ + vpos *= length(obmat[int(axis)].xyz) * empty_scale; + + vec3 axis_color = vec3(0.0); + axis_color[int(axis)] = 1.0; + finalColor.rgb = mix(axis_color + fract(axis), color.rgb, color.a); + finalColor.a = 1.0; + } + + /* Not exclusive with previous flags. */ + if ((vclass & VCLASS_CAMERA_VOLUME) != 0) { + /* Unpack final color. */ + int color_class = int(floor(color.r)); + float color_intensity = fract(color.r); + switch (color_class) { + case 0: /* No eye (convergence plane). */ + finalColor = vec4(1.0, 1.0, 1.0, 1.0); + break; + case 1: /* Left eye. */ + finalColor = vec4(0.0, 1.0, 1.0, 1.0); + break; + case 2: /* Right eye. */ + finalColor = vec4(1.0, 0.0, 0.0, 1.0); + break; + } + finalColor *= vec4(vec3(color_intensity), color.g); + } + + 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 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; + world_pos = (obmat * vec4(vofs, 1.0)).xyz + screen_pos; + } + else { + world_pos = (obmat * vec4(vofs + vpos, 1.0)).xyz; + } + + if ((vclass & VCLASS_LIGHT_SPOT_CONE) != 0) { + /* Compute point on the cone before and after this one. */ + vec2 perp = vec2(pos.y, -pos.x); + const float incr_angle = 2.0 * 3.1415 / 32.0; + const vec2 slope = vec2(cos(incr_angle), sin(incr_angle)); + vec3 p0 = vec3((pos.xy * slope.x + perp * slope.y) * lamp_spot_sine, -lamp_spot_cosine); + vec3 p1 = vec3((pos.xy * slope.x - perp * slope.y) * lamp_spot_sine, -lamp_spot_cosine); + p0 = (obmat * vec4(p0, 1.0)).xyz; + p1 = (obmat * vec4(p1, 1.0)).xyz; + /* Compute normals of each side. */ + vec3 edge = obmat[3].xyz - world_pos; + vec3 n0 = normalize(cross(edge, p0 - world_pos)); + vec3 n1 = normalize(cross(edge, world_pos - p1)); + bool persp = (ProjectionMatrix[3][3] == 0.0); + vec3 V = (persp) ? normalize(ViewMatrixInverse[3].xyz - world_pos) : ViewMatrixInverse[2].xyz; + /* Discard non-silhouette edges. */ + bool facing0 = dot(n0, V) > 0.0; + bool facing1 = dot(n1, V) > 0.0; + if (facing0 == facing1) { + /* Hide line by making it cover 0 pixels. */ + world_pos = obmat[3].xyz; + } + } + + gl_Position = point_world_to_ndc(world_pos); + + /* Convert to screen position [0..sizeVp]. */ + edgePos = edgeStart = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; + +#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. */ + /* 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); +#endif + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_frag.glsl new file mode 100644 index 00000000000..f32e3a8564e --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_frag.glsl @@ -0,0 +1,26 @@ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + fragColor = finalColor; + + /* Stipple */ + const float dash_width = 6.0; + const float dash_factor = 0.5; + + lineOutput = pack_line_data(gl_FragCoord.xy, stipple_start, stipple_coord); + + float dist = distance(stipple_start, stipple_coord); + + if (fragColor.a == 0.0) { + /* Disable stippling. */ + dist = 0.0; + } + + fragColor.a = 1.0; + + if (fract(dist / dash_width) > dash_factor) { + discard; + } +} 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 new file mode 100644 index 00000000000..cd217021e8f --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_extra_wire_vert.glsl @@ -0,0 +1,47 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +vec2 screen_position(vec4 p) +{ + return ((p.xy / p.w) * 0.5 + 0.5) * sizeViewport.xy; +} + +void main() +{ + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + +#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. */ + /* 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); +#endif + + stipple_coord = stipple_start = screen_position(gl_Position); + +#ifdef OBJECT_WIRE + /* Extract data packed inside the unused mat4 members. */ + finalColor = vec4(ModelMatrix[0][3], ModelMatrix[1][3], ModelMatrix[2][3], ModelMatrix[3][3]); +#else + + if (colorid != 0) { + /* TH_CAMERA_PATH is the only color code at the moment. + * Checking `colorid != 0` to avoid having to sync its value with the GLSL code. */ + finalColor = colorCameraPath; + finalColor.a = 0.0; /* No Stipple */ + } + else { + finalColor = color; + finalColor.a = 1.0; /* Stipple */ + } +#endif + +#ifdef SELECT_EDGES + finalColor.a = 0.0; /* No Stipple */ +#endif + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_facing_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_facing_frag.glsl new file mode 100644 index 00000000000..8208689d113 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_facing_frag.glsl @@ -0,0 +1,5 @@ + +void main() +{ + fragColor = gl_FrontFacing ? colorFaceFront : colorFaceBack; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_facing_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_facing_vert.glsl new file mode 100644 index 00000000000..d98caee6a25 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_facing_vert.glsl @@ -0,0 +1,10 @@ + +#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); + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_grid_background_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_grid_background_frag.glsl new file mode 100644 index 00000000000..37958319b44 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_grid_background_frag.glsl @@ -0,0 +1,7 @@ + +void main() +{ + fragColor = color; + float scene_depth = texelFetch(depthBuffer, ivec2(gl_FragCoord.xy), 0).r; + fragColor.a = (scene_depth == 1.0) ? 1.0 : 0.0; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_grid_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_grid_frag.glsl new file mode 100644 index 00000000000..25f4984f119 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_grid_frag.glsl @@ -0,0 +1,232 @@ +/** + * Infinite grid: + * Draw antialiazed grid and axes of different sizes with smooth blending between Level of details. + * We draw multiple triangles to avoid float precision issues due to perspective interpolation. + **/ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) +#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. + */ +#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_STEP(dist) smoothstep(GRID_LINE_SMOOTH_START, GRID_LINE_SMOOTH_END, dist) + +float get_grid(vec2 co, vec2 fwidthCos, float grid_scale) +{ + float 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); + /* 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); +} + +vec3 get_axes(vec3 co, vec3 fwidthCos, float line_size) +{ + vec3 axes_domain = abs(co); + /* 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)); +} + +#define linearstep(p0, p1, v) (clamp(((v) - (p0)) / abs((p1) - (p0)), 0.0, 1.0)) + +void main() +{ + vec3 P = local_pos * grid_buf.size.xyz; + vec3 dFdxPos = dFdx(P); + vec3 dFdyPos = dFdy(P); + vec3 fwidthPos = abs(dFdxPos) + abs(dFdyPos); + P += cameraPos * plane_axes; + + float dist, fade; + bool is_persp = ProjectionMatrix[3][3] == 0.0; + if (is_persp) { + vec3 V = cameraPos - P; + dist = length(V); + V /= dist; + + float angle; + if (flag_test(grid_flag, PLANE_XZ)) { + angle = V.y; + } + else if (flag_test(grid_flag, PLANE_YZ)) { + angle = V.x; + } + else { + angle = V.z; + } + + angle = 1.0 - abs(angle); + angle *= angle; + fade = 1.0 - angle * angle; + fade *= 1.0 - smoothstep(0.0, grid_buf.distance, dist - grid_buf.distance); + } + else { + dist = gl_FragCoord.z * 2.0 - 1.0; + /* Avoid fading in +Z direction in camera view (see T70193). */ + dist = flag_test(grid_flag, GRID_CAMERA) ? clamp(dist, 0.0, 1.0) : abs(dist); + fade = 1.0 - smoothstep(0.0, 0.5, dist - 0.5); + dist = 1.0; /* Avoid branch after. */ + + if (flag_test(grid_flag, PLANE_XY)) { + float angle = 1.0 - abs(ViewMatrixInverse[2].z); + dist = 1.0 + angle * 2.0; + angle *= angle; + fade *= 1.0 - angle * angle; + } + } + + if (flag_test(grid_flag, SHOW_GRID)) { + /* Using `max(dot(dFdxPos, screenVecs[0]), dot(dFdyPos, screenVecs[1]))` + * would be more accurate, but not really necessary. */ + float grid_res = dot(dFdxPos, screenVecs[0].xyz); + + /* The grid begins to appear when it comprises 4 pixels. */ + grid_res *= 4; + + /* For UV/Image editor use grid_buf.zoom_factor. */ + if (flag_test(grid_flag, PLANE_IMAGE) && + /* Grid begins to appear when the length of one grid unit is at least + * (256/grid_size) pixels Value of grid_size defined in `overlay_grid.c`. */ + !flag_test(grid_flag, CUSTOM_GRID)) { + 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)); + } +#endif +#undef grid_step + + float blend = 1.0 - linearstep(scale[0], scale[1], grid_res); + blend = blend * blend * blend; + + vec2 grid_pos, grid_fwidth; + if (flag_test(grid_flag, PLANE_XZ)) { + grid_pos = P.xz; + grid_fwidth = fwidthPos.xz; + } + else if (flag_test(grid_flag, PLANE_YZ)) { + grid_pos = P.yz; + grid_fwidth = fwidthPos.yz; + } + else { + grid_pos = P.xy; + 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]); + + out_color = colorGrid; + out_color.a *= gridA * blend; + out_color = mix(out_color, mix(colorGrid, colorGridEmphasis, blend), gridB); + out_color = mix(out_color, colorGridEmphasis, gridC); + } + else { + out_color = vec4(colorGrid.rgb, 0.0); + } + + if (flag_test(grid_flag, (SHOW_AXIS_X | SHOW_AXIS_Y | SHOW_AXIS_Z))) { + /* Setup axes 'domains' */ + vec3 axes_dist, axes_fwidth; + + if (flag_test(grid_flag, SHOW_AXIS_X)) { + axes_dist.x = dot(P.yz, plane_axes.yz); + axes_fwidth.x = dot(fwidthPos.yz, plane_axes.yz); + } + if (flag_test(grid_flag, SHOW_AXIS_Y)) { + axes_dist.y = dot(P.xz, plane_axes.xz); + axes_fwidth.y = dot(fwidthPos.xz, plane_axes.xz); + } + if (flag_test(grid_flag, SHOW_AXIS_Z)) { + axes_dist.z = dot(P.xy, plane_axes.xy); + axes_fwidth.z = dot(fwidthPos.xy, plane_axes.xy); + } + + /* Computing all axes at once using vec3 */ + vec3 axes = get_axes(axes_dist, axes_fwidth, 0.1); + + if (flag_test(grid_flag, SHOW_AXIS_X)) { + out_color.a = max(out_color.a, axes.x); + out_color.rgb = (axes.x < 1e-8) ? out_color.rgb : colorGridAxisX.rgb; + } + if (flag_test(grid_flag, SHOW_AXIS_Y)) { + out_color.a = max(out_color.a, axes.y); + out_color.rgb = (axes.y < 1e-8) ? out_color.rgb : colorGridAxisY.rgb; + } + if (flag_test(grid_flag, SHOW_AXIS_Z)) { + out_color.a = max(out_color.a, axes.z); + out_color.rgb = (axes.z < 1e-8) ? out_color.rgb : colorGridAxisZ.rgb; + } + } + + float scene_depth = texelFetch(depth_tx, ivec2(gl_FragCoord.xy), 0).r; + if (flag_test(grid_flag, GRID_BACK)) { + fade *= (scene_depth == 1.0) ? 1.0 : 0.0; + } + else { + /* Add a small bias so the grid will always be below of a mesh with the same depth. */ + float grid_depth = gl_FragCoord.z + 4.8e-7; + /* Manual, non hard, depth test: + * Progressively fade the grid below occluders + * (avoids popping visuals due to depth buffer precision) */ + /* Harder settings tend to flicker more, + * but have less "see through" appearance. */ + float bias = max(fwidth(gl_FragCoord.z), 2.4e-7); + fade *= linearstep(grid_depth, grid_depth + bias, scene_depth); + } + + out_color.a *= fade; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_grid_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_grid_vert.glsl new file mode 100644 index 00000000000..b81f1a24358 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_grid_vert.glsl @@ -0,0 +1,43 @@ +/** + * Infinite grid: + * Draw antialiazed grid and axes of different sizes with smooth blending between Level of details. + * We draw multiple triangles to avoid float precision issues due to perspective interpolation. + **/ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) +#pragma BLENDER_REQUIRE(common_math_lib.glsl) + +void main() +{ + vec3 vert_pos; + + /* Project camera pos to the needed plane */ + if (flag_test(grid_flag, PLANE_XY)) { + vert_pos = vec3(pos.x, pos.y, 0.0); + } + else if (flag_test(grid_flag, PLANE_XZ)) { + vert_pos = vec3(pos.x, 0.0, pos.y); + } + else if (flag_test(grid_flag, PLANE_YZ)) { + vert_pos = vec3(0.0, pos.x, pos.y); + } + else /* PLANE_IMAGE */ { + vert_pos = vec3(pos.xy * 0.5 + 0.5, 0.0); + } + + local_pos = vert_pos; + + vec3 real_pos = cameraPos * plane_axes + vert_pos * grid_buf.size.xyz; + + /* Used for additional Z axis */ + if (flag_test(grid_flag, CLIP_ZPOS)) { + real_pos.z = clamp(real_pos.z, 0.0, 1e30); + local_pos.z = clamp(local_pos.z, 0.0, 1.0); + } + if (flag_test(grid_flag, CLIP_ZNEG)) { + real_pos.z = clamp(real_pos.z, -1e30, 0.0); + local_pos.z = clamp(local_pos.z, -1.0, 0.0); + } + + gl_Position = ViewProjectionMatrix * 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 new file mode 100644 index 00000000000..e0339507e0f --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_image_frag.glsl @@ -0,0 +1,24 @@ +#pragma BLENDER_REQUIRE(common_colormanagement_lib.glsl) + +void main() +{ + vec2 uvs_clamped = clamp(uvs, 0.0, 1.0); + vec4 tex_color; + tex_color = texture_read_as_linearrgb(imgTexture, imgPremultiplied, uvs_clamped); + + fragColor = tex_color * color; + + if (!imgAlphaBlend) { + /* Arbitrary discard anything below 5% opacity. + * Note that this could be exposed to the User. */ + if (tex_color.a < 0.05) { + discard; + } + else { + fragColor.a = 1.0; + } + } + + /* Pre-multiplied blending. */ + fragColor.rgb *= fragColor.a; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_image_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_image_vert.glsl new file mode 100644 index 00000000000..45cddb3610d --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_image_vert.glsl @@ -0,0 +1,29 @@ + +#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); + if (isCameraBackground) { + /* Model matrix converts to view position to avoid jittering (see T91398). */ + gl_Position = point_view_to_ndc(world_pos); + /* Camera background images are not really part of the 3D space. + * It makes no sense to apply clipping on them. */ + view_clipping_distances_bypass(); + } + else { + gl_Position = point_world_to_ndc(world_pos); + view_clipping_distances(world_pos); + } + + if (depthSet) { + /* Result in a position at 1.0 (far plane). Small epsilon to avoid precision issue. + * This mimics the effect of infinite projection matrix + * (see http://www.terathon.com/gdc07_lengyel.pdf). */ + gl_Position.z = gl_Position.w - 2.4e-7; + view_clipping_distances_bypass(); + } + + uvs = pos.xy * 0.5 + 0.5; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_frag.glsl new file mode 100644 index 00000000000..324d22501f9 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_frag.glsl @@ -0,0 +1,5 @@ + +void main() +{ + fragColor = interp.color; +} 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 new file mode 100644 index 00000000000..29346a44863 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_geom.glsl @@ -0,0 +1,37 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +vec2 compute_dir(vec2 v0, vec2 v1) +{ + vec2 dir = normalize(v1 - v0 + 1e-8); + dir = vec2(-dir.y, dir.x); + return dir; +} + +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; + + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + float line_size = float(lineThickness) * sizePixel; + + view_clipping_distances_set(gl_in[0]); + interp_out.color = interp_in[0].color; + t = edge_dir * (line_size * (is_persp ? gl_in[0].gl_Position.w : 1.0)); + gl_Position = gl_in[0].gl_Position + vec4(t, 0.0, 0.0); + EmitVertex(); + gl_Position = gl_in[0].gl_Position - vec4(t, 0.0, 0.0); + EmitVertex(); + + view_clipping_distances_set(gl_in[1]); + interp_out.color = interp_in[1].color; + t = edge_dir * (line_size * (is_persp ? gl_in[1].gl_Position.w : 1.0)); + gl_Position = gl_in[1].gl_Position + vec4(t, 0.0, 0.0); + EmitVertex(); + gl_Position = gl_in[1].gl_Position - vec4(t, 0.0, 0.0); + EmitVertex(); + EndPrimitive(); +} 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 new file mode 100644 index 00000000000..bc74a436f5e --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert.glsl @@ -0,0 +1,87 @@ + +#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) + +void main() +{ + gl_Position = ViewProjectionMatrix * vec4(pos, 1.0); + + interp.ss_pos = proj(gl_Position); + + int frame = gl_VertexID + 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 */ + interp.color.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); + } + interp.color.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 */ + interp.color.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); + } + + interp.color.rgb = mix(colorBonePose.rgb, blend_base, intensity); + } + } + else { + if (use_custom_color) { + /* Custom color: current frame color is slightly darker than user selected color */ + interp.color.rgb = customColor * 0.5; + } + else { + /* green - on frameCurrent */ + if (selected) { + intensity = 0.92f; + } + else { + intensity = 0.75f; + } + interp.color.rgb = mix(colorBackground.rgb, blend_base, intensity); + } + } + + interp.color.a = 1.0; + + view_clipping_distances(pos); +} 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 new file mode 100644 index 00000000000..5027525b9b3 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_motion_path_point_vert.glsl @@ -0,0 +1,47 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +#define pointSize mpathPointSettings.x +#define frameCurrent mpathPointSettings.y +#define cacheStart mpathPointSettings.z +#define stepSize mpathPointSettings.w + +void main() +{ + gl_Position = ViewProjectionMatrix * vec4(pos, 1.0); + gl_PointSize = float(pointSize + 2); + + int frame = gl_VertexID + cacheStart; + bool use_custom_color = customColor.x >= 0.0; + finalColor = (use_custom_color) ? vec4(customColor, 1.0) : vec4(1.0); + + /* Bias to reduce z fighting with the path */ + gl_Position.z -= 1e-4; + + if (gl_VertexID % stepSize == 0) { + gl_PointSize = float(pointSize) + 4; + } + + if (showKeyFrames) { + if ((flag & MOTIONPATH_VERT_KEY) != 0) { + gl_PointSize = float(pointSize + 5); + finalColor = colorVertexSelect; + /* Bias more to get these on top of regular points */ + gl_Position.z -= 1e-4; + } + /* Draw big green dot where the current frame is. + * NOTE: this is only done when keyframes are shown, since this adds similar types of clutter + */ + if (frame == frameCurrent) { + gl_PointSize = float(pointSize + 8); + finalColor = colorCurrentFrame; + /* Bias more to get these on top of keyframes */ + gl_Position.z -= 1e-4; + } + } + + gl_PointSize *= sizePixel; + + view_clipping_distances(pos); +} 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 new file mode 100644 index 00000000000..472a589f441 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_detect_frag.glsl @@ -0,0 +1,360 @@ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +#define XPOS (1 << 0) +#define XNEG (1 << 1) +#define YPOS (1 << 2) +#define YNEG (1 << 3) + +#define ALL (XPOS | XNEG | YPOS | YNEG) +#define NONE 0 + +#define DIAG_XNEG_YPOS (XNEG | YPOS) +#define DIAG_XPOS_YPOS (XPOS | YPOS) +#define DIAG_XPOS_YNEG (XPOS | YNEG) +#define DIAG_XNEG_YNEG (XNEG | YNEG) + +#define APEX_XPOS (ALL & (~XPOS)) +#define APEX_XNEG (ALL & (~XNEG)) +#define APEX_YPOS (ALL & (~YPOS)) +#define APEX_YNEG (ALL & (~YNEG)) + +bool has_edge(uint id, vec2 uv, uint ref, inout uint ref_col, inout vec2 depth_uv) +{ + if (ref_col == 0u) { + /* Make outline bleed on the background. */ + ref_col = id; + depth_uv = uv; + } + return (id != ref); +} + +/* A gather4 + check against ref. */ +bvec4 gather_edges(vec2 uv, uint ref) +{ + uvec4 ids; +#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; + 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; + ids.w = textureLod(outlineId, uv - ofs.xy, 0.0).r; +#endif + + return notEqual(ids, uvec4(ref)); +} + +/* Clockwise */ +vec2 rotate_90(vec2 v) +{ + return vec2(v.y, -v.x); +} +vec2 rotate_180(vec2 v) +{ + return vec2(-v.x, -v.y); +} +vec2 rotate_270(vec2 v) +{ + return vec2(-v.y, v.x); +} + +/* Counter-Clockwise */ +bvec4 rotate_90(bvec4 v) +{ + return v.yzwx; +} +bvec4 rotate_180(bvec4 v) +{ + return v.zwxy; +} +bvec4 rotate_270(bvec4 v) +{ + return v.wxyz; +} + +/* Apply offset to line endpoint based on surrounding edges infos. */ +bool line_offset(bvec2 edges, vec2 ofs, inout vec2 line_point) +{ + if (all(edges.xy)) { + line_point.y -= ofs.y; + } + else if (!edges.x) { + line_point.y += ofs.y; + } + else /* !edges.y */ { + line_point.x += ofs.x; + return true; + } + return false; +} + +/* Changes Antialiasing pattern and makes line thicker. 0.0 is thin. */ +#define PROXIMITY_OFS -0.35 + +/* Use surrounding edges to approximate the outline direction to create smooth lines. */ +void straight_line_dir(bvec4 edges1, bvec4 edges2, out vec2 line_start, out vec2 line_end) +{ + /* Y_POS as reference. Other cases are rotated to match reference. */ + line_end = vec2(1.5, 0.5 + PROXIMITY_OFS); + line_start = vec2(-line_end.x, line_end.y); + + vec2 line_ofs = vec2(1.0, 0.5); + if (line_offset(edges1.xw, line_ofs, line_end)) { + line_offset(edges1.yz, line_ofs, line_end); + } + line_ofs = vec2(-line_ofs.x, line_ofs.y); + if (line_offset(edges2.yz, line_ofs, line_start)) { + line_offset(edges2.xw, line_ofs, line_start); + } +} + +vec2 diag_offset(bvec4 edges) +{ + /* X_NEG | Y_POS as reference. Other cases are rotated to match reference. + * So the line is coming from bottom left. */ + if (all(edges.wz)) { + /* Horizontal line. */ + return vec2(2.5, 0.5); + } + else if (all(not(edges.xw))) { + /* Vertical line. */ + return vec2(0.5, 2.5); + } + else if (edges.w) { + /* Less horizontal Line. */ + return vec2(2.5, 0.5); + } + else { + /* Less vertical Line. */ + return vec2(0.5, 2.5); + } +} + +/* Compute line direction vector from the bottom left corner. */ +void diag_dir(bvec4 edges1, bvec4 edges2, out vec2 line_start, out vec2 line_end) +{ + /* Negate instead of rotating back the result of diag_offset. */ + edges2 = not(edges2); + edges2 = rotate_180(edges2); + line_end = diag_offset(edges1); + line_end += diag_offset(edges2); + + if (line_end.x == line_end.y) { + /* Perfect diagonal line. Push line start towards edge. */ + line_start = vec2(-1.0, 1.0) * PROXIMITY_OFS * 0.4; + } + else if (line_end.x > line_end.y) { + /* Horizontal Line. Lower line start. */ + line_start = vec2(0.0, PROXIMITY_OFS); + } + else { + /* Vertical Line. Push line start to the right. */ + line_start = -vec2(PROXIMITY_OFS, 0.0); + } + line_end += line_start; +} + +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 depth_uv = uvs; + + uvec4 ids; +#ifdef GPU_ARB_texture_gather + /* Reminder: Samples order is CW starting from top left. */ + uvec2 tmp1, tmp2, tmp3, tmp4; + if (doThickOutlines) { + tmp1 = textureGather(outlineId, uvs + ofs.xy * vec2(1.5, -0.5)).xy; + tmp2 = textureGather(outlineId, uvs + ofs.xy * vec2(-1.5, -0.5)).yx; + tmp3 = textureGather(outlineId, uvs + ofs.xy * vec2(0.5, 1.5)).wx; + tmp4 = textureGather(outlineId, uvs + ofs.xy * vec2(0.5, -1.5)).xw; + ids.x = tmp1.x; + ids.y = tmp2.x; + ids.z = tmp3.x; + ids.w = tmp4.x; + } + else { + ids.xz = textureGather(outlineId, uvs + ofs.xy * 0.5).zx; + ids.yw = textureGather(outlineId, uvs - ofs.xy * 0.5).xz; + } +#else + ids.x = textureLod(outlineId, uvs + ofs.xz, 0.0).r; + ids.y = textureLod(outlineId, uvs - ofs.xz, 0.0).r; + ids.z = textureLod(outlineId, uvs + ofs.zy, 0.0).r; + ids.w = textureLod(outlineId, uvs - ofs.zy, 0.0).r; +#endif + + bool has_edge_pos_x = has_edge(ids.x, uvs + ofs.xz, ref, ref_col, depth_uv); + bool has_edge_neg_x = has_edge(ids.y, uvs - ofs.xz, ref, ref_col, depth_uv); + bool has_edge_pos_y = has_edge(ids.z, uvs + ofs.zy, ref, ref_col, depth_uv); + bool has_edge_neg_y = has_edge(ids.w, uvs - ofs.zy, ref, ref_col, depth_uv); + + if (doThickOutlines) { + if (!any(bvec4(has_edge_pos_x, has_edge_neg_x, has_edge_pos_y, has_edge_neg_y))) { +#ifdef GPU_ARB_texture_gather + ids.x = tmp1.y; + ids.y = tmp2.y; + ids.z = tmp3.y; + ids.w = tmp4.y; +#else + ids.x = textureLod(outlineId, uvs + 2.0 * ofs.xz, 0.0).r; + ids.y = textureLod(outlineId, uvs - 2.0 * ofs.xz, 0.0).r; + ids.z = textureLod(outlineId, uvs + 2.0 * ofs.zy, 0.0).r; + ids.w = textureLod(outlineId, uvs - 2.0 * ofs.zy, 0.0).r; +#endif + + has_edge_pos_x = has_edge(ids.x, uvs + 2.0 * ofs.xz, ref, ref_col, depth_uv); + has_edge_neg_x = has_edge(ids.y, uvs - 2.0 * ofs.xz, ref, ref_col, depth_uv); + has_edge_pos_y = has_edge(ids.z, uvs + 2.0 * ofs.zy, ref, ref_col, depth_uv); + has_edge_neg_y = has_edge(ids.w, uvs - 2.0 * ofs.zy, ref, ref_col, depth_uv); + } + } + + if (isXrayWires) { + /* Don't inflate the wire outlines too much. */ + has_edge_neg_x = has_edge_neg_y = false; + } + + /* WATCH: Keep in sync with outlineId of the prepass. */ + uint color_id = ref_col >> 14u; + if (ref_col == 0u) { + fragColor = vec4(0.0); + } + else if (color_id == 1u) { + fragColor = colorSelect; + } + else if (color_id == 3u) { + fragColor = colorActive; + } + else { + fragColor = colorTransform; + } + + float ref_depth = textureLod(outlineDepth, depth_uv, 0.0).r; + float scene_depth = textureLod(sceneDepth, depth_uv, 0.0).r; + + /* Avoid bad cases of zfighting for occlusion only. */ + const float epsilon = 3.0 / 8388608.0; + bool occluded = (ref_depth > scene_depth + epsilon); + + /* NOTE: We never set alpha to 1.0 to avoid Antialiasing destroying the line. */ + fragColor *= (occluded ? alphaOcclu : 1.0) * (254.0 / 255.0); + + int edge_case = 0; + edge_case += int(has_edge_pos_x) * XPOS; + edge_case += int(has_edge_neg_x) * XNEG; + edge_case += int(has_edge_pos_y) * YPOS; + edge_case += int(has_edge_neg_y) * YNEG; + + if (edge_case == ALL || edge_case == NONE) { + discard; + } + + if (!doAntiAliasing) { + lineOutput = vec4(0.0); + return; + } + + vec2 line_start, line_end; + vec2 line_ofs; + bvec4 extra_edges, extra_edges2; + /* TODO: simplify this branching hell. */ + 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); + 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 = rotate_180(extra_edges); + extra_edges2 = rotate_180(extra_edges2); + straight_line_dir(extra_edges, extra_edges2, line_start, line_end); + line_start = rotate_180(line_start); + 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 = rotate_90(extra_edges); + extra_edges2 = rotate_90(extra_edges2); + straight_line_dir(extra_edges, extra_edges2, line_start, line_end); + line_start = rotate_90(line_start); + 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 = rotate_270(extra_edges); + extra_edges2 = rotate_270(extra_edges2); + straight_line_dir(extra_edges, extra_edges2, line_start, line_end); + line_start = rotate_270(line_start); + line_end = rotate_270(line_end); + break; + + /* Diagonal */ + case DIAG_XNEG_YPOS: + extra_edges = gather_edges(uvs + ofs.xy * vec2(1.5), ref); + extra_edges2 = gather_edges(uvs + ofs.xy * vec2(-1.5), ref); + diag_dir(extra_edges, extra_edges2, line_start, line_end); + break; + case DIAG_XPOS_YNEG: + extra_edges = gather_edges(uvs - ofs.xy * vec2(1.5), ref); + extra_edges2 = gather_edges(uvs - ofs.xy * vec2(-1.5), ref); + extra_edges = rotate_180(extra_edges); + extra_edges2 = rotate_180(extra_edges2); + diag_dir(extra_edges, extra_edges2, line_start, line_end); + line_start = rotate_180(line_start); + line_end = rotate_180(line_end); + break; + case DIAG_XPOS_YPOS: + extra_edges = gather_edges(uvs + ofs.xy * vec2(1.5, -1.5), ref); + extra_edges2 = gather_edges(uvs - ofs.xy * vec2(1.5, -1.5), ref); + extra_edges = rotate_90(extra_edges); + extra_edges2 = rotate_90(extra_edges2); + diag_dir(extra_edges, extra_edges2, line_start, line_end); + line_start = rotate_90(line_start); + line_end = rotate_90(line_end); + break; + case DIAG_XNEG_YNEG: + extra_edges = gather_edges(uvs - ofs.xy * vec2(1.5, -1.5), ref); + extra_edges2 = gather_edges(uvs + ofs.xy * vec2(1.5, -1.5), ref); + extra_edges = rotate_270(extra_edges); + extra_edges2 = rotate_270(extra_edges2); + diag_dir(extra_edges, extra_edges2, line_start, line_end); + line_start = rotate_270(line_start); + line_end = rotate_270(line_end); + break; + + /* Apex */ + case APEX_XPOS: + case APEX_XNEG: + line_start = vec2(-0.5, 0.0); + line_end = vec2(0.5, 0.0); + break; + case APEX_YPOS: + case APEX_YNEG: + line_start = vec2(0.0, -0.5); + line_end = vec2(0.0, 0.5); + break; + default: + /* Ensure values are assigned to, avoids undefined behavior for + * divergent control-flow. This can occur if discard is called + * as discard is not treated as a return in Metal 2.2. So + * side-effects can still cause problems. */ + line_start = vec2(0.0); + line_end = vec2(0.0); + break; + } + + lineOutput = pack_line_data(vec2(0.0), line_start, line_end); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_frag.glsl new file mode 100644 index 00000000000..d1abd74a7b3 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_frag.glsl @@ -0,0 +1,5 @@ + +void main() +{ + out_object_id = interp.ob_id; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_geom.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_geom.glsl new file mode 100644 index 00000000000..8a196620af9 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_geom.glsl @@ -0,0 +1,47 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void vert_from_gl_in(int v) +{ + gl_Position = gl_in[v].gl_Position; + interp_out.ob_id = interp_in[v].ob_id; + view_clipping_distances_set(gl_in[v]); +} + +void main() +{ + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + + vec3 view_vec = (is_persp) ? normalize(vert[1].pos) : vec3(0.0, 0.0, -1.0); + + vec3 v10 = vert[0].pos - vert[1].pos; + vec3 v12 = vert[2].pos - vert[1].pos; + vec3 v13 = vert[3].pos - vert[1].pos; + + vec3 n0 = cross(v12, v10); + vec3 n3 = cross(v13, v12); + + float fac0 = dot(view_vec, n0); + float fac3 = dot(view_vec, n3); + + /* If both adjacent verts are facing the camera the same way, + * then it isn't an outline edge. */ + if (sign(fac0) == sign(fac3)) { + return; + } + + /* Don't outline if concave edge. */ + /* That would hide a lot of non useful edge but it flickers badly. + * TODO: revisit later... */ + // if (dot(n0, v13) > 0.01) + // return; + + vert_from_gl_in(1); + EmitVertex(); + + vert_from_gl_in(2); + EmitVertex(); + + EndPrimitive(); +} 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 new file mode 100644 index 00000000000..b6d5cd96c12 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_frag.glsl @@ -0,0 +1,42 @@ + +#pragma BLENDER_REQUIRE(common_gpencil_lib.glsl) + +vec3 ray_plane_intersection(vec3 ray_ori, vec3 ray_dir, vec4 plane) +{ + float d = dot(plane.xyz, ray_dir); + vec3 plane_co = plane.xyz * (-plane.w / dot(plane.xyz, plane.xyz)); + vec3 h = ray_ori - plane_co; + float lambda = -dot(plane.xyz, h) / ((abs(d) < 1e-8) ? 1e-8 : d); + return ray_ori + ray_dir * lambda; +} + +void main() +{ + if (gpencil_stroke_round_cap_mask(gp_interp.sspos.xy, + gp_interp.sspos.zw, + gp_interp.aspect, + gp_interp.thickness.x, + gp_interp.hardness) < 0.001) { + discard; + } + + if (!gpStrokeOrder3d) { + /* Stroke order 2D. Project to gpDepthPlane. */ + bool is_persp = ProjectionMatrix[3][3] == 0.0; + vec2 uvs = vec2(gl_FragCoord.xy) * drw_view.viewport_size_inverse; + vec3 pos_ndc = vec3(uvs, gl_FragCoord.z) * 2.0 - 1.0; + vec4 pos_world = ViewProjectionMatrixInverse * vec4(pos_ndc, 1.0); + vec3 pos = pos_world.xyz / pos_world.w; + + vec3 ray_ori = pos; + vec3 ray_dir = (is_persp) ? (ViewMatrixInverse[3].xyz - pos) : ViewMatrixInverse[2].xyz; + vec3 isect = ray_plane_intersection(ray_ori, ray_dir, gpDepthPlane); + vec4 ndc = point_world_to_ndc(isect); + gl_FragDepth = (ndc.z / ndc.w) * 0.5 + 0.5; + } + else { + gl_FragDepth = gl_FragCoord.z; + } + + out_object_id = interp.ob_id; +} 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 new file mode 100644 index 00000000000..4b1470e5723 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_gpencil_vert.glsl @@ -0,0 +1,74 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) +#pragma BLENDER_REQUIRE(common_gpencil_lib.glsl) + +uint outline_colorid_get(void) +{ + int flag = int(abs(ObjectInfo.w)); + bool is_active = (flag & DRW_BASE_ACTIVE) != 0; + + if (isTransform) { + return 0u; /* colorTransform */ + } + else if (is_active) { + return 3u; /* colorActive */ + } + else { + return 1u; /* colorSelect */ + } + + return 0u; +} + +/* Replace top 2 bits (of the 16bit output) by outlineId. + * This leaves 16K different IDs to create outlines between objects. + * SHIFT = (32 - (16 - 2)) */ +#define SHIFT 18u + +void main() +{ + vec3 world_pos; + vec3 unused_N; + vec4 unused_color; + 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), + world_pos, + unused_N, + unused_color, + unused_strength, + unused_uv, + gp_interp.sspos, + gp_interp.aspect, + gp_interp.thickness, + gp_interp.hardness); + + /* Small bias to always be on top of the geom. */ + gl_Position.z -= 1e-3; + + /* ID 0 is nothing (background) */ + interp.ob_id = uint(resource_handle + 1); + + /* Should be 2 bits only [0..3]. */ + uint outline_id = outline_colorid_get(); + + /* Combine for 16bit uint target. */ + interp.ob_id = (outline_id << 14u) | ((interp.ob_id << SHIFT) >> SHIFT); + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_pointcloud_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_pointcloud_vert.glsl new file mode 100644 index 00000000000..371ff628c59 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_pointcloud_vert.glsl @@ -0,0 +1,48 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) +#pragma BLENDER_REQUIRE(common_pointcloud_lib.glsl) + +uint outline_colorid_get(void) +{ + int flag = int(abs(ObjectInfo.w)); + bool is_active = (flag & DRW_BASE_ACTIVE) != 0; + + if (isTransform) { + return 0u; /* colorTransform */ + } + else if (is_active) { + return 3u; /* colorActive */ + } + else { + return 1u; /* colorSelect */ + } + + return 0u; +} + +/* Replace top 2 bits (of the 16bit output) by outlineId. + * This leaves 16K different IDs to create outlines between objects. + * SHIFT = (32 - (16 - 2)) */ +#define SHIFT 18u + +void main() +{ + vec3 world_pos = pointcloud_get_pos(); + + gl_Position = point_world_to_ndc(world_pos); + + /* Small bias to always be on top of the geom. */ + gl_Position.z -= 1e-3; + + /* ID 0 is nothing (background) */ + interp.ob_id = uint(resource_handle + 1); + + /* Should be 2 bits only [0..3]. */ + uint outline_id = outline_colorid_get(); + + /* Combine for 16bit uint target. */ + interp.ob_id = (outline_id << 14u) | ((interp.ob_id << SHIFT) >> SHIFT); + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_vert.glsl new file mode 100644 index 00000000000..1d0b08f51b2 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_outline_prepass_vert.glsl @@ -0,0 +1,50 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +uint outline_colorid_get(void) +{ + int flag = int(abs(ObjectInfo.w)); + bool is_active = (flag & DRW_BASE_ACTIVE) != 0; + + if (isTransform) { + return 0u; /* colorTransform */ + } + else if (is_active) { + return 3u; /* colorActive */ + } + else { + return 1u; /* colorSelect */ + } + + return 0u; +} + +/* Replace top 2 bits (of the 16bit output) by outlineId. + * This leaves 16K different IDs to create outlines between objects. + * SHIFT = (32 - (16 - 2)) */ +#define SHIFT 18u + +void main() +{ + vec3 world_pos = point_object_to_world(pos); + + gl_Position = point_world_to_ndc(world_pos); +#ifdef USE_GEOM + vert.pos = point_world_to_view(world_pos); +#endif + + /* Small bias to always be on top of the geom. */ + gl_Position.z -= 1e-3; + + /* ID 0 is nothing (background) */ + interp.ob_id = uint(resource_handle + 1); + + /* Should be 2 bits only [0..3]. */ + uint outline_id = outline_colorid_get(); + + /* Combine for 16bit uint target. */ + interp.ob_id = (outline_id << 14u) | ((interp.ob_id << SHIFT) >> SHIFT); + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_face_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_face_vert.glsl new file mode 100644 index 00000000000..22906bf1526 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_face_vert.glsl @@ -0,0 +1,21 @@ +#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); + + bool is_select = (nor.w > 0.0); + bool is_hidden = (nor.w < 0.0); + + /* Don't draw faces that are selected. */ + if (is_hidden || is_select) { + gl_Position = vec4(-2.0, -2.0, -2.0, 1.0); + } + else { + view_clipping_distances(world_pos); + } +} 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 new file mode 100644 index 00000000000..8736b2a87db --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_point_vert.glsl @@ -0,0 +1,27 @@ +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + bool is_select = (nor.w > 0.0); + bool is_hidden = (nor.w < 0.0); + + 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. */ + gl_Position.z -= (is_select ? 2e-4 : 1e-4); + + if (is_hidden) { + gl_Position = vec4(-2.0, -2.0, -2.0, 1.0); + } + + finalColor = (is_select) ? vec4(1.0) : colorWire; + finalColor.a = nor.w; + + gl_PointSize = sizeVertex * 2.0; + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_texture_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_texture_frag.glsl new file mode 100644 index 00000000000..e5af0e7bd88 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_texture_frag.glsl @@ -0,0 +1,14 @@ +#pragma BLENDER_REQUIRE(common_colormanagement_lib.glsl) + +void main() +{ + vec4 mask = vec4(texture_read_as_srgb(maskImage, maskImagePremultiplied, uv_interp).rgb, 1.0); + if (maskInvertStencil) { + mask.rgb = 1.0 - mask.rgb; + } + float mask_step = smoothstep(0.0, 3.0, mask.r + mask.g + mask.b); + mask.rgb *= maskColor; + mask.a = mask_step * opacity; + + fragColor = mask; +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_texture_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_texture_vert.glsl new file mode 100644 index 00000000000..f93d0050950 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_texture_vert.glsl @@ -0,0 +1,14 @@ +#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); + + uv_interp = mu; + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_vertcol_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_vertcol_frag.glsl new file mode 100644 index 00000000000..193fabc65cb --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_vertcol_frag.glsl @@ -0,0 +1,20 @@ +vec3 linear_to_srgb_attr(vec3 c) +{ + c = max(c, vec3(0.0)); + vec3 c1 = c * 12.92; + vec3 c2 = 1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055; + return mix(c1, c2, step(vec3(0.0031308), c)); +} + +void main() +{ + vec3 color = linear_to_srgb_attr(finalColor); + + if (useAlphaBlend) { + fragColor = vec4(color, opacity); + } + else { + /* mix with 1.0 -> is like opacity when using multiply blend mode */ + fragColor = vec4(mix(vec3(1.0), color, opacity), 1.0); + } +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_vertcol_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_vertcol_vert.glsl new file mode 100644 index 00000000000..650070dcfd5 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_vertcol_vert.glsl @@ -0,0 +1,22 @@ +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +vec3 srgb_to_linear_attr(vec3 c) +{ + c = max(c, vec3(0.0)); + vec3 c1 = c * (1.0 / 12.92); + vec3 c2 = pow((c + 0.055) * (1.0 / 1.055), vec3(2.4)); + return mix(c1, c2, step(vec3(0.04045), c)); +} + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); + + finalColor = srgb_to_linear_attr(ac); + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_weight_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_weight_frag.glsl new file mode 100644 index 00000000000..1befe7506c4 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_weight_frag.glsl @@ -0,0 +1,98 @@ +float contours(float value, float steps, float width_px, float max_rel_width, float gradient) +{ + /* Minimum visible and minimum full strength line width in screen space for fade out. */ + const float min_width_px = 1.3, fade_width_px = 2.3; + /* Line is thinner towards the increase in the weight gradient by this factor. */ + const float hi_bias = 2.0; + + /* Don't draw lines at 0 or 1. */ + float rel_value = value * steps; + + if (rel_value < 0.5 || rel_value > steps - 0.5) { + return 0.0; + } + + /* Check if completely invisible due to fade out. */ + float rel_gradient = gradient * steps; + float rel_min_width = min_width_px * rel_gradient; + + if (max_rel_width <= rel_min_width) { + return 0.0; + } + + /* Main shape of the line, accounting for width bias and maximum weight space width. */ + float rel_width = width_px * rel_gradient; + + float offset = fract(rel_value + 0.5) - 0.5; + + float base_alpha = 1.0 - max(offset * hi_bias, -offset) / min(max_rel_width, rel_width); + + /* Line fadeout when too thin in screen space. */ + float rel_fade_width = fade_width_px * rel_gradient; + + float fade_alpha = (max_rel_width - rel_min_width) / (rel_fade_width - rel_min_width); + + return clamp(base_alpha, 0.0, 1.0) * clamp(fade_alpha, 0.0, 1.0); +} + +vec4 contour_grid(float weight, float weight_gradient) +{ + /* Fade away when the gradient is too low to avoid big fills and noise. */ + float flt_eps = max(1e-8, 1e-6 * weight); + + if (weight_gradient <= flt_eps) { + return vec4(0.0); + } + + /* Three levels of grid lines */ + float grid10 = contours(weight, 10.0, 5.0, 0.3, weight_gradient); + float grid100 = contours(weight, 100.0, 3.5, 0.35, weight_gradient) * 0.6; + float grid1000 = contours(weight, 1000.0, 2.5, 0.4, weight_gradient) * 0.25; + + /* White lines for 0.1 and 0.01, and black for 0.001 */ + vec4 grid = vec4(1.0) * max(grid10, grid100); + + grid.a = max(grid.a, grid1000); + + return grid * clamp((weight_gradient - flt_eps) / flt_eps, 0.0, 1.0); +} + +vec4 apply_color_fac(vec4 color_in) +{ + vec4 color = color_in; + color.rgb = max(vec3(0.005), color_in.rgb) * color_fac; + return color; +} + +void main() +{ + float alert = weight_interp.y; + vec4 color; + + /* Missing vertex group alert color. Uniform in practice. */ + if (alert > 1.1) { + color = apply_color_fac(colorVertexMissingData); + } + /* Weights are available */ + else { + float weight = weight_interp.x; + vec4 weight_color = texture(colorramp, weight, 0); + weight_color = apply_color_fac(weight_color); + + /* Contour display */ + if (drawContours) { + /* This must be executed uniformly for all fragments */ + float weight_gradient = length(vec2(dFdx(weight), dFdy(weight))); + + vec4 grid = contour_grid(weight, weight_gradient); + + weight_color = grid + weight_color * (1 - grid.a); + } + + /* Zero weight alert color. Nonlinear blend to reduce impact. */ + vec4 color_unreferenced = apply_color_fac(colorVertexUnreferenced); + color = mix(weight_color, color_unreferenced, alert * alert); + } + + fragColor = vec4(color.rgb, opacity); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_paint_weight_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_paint_weight_vert.glsl new file mode 100644 index 00000000000..cff79d606d6 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_weight_vert.glsl @@ -0,0 +1,25 @@ +#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); + + /* Separate actual weight and alerts for independent interpolation */ + weight_interp = max(vec2(weight, -weight), 0.0); + + /* Saturate the weight to give a hint of the geometry behind the weights. */ +#ifdef FAKE_SHADING + vec3 view_normal = normalize(normal_object_to_view(nor)); + color_fac = abs(dot(view_normal, light_dir)); + color_fac = color_fac * 0.9 + 0.1; + +#else + color_fac = 1.0; +#endif + + view_clipping_distances(world_pos); +} 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 new file mode 100644 index 00000000000..749cc92f082 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_paint_wire_vert.glsl @@ -0,0 +1,31 @@ +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + GPU_INTEL_VERTEX_SHADER_WORKAROUND + + bool is_select = (nor.w > 0.0) && useSelect; + bool is_hidden = (nor.w < 0.0) && useSelect; + + 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. */ + gl_Position.z -= (is_select ? 2e-4 : 1e-4); + + if (is_hidden) { + gl_Position = vec4(-2.0, -2.0, -2.0, 1.0); + } + + const vec4 colSel = vec4(1.0); + + finalColor = (is_select) ? colSel : colorWire; + + /* Weight paint needs a light color to contrasts with dark weights. */ + if (!useSelect) { + finalColor = vec4(1.0, 1.0, 1.0, 0.3); + } + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_particle_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_particle_frag.glsl new file mode 100644 index 00000000000..a2bcca7b820 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_particle_frag.glsl @@ -0,0 +1,23 @@ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + vec2 uv = gl_PointCoord - vec2(0.5); + float dist = length(uv); + + if (dist > 0.5) { + discard; + } + /* Nice sphere falloff. */ + float intensity = sqrt(1.0 - dist * 2.0) * 0.5 + 0.5; + fragColor = finalColor * vec4(intensity, intensity, intensity, 1.0); + + /* The default value of GL_POINT_SPRITE_COORD_ORIGIN is GL_UPPER_LEFT. Need to reverse the Y. */ + uv.y = -uv.y; + /* Subtract distance to outer edge of the circle. (0.75 is manually tweaked to look better) */ + vec2 edge_pos = gl_FragCoord.xy - uv * (0.75 / (dist + 1e-9)); + vec2 edge_start = edge_pos + vec2(-uv.y, uv.x); + + lineOutput = pack_line_data(gl_FragCoord.xy, edge_start, edge_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl new file mode 100644 index 00000000000..fb981a8167a --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_particle_vert.glsl @@ -0,0 +1,53 @@ + +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +/* TODO(fclem): Share with C code. */ +#define VCLASS_SCREENALIGNED (1 << 9) + +#define VCLASS_EMPTY_AXES (1 << 11) + +vec3 rotate(vec3 vec, vec4 quat) +{ + /* The quaternion representation here stores the w component in the first index. */ + return vec + 2.0 * cross(quat.yzw, cross(quat.yzw, vec) + quat.x * vec); +} + +void main() +{ + /* Drawsize packed in alpha. */ + float draw_size = color.a; + + vec3 world_pos = part_pos; + +#ifdef USE_DOTS + gl_Position = point_world_to_ndc(world_pos); + /* World sized points. */ + gl_PointSize = sizePixel * draw_size * ProjectionMatrix[1][1] * sizeViewport.y / gl_Position.w; +#else + + if ((vclass & VCLASS_SCREENALIGNED) != 0) { + /* World sized, camera facing geometry. */ + world_pos += (screenVecs[0].xyz * pos.x + screenVecs[1].xyz * pos.y) * draw_size; + } + else { + world_pos += rotate(pos, part_rot) * draw_size; + } + + gl_Position = point_world_to_ndc(world_pos); +#endif + + /* Coloring */ + if ((vclass & VCLASS_EMPTY_AXES) != 0) { + /* See VBO construction for explanation. */ + finalColor = vec4(clamp(pos * 10000.0, 0.0, 1.0), 1.0); + } + else if (part_val < 0.0) { + finalColor = vec4(color.rgb, 1.0); + } + else { + finalColor = vec4(texture(weightTex, part_val).rgb, 1.0); + } + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_frag.glsl new file mode 100644 index 00000000000..9650af755c5 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_frag.glsl @@ -0,0 +1,5 @@ + +void main() +{ + fragColor = vec4(faceset_color * vec3(mask_color), 1.0); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_vert.glsl new file mode 100644 index 00000000000..36c0e6a0acf --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_sculpt_mask_vert.glsl @@ -0,0 +1,13 @@ +#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); + + faceset_color = mix(vec3(1.0), fset, faceSetsOpacity); + mask_color = 1.0 - (msk * maskOpacity); + + view_clipping_distances(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_volume_gridlines_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_volume_gridlines_vert.glsl new file mode 100644 index 00000000000..11a04dddd2a --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_volume_gridlines_vert.glsl @@ -0,0 +1,98 @@ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +/* Corners for cell outlines. 0.45 is arbitrary. Any value below 0.5 can be used to avoid + * overlapping of the outlines. */ +const vec3 corners[4] = vec3[4](vec3(-0.45, 0.45, 0.0), + vec3(0.45, 0.45, 0.0), + vec3(0.45, -0.45, 0.0), + vec3(-0.45, -0.45, 0.0)); + +const int indices[8] = int[8](0, 1, 1, 2, 2, 3, 3, 0); + +vec4 flag_to_color(uint flag) +{ + /* Color mapping for flags */ + vec4 color = vec4(0.0, 0.0, 0.0, 1.0); + /* Cell types: 1 is Fluid, 2 is Obstacle, 4 is Empty, 8 is Inflow, 16 is Outflow */ + if (bool(flag & uint(1))) { + color.rgb += vec3(0.0, 0.0, 0.75); /* blue */ + } + if (bool(flag & uint(2))) { + color.rgb += vec3(0.4, 0.4, 0.4); /* gray */ + } + if (bool(flag & uint(4))) { + color.rgb += vec3(0.25, 0.0, 0.2); /* dark purple */ + } + if (bool(flag & uint(8))) { + color.rgb += vec3(0.0, 0.5, 0.0); /* dark green */ + } + if (bool(flag & uint(16))) { + color.rgb += vec3(0.9, 0.3, 0.0); /* orange */ + } + if (is_zero(color.rgb)) { + color.rgb += vec3(0.5, 0.0, 0.0); /* medium red */ + } + return color; +} + +void main() +{ + int cell = gl_VertexID / 8; + mat3 rot_mat = mat3(0.0); + + vec3 cell_offset = vec3(0.5); + ivec3 cell_div = volumeSize; + if (sliceAxis == 0) { + cell_offset.x = slicePosition * float(volumeSize.x); + cell_div.x = 1; + rot_mat[2].x = 1.0; + rot_mat[0].y = 1.0; + rot_mat[1].z = 1.0; + } + else if (sliceAxis == 1) { + cell_offset.y = slicePosition * float(volumeSize.y); + cell_div.y = 1; + rot_mat[1].x = 1.0; + rot_mat[2].y = 1.0; + rot_mat[0].z = 1.0; + } + else if (sliceAxis == 2) { + cell_offset.z = slicePosition * float(volumeSize.z); + cell_div.z = 1; + rot_mat[0].x = 1.0; + rot_mat[1].y = 1.0; + rot_mat[2].z = 1.0; + } + + ivec3 cell_co; + cell_co.x = cell % cell_div.x; + cell_co.y = (cell / cell_div.x) % cell_div.y; + cell_co.z = cell / (cell_div.x * cell_div.y); + + finalColor = vec4(0.0, 0.0, 0.0, 1.0); + +#if defined(SHOW_FLAGS) || defined(SHOW_RANGE) + uint flag = texelFetch(flagTexture, cell_co + ivec3(cell_offset), 0).r; +#endif + +#ifdef SHOW_FLAGS + finalColor = flag_to_color(flag); +#endif + +#ifdef SHOW_RANGE + float value = texelFetch(fieldTexture, cell_co + ivec3(cell_offset), 0).r; + if (value >= lowerBound && value <= upperBound) { + if (cellFilter == 0 || bool(uint(cellFilter) & flag)) { + finalColor = rangeColor; + } + } +#endif + + vec3 pos = domainOriginOffset + cellSize * (vec3(cell_co + adaptiveCellOffset) + cell_offset); + vec3 rotated_pos = rot_mat * corners[indices[gl_VertexID % 8]]; + pos += rotated_pos * cellSize; + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_volume_velocity_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_volume_velocity_vert.glsl new file mode 100644 index 00000000000..a33d27676c3 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_volume_velocity_vert.glsl @@ -0,0 +1,191 @@ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +const vec3 corners[4] = vec3[4](vec3(0.0, 0.2, -0.5), + vec3(-0.2 * 0.866, -0.2 * 0.5, -0.5), + vec3(0.2 * 0.866, -0.2 * 0.5, -0.5), + vec3(0.0, 0.0, 0.5)); + +const int indices[12] = int[12](0, 1, 1, 2, 2, 0, 0, 3, 1, 3, 2, 3); + +/* Straight Port from BKE_defvert_weight_to_rgb() + * TODO: port this to a color ramp. */ +vec3 weight_to_color(float weight) +{ + vec3 r_rgb = vec3(0.0); + float blend = ((weight / 2.0) + 0.5); + + if (weight <= 0.25) { /* blue->cyan */ + r_rgb.g = blend * weight * 4.0; + r_rgb.b = blend; + } + else if (weight <= 0.50) { /* cyan->green */ + r_rgb.g = blend; + r_rgb.b = blend * (1.0 - ((weight - 0.25) * 4.0)); + } + else if (weight <= 0.75) { /* green->yellow */ + r_rgb.r = blend * ((weight - 0.50) * 4.0); + r_rgb.g = blend; + } + else if (weight <= 1.0) { /* yellow->red */ + r_rgb.r = blend; + r_rgb.g = blend * (1.0 - ((weight - 0.75) * 4.0)); + } + else { + /* exceptional value, unclamped or nan, + * avoid uninitialized memory use */ + r_rgb = vec3(1.0, 0.0, 1.0); + } + + return r_rgb; +} + +mat3 rotation_from_vector(vec3 v) +{ + /* Add epsilon to avoid NaN. */ + vec3 N = normalize(v + 1e-8); + vec3 UpVector = abs(N.z) < 0.99999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0); + vec3 T = normalize(cross(UpVector, N)); + vec3 B = cross(N, T); + return mat3(T, B, N); +} + +vec3 get_vector(ivec3 cell_co) +{ + vec3 vector; + + vector.x = texelFetch(velocityX, cell_co, 0).r; + vector.y = texelFetch(velocityY, cell_co, 0).r; + vector.z = texelFetch(velocityZ, cell_co, 0).r; + + return vector; +} + +/* Interpolate MAC information for cell-centered vectors. */ +vec3 get_vector_centered(ivec3 cell_co) +{ + vec3 vector; + + vector.x = 0.5 * (texelFetch(velocityX, cell_co, 0).r + + texelFetch(velocityX, ivec3(cell_co.x + 1, cell_co.yz), 0).r); + vector.y = 0.5 * (texelFetch(velocityY, cell_co, 0).r + + texelFetch(velocityY, ivec3(cell_co.x, cell_co.y + 1, cell_co.z), 0).r); + vector.z = 0.5 * (texelFetch(velocityZ, cell_co, 0).r + + texelFetch(velocityZ, ivec3(cell_co.xy, cell_co.z + 1), 0).r); + + return vector; +} + +/* Interpolate cell-centered information for MAC vectors. */ +vec3 get_vector_mac(ivec3 cell_co) +{ + vec3 vector; + + vector.x = 0.5 * (texelFetch(velocityX, ivec3(cell_co.x - 1, cell_co.yz), 0).r + + texelFetch(velocityX, cell_co, 0).r); + vector.y = 0.5 * (texelFetch(velocityY, ivec3(cell_co.x, cell_co.y - 1, cell_co.z), 0).r + + texelFetch(velocityY, cell_co, 0).r); + vector.z = 0.5 * (texelFetch(velocityZ, ivec3(cell_co.xy, cell_co.z - 1), 0).r + + texelFetch(velocityZ, cell_co, 0).r); + + return vector; +} + +void main() +{ +#ifdef USE_NEEDLE + int cell = gl_VertexID / 12; +#elif defined(USE_MAC) + int cell = gl_VertexID / 6; +#else + int cell = gl_VertexID / 2; +#endif + + ivec3 volume_size = textureSize(velocityX, 0); + + ivec3 cell_ofs = ivec3(0); + ivec3 cell_div = volume_size; + if (sliceAxis == 0) { + cell_ofs.x = int(slicePosition * float(volume_size.x)); + cell_div.x = 1; + } + else if (sliceAxis == 1) { + cell_ofs.y = int(slicePosition * float(volume_size.y)); + cell_div.y = 1; + } + else if (sliceAxis == 2) { + cell_ofs.z = int(slicePosition * float(volume_size.z)); + cell_div.z = 1; + } + + ivec3 cell_co; + cell_co.x = cell % cell_div.x; + cell_co.y = (cell / cell_div.x) % cell_div.y; + cell_co.z = cell / (cell_div.x * cell_div.y); + cell_co += cell_ofs; + + vec3 pos = domainOriginOffset + cellSize * (vec3(cell_co + adaptiveCellOffset) + 0.5); + + vec3 vector; + +#ifdef USE_MAC + vec3 color; + vector = (isCellCentered) ? get_vector_mac(cell_co) : get_vector(cell_co); + + switch (gl_VertexID % 6) { + case 0: /* Tail of X component. */ + pos.x += (drawMACX) ? -0.5 * cellSize.x : 0.0; + color = vec3(1.0, 0.0, 0.0); /* red */ + break; + case 1: /* Head of X component. */ + pos.x += (drawMACX) ? (-0.5 + vector.x * displaySize) * cellSize.x : 0.0; + color = vec3(1.0, 1.0, 0.0); /* yellow */ + break; + case 2: /* Tail of Y component. */ + pos.y += (drawMACY) ? -0.5 * cellSize.y : 0.0; + color = vec3(0.0, 1.0, 0.0); /* green */ + break; + case 3: /* Head of Y component. */ + pos.y += (drawMACY) ? (-0.5 + vector.y * displaySize) * cellSize.y : 0.0; + color = vec3(1.0, 1.0, 0.0); /* yellow */ + break; + case 4: /* Tail of Z component. */ + pos.z += (drawMACZ) ? -0.5 * cellSize.z : 0.0; + color = vec3(0.0, 0.0, 1.0); /* blue */ + break; + case 5: /* Head of Z component. */ + pos.z += (drawMACZ) ? (-0.5 + vector.z * displaySize) * cellSize.z : 0.0; + color = vec3(1.0, 1.0, 0.0); /* yellow */ + break; + } + + finalColor = vec4(color, 1.0); +#else + vector = (isCellCentered) ? get_vector(cell_co) : get_vector_centered(cell_co); + + finalColor = vec4(weight_to_color(length(vector)), 1.0); + + float vector_length = 1.0; + + if (scaleWithMagnitude) { + vector_length = length(vector); + } + else if (length(vector) == 0.0) { + vector_length = 0.0; + } + + mat3 rot_mat = rotation_from_vector(vector); + +# ifdef USE_NEEDLE + vec3 rotated_pos = rot_mat * corners[indices[gl_VertexID % 12]]; + pos += rotated_pos * vector_length * displaySize * cellSize; +# else + vec3 rotated_pos = rot_mat * vec3(0.0, 0.0, 1.0); + pos += ((gl_VertexID % 2) == 1) ? rotated_pos * vector_length * displaySize * cellSize : + vec3(0.0); +# endif +#endif + + vec3 world_pos = point_object_to_world(pos); + gl_Position = point_world_to_ndc(world_pos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_wireframe_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_wireframe_frag.glsl new file mode 100644 index 00000000000..bc28d7a8a36 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_wireframe_frag.glsl @@ -0,0 +1,44 @@ + +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +void main() +{ + /* Needed only because of wireframe slider. + * If we could get rid of it would be nice because of performance drain of discard. */ + if (edgeStart.r == -1.0) { + discard; + } + +#ifndef SELECT_EDGES + lineOutput = pack_line_data(gl_FragCoord.xy, edgeStart, edgePos); + fragColor = finalColor; + +# ifdef CUSTOM_DEPTH_BIAS + 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; + float depth_occluder = texture(depthTex, uv).r; + float depth_min = depth_occluder; + vec2 texel_uv_size = drw_view.viewport_size_inverse; + + if (dir_horiz) { + depth_min = min(depth_min, texture(depthTex, uv + vec2(-texel_uv_size.x, 0.0)).r); + depth_min = min(depth_min, texture(depthTex, uv + vec2(texel_uv_size.x, 0.0)).r); + } + else { + depth_min = min(depth_min, texture(depthTex, uv + vec2(0, -texel_uv_size.y)).r); + depth_min = min(depth_min, texture(depthTex, uv + vec2(0, texel_uv_size.y)).r); + } + + float delta = abs(depth_occluder - depth_min); + + if (gl_FragCoord.z < (depth_occluder + delta) && gl_FragCoord.z > depth_occluder) { + gl_FragDepth = depth_occluder; + } + else { + gl_FragDepth = gl_FragCoord.z; + } +# endif +#endif +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl b/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl new file mode 100644 index 00000000000..41bd7791dd7 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_wireframe_vert.glsl @@ -0,0 +1,144 @@ +#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) +#pragma BLENDER_REQUIRE(common_view_lib.glsl) + +float get_edge_sharpness(float wd) +{ + return ((wd == 0.0) ? -1.5 : wd) + wireStepParam; +} + +void wire_color_get(out vec3 rim_col, out vec3 wire_col) +{ + int flag = int(abs(ObjectInfo.w)); + bool is_selected = (flag & DRW_BASE_SELECTED) != 0; + bool is_from_set = (flag & DRW_BASE_FROM_SET) != 0; + bool is_active = (flag & DRW_BASE_ACTIVE) != 0; + + if (is_from_set) { + rim_col = colorWire.rgb; + wire_col = colorWire.rgb; + } + else if (is_selected && useColoring) { + if (isTransform) { + rim_col = colorTransform.rgb; + } + else if (is_active) { + rim_col = colorActive.rgb; + } + else { + rim_col = colorSelect.rgb; + } + wire_col = colorWire.rgb; + } + else { + rim_col = colorWire.rgb; + wire_col = colorBackground.rgb; + } +} + +vec3 hsv_to_rgb(vec3 hsv) +{ + vec3 nrgb = abs(hsv.x * 6.0 - vec3(3.0, 2.0, 4.0)) * vec3(1, -1, -1) + vec3(-1, 2, 2); + nrgb = clamp(nrgb, 0.0, 1.0); + return ((nrgb - 1.0) * hsv.y + 1.0) * hsv.z; +} + +void wire_object_color_get(out vec3 rim_col, out vec3 wire_col) +{ + int flag = int(abs(ObjectInfo.w)); + bool is_selected = (flag & DRW_BASE_SELECTED) != 0; + + if (isObjectColor) { + rim_col = wire_col = ObjectColor.rgb * 0.5; + } + else { + float hue = ObjectInfo.z; + vec3 hsv = vec3(hue, 0.75, 0.8); + rim_col = wire_col = hsv_to_rgb(hsv); + } + + if (is_selected && useColoring) { + /* "Normalize" color. */ + wire_col += 1e-4; /* Avoid division by 0. */ + float brightness = max(wire_col.x, max(wire_col.y, wire_col.z)); + wire_col *= 0.5 / brightness; + rim_col += 0.75; + } + else { + rim_col *= 0.5; + wire_col += 0.5; + } +} + +void main() +{ + bool no_attr = all(equal(nor, vec3(0))); + vec3 wnor = no_attr ? ViewMatrixInverse[2].xyz : normalize(normal_object_to_world(nor)); + vec3 wpos = point_object_to_world(pos); + + if (isHair) { + mat4 obmat = hairDupliMatrix; + wpos = (obmat * vec4(pos, 1.0)).xyz; + wnor = -normalize(mat3(obmat) * nor); + } + + bool is_persp = (ProjectionMatrix[3][3] == 0.0); + vec3 V = (is_persp) ? normalize(ViewMatrixInverse[3].xyz - wpos) : ViewMatrixInverse[2].xyz; + + float facing = dot(wnor, V); + + gl_Position = point_world_to_ndc(wpos); + +#ifndef CUSTOM_DEPTH_BIAS + float facing_ratio = clamp(1.0 - facing * facing, 0.0, 1.0); + float flip = sign(facing); /* Flip when not facing the normal (i.e.: backfacing). */ + float curvature = (1.0 - wd * 0.75); /* Avoid making things worse for curvy areas. */ + vec3 wofs = wnor * (facing_ratio * curvature * flip); + 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; + + /* Push the vertex towards the camera. Helps a bit. */ + gl_Position.z -= facing_ratio * curvature * 1.0e-6 * gl_Position.w; +#endif + + /* Convert to screen position [0..sizeVp]. */ + edgeStart = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; + +#ifndef SELECT_EDGES + edgePos = edgeStart; + + vec3 rim_col, wire_col; + if (isObjectColor || isRandomColor) { + wire_object_color_get(rim_col, wire_col); + } + else { + wire_color_get(rim_col, wire_col); + } + + facing = clamp(abs(facing), 0.0, 1.0); + + /* Do interpolation in a non-linear space to have a better visual result. */ + rim_col = pow(rim_col, vec3(1.0 / 2.2)); + wire_col = pow(wire_col, vec3(1.0 / 2.2)); + vec3 final_front_col = mix(rim_col, wire_col, 0.35); + finalColor.rgb = mix(rim_col, final_front_col, facing); + finalColor.rgb = pow(finalColor.rgb, vec3(2.2)); + finalColor.a = wireOpacity; + finalColor.rgb *= wireOpacity; +#endif + + /* Cull flat edges below threshold. */ + if (!no_attr && (get_edge_sharpness(wd) < 0.0)) { + edgeStart = vec2(-1.0); + } + +#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); +#endif + + view_clipping_distances(wpos); +} diff --git a/source/blender/draw/engines/overlay/shaders/overlay_xray_fade_frag.glsl b/source/blender/draw/engines/overlay/shaders/overlay_xray_fade_frag.glsl new file mode 100644 index 00000000000..9aa2fdc3796 --- /dev/null +++ b/source/blender/draw/engines/overlay/shaders/overlay_xray_fade_frag.glsl @@ -0,0 +1,7 @@ + +void main() +{ + float depth = texture(depthTex, uvcoordsvar.xy).r; + float depth_xray = texture(xrayDepthTex, uvcoordsvar.xy).r; + fragColor = vec4((depth < 1.0 && depth > depth_xray) ? opacity : 1.0); +} diff --git a/source/blender/draw/engines/overlay/shaders/paint_face_vert.glsl b/source/blender/draw/engines/overlay/shaders/paint_face_vert.glsl deleted file mode 100644 index 22906bf1526..00000000000 --- a/source/blender/draw/engines/overlay/shaders/paint_face_vert.glsl +++ /dev/null @@ -1,21 +0,0 @@ -#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); - - bool is_select = (nor.w > 0.0); - bool is_hidden = (nor.w < 0.0); - - /* Don't draw faces that are selected. */ - if (is_hidden || is_select) { - gl_Position = vec4(-2.0, -2.0, -2.0, 1.0); - } - else { - view_clipping_distances(world_pos); - } -} diff --git a/source/blender/draw/engines/overlay/shaders/paint_point_vert.glsl b/source/blender/draw/engines/overlay/shaders/paint_point_vert.glsl deleted file mode 100644 index 8736b2a87db..00000000000 --- a/source/blender/draw/engines/overlay/shaders/paint_point_vert.glsl +++ /dev/null @@ -1,27 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - bool is_select = (nor.w > 0.0); - bool is_hidden = (nor.w < 0.0); - - 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. */ - gl_Position.z -= (is_select ? 2e-4 : 1e-4); - - if (is_hidden) { - gl_Position = vec4(-2.0, -2.0, -2.0, 1.0); - } - - finalColor = (is_select) ? vec4(1.0) : colorWire; - finalColor.a = nor.w; - - gl_PointSize = sizeVertex * 2.0; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/paint_texture_frag.glsl b/source/blender/draw/engines/overlay/shaders/paint_texture_frag.glsl deleted file mode 100644 index e5af0e7bd88..00000000000 --- a/source/blender/draw/engines/overlay/shaders/paint_texture_frag.glsl +++ /dev/null @@ -1,14 +0,0 @@ -#pragma BLENDER_REQUIRE(common_colormanagement_lib.glsl) - -void main() -{ - vec4 mask = vec4(texture_read_as_srgb(maskImage, maskImagePremultiplied, uv_interp).rgb, 1.0); - if (maskInvertStencil) { - mask.rgb = 1.0 - mask.rgb; - } - float mask_step = smoothstep(0.0, 3.0, mask.r + mask.g + mask.b); - mask.rgb *= maskColor; - mask.a = mask_step * opacity; - - fragColor = mask; -} diff --git a/source/blender/draw/engines/overlay/shaders/paint_texture_vert.glsl b/source/blender/draw/engines/overlay/shaders/paint_texture_vert.glsl deleted file mode 100644 index f93d0050950..00000000000 --- a/source/blender/draw/engines/overlay/shaders/paint_texture_vert.glsl +++ /dev/null @@ -1,14 +0,0 @@ -#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); - - uv_interp = mu; - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/paint_vertcol_frag.glsl b/source/blender/draw/engines/overlay/shaders/paint_vertcol_frag.glsl deleted file mode 100644 index 193fabc65cb..00000000000 --- a/source/blender/draw/engines/overlay/shaders/paint_vertcol_frag.glsl +++ /dev/null @@ -1,20 +0,0 @@ -vec3 linear_to_srgb_attr(vec3 c) -{ - c = max(c, vec3(0.0)); - vec3 c1 = c * 12.92; - vec3 c2 = 1.055 * pow(c, vec3(1.0 / 2.4)) - 0.055; - return mix(c1, c2, step(vec3(0.0031308), c)); -} - -void main() -{ - vec3 color = linear_to_srgb_attr(finalColor); - - if (useAlphaBlend) { - fragColor = vec4(color, opacity); - } - else { - /* mix with 1.0 -> is like opacity when using multiply blend mode */ - fragColor = vec4(mix(vec3(1.0), color, opacity), 1.0); - } -} diff --git a/source/blender/draw/engines/overlay/shaders/paint_vertcol_vert.glsl b/source/blender/draw/engines/overlay/shaders/paint_vertcol_vert.glsl deleted file mode 100644 index 650070dcfd5..00000000000 --- a/source/blender/draw/engines/overlay/shaders/paint_vertcol_vert.glsl +++ /dev/null @@ -1,22 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -vec3 srgb_to_linear_attr(vec3 c) -{ - c = max(c, vec3(0.0)); - vec3 c1 = c * (1.0 / 12.92); - vec3 c2 = pow((c + 0.055) * (1.0 / 1.055), vec3(2.4)); - return mix(c1, c2, step(vec3(0.04045), c)); -} - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); - - finalColor = srgb_to_linear_attr(ac); - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/paint_weight_frag.glsl b/source/blender/draw/engines/overlay/shaders/paint_weight_frag.glsl deleted file mode 100644 index 1befe7506c4..00000000000 --- a/source/blender/draw/engines/overlay/shaders/paint_weight_frag.glsl +++ /dev/null @@ -1,98 +0,0 @@ -float contours(float value, float steps, float width_px, float max_rel_width, float gradient) -{ - /* Minimum visible and minimum full strength line width in screen space for fade out. */ - const float min_width_px = 1.3, fade_width_px = 2.3; - /* Line is thinner towards the increase in the weight gradient by this factor. */ - const float hi_bias = 2.0; - - /* Don't draw lines at 0 or 1. */ - float rel_value = value * steps; - - if (rel_value < 0.5 || rel_value > steps - 0.5) { - return 0.0; - } - - /* Check if completely invisible due to fade out. */ - float rel_gradient = gradient * steps; - float rel_min_width = min_width_px * rel_gradient; - - if (max_rel_width <= rel_min_width) { - return 0.0; - } - - /* Main shape of the line, accounting for width bias and maximum weight space width. */ - float rel_width = width_px * rel_gradient; - - float offset = fract(rel_value + 0.5) - 0.5; - - float base_alpha = 1.0 - max(offset * hi_bias, -offset) / min(max_rel_width, rel_width); - - /* Line fadeout when too thin in screen space. */ - float rel_fade_width = fade_width_px * rel_gradient; - - float fade_alpha = (max_rel_width - rel_min_width) / (rel_fade_width - rel_min_width); - - return clamp(base_alpha, 0.0, 1.0) * clamp(fade_alpha, 0.0, 1.0); -} - -vec4 contour_grid(float weight, float weight_gradient) -{ - /* Fade away when the gradient is too low to avoid big fills and noise. */ - float flt_eps = max(1e-8, 1e-6 * weight); - - if (weight_gradient <= flt_eps) { - return vec4(0.0); - } - - /* Three levels of grid lines */ - float grid10 = contours(weight, 10.0, 5.0, 0.3, weight_gradient); - float grid100 = contours(weight, 100.0, 3.5, 0.35, weight_gradient) * 0.6; - float grid1000 = contours(weight, 1000.0, 2.5, 0.4, weight_gradient) * 0.25; - - /* White lines for 0.1 and 0.01, and black for 0.001 */ - vec4 grid = vec4(1.0) * max(grid10, grid100); - - grid.a = max(grid.a, grid1000); - - return grid * clamp((weight_gradient - flt_eps) / flt_eps, 0.0, 1.0); -} - -vec4 apply_color_fac(vec4 color_in) -{ - vec4 color = color_in; - color.rgb = max(vec3(0.005), color_in.rgb) * color_fac; - return color; -} - -void main() -{ - float alert = weight_interp.y; - vec4 color; - - /* Missing vertex group alert color. Uniform in practice. */ - if (alert > 1.1) { - color = apply_color_fac(colorVertexMissingData); - } - /* Weights are available */ - else { - float weight = weight_interp.x; - vec4 weight_color = texture(colorramp, weight, 0); - weight_color = apply_color_fac(weight_color); - - /* Contour display */ - if (drawContours) { - /* This must be executed uniformly for all fragments */ - float weight_gradient = length(vec2(dFdx(weight), dFdy(weight))); - - vec4 grid = contour_grid(weight, weight_gradient); - - weight_color = grid + weight_color * (1 - grid.a); - } - - /* Zero weight alert color. Nonlinear blend to reduce impact. */ - vec4 color_unreferenced = apply_color_fac(colorVertexUnreferenced); - color = mix(weight_color, color_unreferenced, alert * alert); - } - - fragColor = vec4(color.rgb, opacity); -} diff --git a/source/blender/draw/engines/overlay/shaders/paint_weight_vert.glsl b/source/blender/draw/engines/overlay/shaders/paint_weight_vert.glsl deleted file mode 100644 index cff79d606d6..00000000000 --- a/source/blender/draw/engines/overlay/shaders/paint_weight_vert.glsl +++ /dev/null @@ -1,25 +0,0 @@ -#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); - - /* Separate actual weight and alerts for independent interpolation */ - weight_interp = max(vec2(weight, -weight), 0.0); - - /* Saturate the weight to give a hint of the geometry behind the weights. */ -#ifdef FAKE_SHADING - vec3 view_normal = normalize(normal_object_to_view(nor)); - color_fac = abs(dot(view_normal, light_dir)); - color_fac = color_fac * 0.9 + 0.1; - -#else - color_fac = 1.0; -#endif - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/paint_wire_vert.glsl b/source/blender/draw/engines/overlay/shaders/paint_wire_vert.glsl deleted file mode 100644 index 749cc92f082..00000000000 --- a/source/blender/draw/engines/overlay/shaders/paint_wire_vert.glsl +++ /dev/null @@ -1,31 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - GPU_INTEL_VERTEX_SHADER_WORKAROUND - - bool is_select = (nor.w > 0.0) && useSelect; - bool is_hidden = (nor.w < 0.0) && useSelect; - - 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. */ - gl_Position.z -= (is_select ? 2e-4 : 1e-4); - - if (is_hidden) { - gl_Position = vec4(-2.0, -2.0, -2.0, 1.0); - } - - const vec4 colSel = vec4(1.0); - - finalColor = (is_select) ? colSel : colorWire; - - /* Weight paint needs a light color to contrasts with dark weights. */ - if (!useSelect) { - finalColor = vec4(1.0, 1.0, 1.0, 0.3); - } - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/particle_frag.glsl b/source/blender/draw/engines/overlay/shaders/particle_frag.glsl deleted file mode 100644 index a2bcca7b820..00000000000 --- a/source/blender/draw/engines/overlay/shaders/particle_frag.glsl +++ /dev/null @@ -1,23 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - vec2 uv = gl_PointCoord - vec2(0.5); - float dist = length(uv); - - if (dist > 0.5) { - discard; - } - /* Nice sphere falloff. */ - float intensity = sqrt(1.0 - dist * 2.0) * 0.5 + 0.5; - fragColor = finalColor * vec4(intensity, intensity, intensity, 1.0); - - /* The default value of GL_POINT_SPRITE_COORD_ORIGIN is GL_UPPER_LEFT. Need to reverse the Y. */ - uv.y = -uv.y; - /* Subtract distance to outer edge of the circle. (0.75 is manually tweaked to look better) */ - vec2 edge_pos = gl_FragCoord.xy - uv * (0.75 / (dist + 1e-9)); - vec2 edge_start = edge_pos + vec2(-uv.y, uv.x); - - lineOutput = pack_line_data(gl_FragCoord.xy, edge_start, edge_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/particle_vert.glsl b/source/blender/draw/engines/overlay/shaders/particle_vert.glsl deleted file mode 100644 index fb981a8167a..00000000000 --- a/source/blender/draw/engines/overlay/shaders/particle_vert.glsl +++ /dev/null @@ -1,53 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -/* TODO(fclem): Share with C code. */ -#define VCLASS_SCREENALIGNED (1 << 9) - -#define VCLASS_EMPTY_AXES (1 << 11) - -vec3 rotate(vec3 vec, vec4 quat) -{ - /* The quaternion representation here stores the w component in the first index. */ - return vec + 2.0 * cross(quat.yzw, cross(quat.yzw, vec) + quat.x * vec); -} - -void main() -{ - /* Drawsize packed in alpha. */ - float draw_size = color.a; - - vec3 world_pos = part_pos; - -#ifdef USE_DOTS - gl_Position = point_world_to_ndc(world_pos); - /* World sized points. */ - gl_PointSize = sizePixel * draw_size * ProjectionMatrix[1][1] * sizeViewport.y / gl_Position.w; -#else - - if ((vclass & VCLASS_SCREENALIGNED) != 0) { - /* World sized, camera facing geometry. */ - world_pos += (screenVecs[0].xyz * pos.x + screenVecs[1].xyz * pos.y) * draw_size; - } - else { - world_pos += rotate(pos, part_rot) * draw_size; - } - - gl_Position = point_world_to_ndc(world_pos); -#endif - - /* Coloring */ - if ((vclass & VCLASS_EMPTY_AXES) != 0) { - /* See VBO construction for explanation. */ - finalColor = vec4(clamp(pos * 10000.0, 0.0, 1.0), 1.0); - } - else if (part_val < 0.0) { - finalColor = vec4(color.rgb, 1.0); - } - else { - finalColor = vec4(texture(weightTex, part_val).rgb, 1.0); - } - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/sculpt_mask_frag.glsl b/source/blender/draw/engines/overlay/shaders/sculpt_mask_frag.glsl deleted file mode 100644 index 9650af755c5..00000000000 --- a/source/blender/draw/engines/overlay/shaders/sculpt_mask_frag.glsl +++ /dev/null @@ -1,5 +0,0 @@ - -void main() -{ - fragColor = vec4(faceset_color * vec3(mask_color), 1.0); -} diff --git a/source/blender/draw/engines/overlay/shaders/sculpt_mask_vert.glsl b/source/blender/draw/engines/overlay/shaders/sculpt_mask_vert.glsl deleted file mode 100644 index 36c0e6a0acf..00000000000 --- a/source/blender/draw/engines/overlay/shaders/sculpt_mask_vert.glsl +++ /dev/null @@ -1,13 +0,0 @@ -#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); - - faceset_color = mix(vec3(1.0), fset, faceSetsOpacity); - mask_color = 1.0 - (msk * maskOpacity); - - view_clipping_distances(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/volume_gridlines_vert.glsl b/source/blender/draw/engines/overlay/shaders/volume_gridlines_vert.glsl deleted file mode 100644 index 11a04dddd2a..00000000000 --- a/source/blender/draw/engines/overlay/shaders/volume_gridlines_vert.glsl +++ /dev/null @@ -1,98 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -/* Corners for cell outlines. 0.45 is arbitrary. Any value below 0.5 can be used to avoid - * overlapping of the outlines. */ -const vec3 corners[4] = vec3[4](vec3(-0.45, 0.45, 0.0), - vec3(0.45, 0.45, 0.0), - vec3(0.45, -0.45, 0.0), - vec3(-0.45, -0.45, 0.0)); - -const int indices[8] = int[8](0, 1, 1, 2, 2, 3, 3, 0); - -vec4 flag_to_color(uint flag) -{ - /* Color mapping for flags */ - vec4 color = vec4(0.0, 0.0, 0.0, 1.0); - /* Cell types: 1 is Fluid, 2 is Obstacle, 4 is Empty, 8 is Inflow, 16 is Outflow */ - if (bool(flag & uint(1))) { - color.rgb += vec3(0.0, 0.0, 0.75); /* blue */ - } - if (bool(flag & uint(2))) { - color.rgb += vec3(0.4, 0.4, 0.4); /* gray */ - } - if (bool(flag & uint(4))) { - color.rgb += vec3(0.25, 0.0, 0.2); /* dark purple */ - } - if (bool(flag & uint(8))) { - color.rgb += vec3(0.0, 0.5, 0.0); /* dark green */ - } - if (bool(flag & uint(16))) { - color.rgb += vec3(0.9, 0.3, 0.0); /* orange */ - } - if (is_zero(color.rgb)) { - color.rgb += vec3(0.5, 0.0, 0.0); /* medium red */ - } - return color; -} - -void main() -{ - int cell = gl_VertexID / 8; - mat3 rot_mat = mat3(0.0); - - vec3 cell_offset = vec3(0.5); - ivec3 cell_div = volumeSize; - if (sliceAxis == 0) { - cell_offset.x = slicePosition * float(volumeSize.x); - cell_div.x = 1; - rot_mat[2].x = 1.0; - rot_mat[0].y = 1.0; - rot_mat[1].z = 1.0; - } - else if (sliceAxis == 1) { - cell_offset.y = slicePosition * float(volumeSize.y); - cell_div.y = 1; - rot_mat[1].x = 1.0; - rot_mat[2].y = 1.0; - rot_mat[0].z = 1.0; - } - else if (sliceAxis == 2) { - cell_offset.z = slicePosition * float(volumeSize.z); - cell_div.z = 1; - rot_mat[0].x = 1.0; - rot_mat[1].y = 1.0; - rot_mat[2].z = 1.0; - } - - ivec3 cell_co; - cell_co.x = cell % cell_div.x; - cell_co.y = (cell / cell_div.x) % cell_div.y; - cell_co.z = cell / (cell_div.x * cell_div.y); - - finalColor = vec4(0.0, 0.0, 0.0, 1.0); - -#if defined(SHOW_FLAGS) || defined(SHOW_RANGE) - uint flag = texelFetch(flagTexture, cell_co + ivec3(cell_offset), 0).r; -#endif - -#ifdef SHOW_FLAGS - finalColor = flag_to_color(flag); -#endif - -#ifdef SHOW_RANGE - float value = texelFetch(fieldTexture, cell_co + ivec3(cell_offset), 0).r; - if (value >= lowerBound && value <= upperBound) { - if (cellFilter == 0 || bool(uint(cellFilter) & flag)) { - finalColor = rangeColor; - } - } -#endif - - vec3 pos = domainOriginOffset + cellSize * (vec3(cell_co + adaptiveCellOffset) + cell_offset); - vec3 rotated_pos = rot_mat * corners[indices[gl_VertexID % 8]]; - pos += rotated_pos * cellSize; - - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/volume_velocity_vert.glsl b/source/blender/draw/engines/overlay/shaders/volume_velocity_vert.glsl deleted file mode 100644 index a33d27676c3..00000000000 --- a/source/blender/draw/engines/overlay/shaders/volume_velocity_vert.glsl +++ /dev/null @@ -1,191 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -const vec3 corners[4] = vec3[4](vec3(0.0, 0.2, -0.5), - vec3(-0.2 * 0.866, -0.2 * 0.5, -0.5), - vec3(0.2 * 0.866, -0.2 * 0.5, -0.5), - vec3(0.0, 0.0, 0.5)); - -const int indices[12] = int[12](0, 1, 1, 2, 2, 0, 0, 3, 1, 3, 2, 3); - -/* Straight Port from BKE_defvert_weight_to_rgb() - * TODO: port this to a color ramp. */ -vec3 weight_to_color(float weight) -{ - vec3 r_rgb = vec3(0.0); - float blend = ((weight / 2.0) + 0.5); - - if (weight <= 0.25) { /* blue->cyan */ - r_rgb.g = blend * weight * 4.0; - r_rgb.b = blend; - } - else if (weight <= 0.50) { /* cyan->green */ - r_rgb.g = blend; - r_rgb.b = blend * (1.0 - ((weight - 0.25) * 4.0)); - } - else if (weight <= 0.75) { /* green->yellow */ - r_rgb.r = blend * ((weight - 0.50) * 4.0); - r_rgb.g = blend; - } - else if (weight <= 1.0) { /* yellow->red */ - r_rgb.r = blend; - r_rgb.g = blend * (1.0 - ((weight - 0.75) * 4.0)); - } - else { - /* exceptional value, unclamped or nan, - * avoid uninitialized memory use */ - r_rgb = vec3(1.0, 0.0, 1.0); - } - - return r_rgb; -} - -mat3 rotation_from_vector(vec3 v) -{ - /* Add epsilon to avoid NaN. */ - vec3 N = normalize(v + 1e-8); - vec3 UpVector = abs(N.z) < 0.99999 ? vec3(0.0, 0.0, 1.0) : vec3(1.0, 0.0, 0.0); - vec3 T = normalize(cross(UpVector, N)); - vec3 B = cross(N, T); - return mat3(T, B, N); -} - -vec3 get_vector(ivec3 cell_co) -{ - vec3 vector; - - vector.x = texelFetch(velocityX, cell_co, 0).r; - vector.y = texelFetch(velocityY, cell_co, 0).r; - vector.z = texelFetch(velocityZ, cell_co, 0).r; - - return vector; -} - -/* Interpolate MAC information for cell-centered vectors. */ -vec3 get_vector_centered(ivec3 cell_co) -{ - vec3 vector; - - vector.x = 0.5 * (texelFetch(velocityX, cell_co, 0).r + - texelFetch(velocityX, ivec3(cell_co.x + 1, cell_co.yz), 0).r); - vector.y = 0.5 * (texelFetch(velocityY, cell_co, 0).r + - texelFetch(velocityY, ivec3(cell_co.x, cell_co.y + 1, cell_co.z), 0).r); - vector.z = 0.5 * (texelFetch(velocityZ, cell_co, 0).r + - texelFetch(velocityZ, ivec3(cell_co.xy, cell_co.z + 1), 0).r); - - return vector; -} - -/* Interpolate cell-centered information for MAC vectors. */ -vec3 get_vector_mac(ivec3 cell_co) -{ - vec3 vector; - - vector.x = 0.5 * (texelFetch(velocityX, ivec3(cell_co.x - 1, cell_co.yz), 0).r + - texelFetch(velocityX, cell_co, 0).r); - vector.y = 0.5 * (texelFetch(velocityY, ivec3(cell_co.x, cell_co.y - 1, cell_co.z), 0).r + - texelFetch(velocityY, cell_co, 0).r); - vector.z = 0.5 * (texelFetch(velocityZ, ivec3(cell_co.xy, cell_co.z - 1), 0).r + - texelFetch(velocityZ, cell_co, 0).r); - - return vector; -} - -void main() -{ -#ifdef USE_NEEDLE - int cell = gl_VertexID / 12; -#elif defined(USE_MAC) - int cell = gl_VertexID / 6; -#else - int cell = gl_VertexID / 2; -#endif - - ivec3 volume_size = textureSize(velocityX, 0); - - ivec3 cell_ofs = ivec3(0); - ivec3 cell_div = volume_size; - if (sliceAxis == 0) { - cell_ofs.x = int(slicePosition * float(volume_size.x)); - cell_div.x = 1; - } - else if (sliceAxis == 1) { - cell_ofs.y = int(slicePosition * float(volume_size.y)); - cell_div.y = 1; - } - else if (sliceAxis == 2) { - cell_ofs.z = int(slicePosition * float(volume_size.z)); - cell_div.z = 1; - } - - ivec3 cell_co; - cell_co.x = cell % cell_div.x; - cell_co.y = (cell / cell_div.x) % cell_div.y; - cell_co.z = cell / (cell_div.x * cell_div.y); - cell_co += cell_ofs; - - vec3 pos = domainOriginOffset + cellSize * (vec3(cell_co + adaptiveCellOffset) + 0.5); - - vec3 vector; - -#ifdef USE_MAC - vec3 color; - vector = (isCellCentered) ? get_vector_mac(cell_co) : get_vector(cell_co); - - switch (gl_VertexID % 6) { - case 0: /* Tail of X component. */ - pos.x += (drawMACX) ? -0.5 * cellSize.x : 0.0; - color = vec3(1.0, 0.0, 0.0); /* red */ - break; - case 1: /* Head of X component. */ - pos.x += (drawMACX) ? (-0.5 + vector.x * displaySize) * cellSize.x : 0.0; - color = vec3(1.0, 1.0, 0.0); /* yellow */ - break; - case 2: /* Tail of Y component. */ - pos.y += (drawMACY) ? -0.5 * cellSize.y : 0.0; - color = vec3(0.0, 1.0, 0.0); /* green */ - break; - case 3: /* Head of Y component. */ - pos.y += (drawMACY) ? (-0.5 + vector.y * displaySize) * cellSize.y : 0.0; - color = vec3(1.0, 1.0, 0.0); /* yellow */ - break; - case 4: /* Tail of Z component. */ - pos.z += (drawMACZ) ? -0.5 * cellSize.z : 0.0; - color = vec3(0.0, 0.0, 1.0); /* blue */ - break; - case 5: /* Head of Z component. */ - pos.z += (drawMACZ) ? (-0.5 + vector.z * displaySize) * cellSize.z : 0.0; - color = vec3(1.0, 1.0, 0.0); /* yellow */ - break; - } - - finalColor = vec4(color, 1.0); -#else - vector = (isCellCentered) ? get_vector(cell_co) : get_vector_centered(cell_co); - - finalColor = vec4(weight_to_color(length(vector)), 1.0); - - float vector_length = 1.0; - - if (scaleWithMagnitude) { - vector_length = length(vector); - } - else if (length(vector) == 0.0) { - vector_length = 0.0; - } - - mat3 rot_mat = rotation_from_vector(vector); - -# ifdef USE_NEEDLE - vec3 rotated_pos = rot_mat * corners[indices[gl_VertexID % 12]]; - pos += rotated_pos * vector_length * displaySize * cellSize; -# else - vec3 rotated_pos = rot_mat * vec3(0.0, 0.0, 1.0); - pos += ((gl_VertexID % 2) == 1) ? rotated_pos * vector_length * displaySize * cellSize : - vec3(0.0); -# endif -#endif - - vec3 world_pos = point_object_to_world(pos); - gl_Position = point_world_to_ndc(world_pos); -} diff --git a/source/blender/draw/engines/overlay/shaders/wireframe_frag.glsl b/source/blender/draw/engines/overlay/shaders/wireframe_frag.glsl deleted file mode 100644 index bc28d7a8a36..00000000000 --- a/source/blender/draw/engines/overlay/shaders/wireframe_frag.glsl +++ /dev/null @@ -1,44 +0,0 @@ - -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -void main() -{ - /* Needed only because of wireframe slider. - * If we could get rid of it would be nice because of performance drain of discard. */ - if (edgeStart.r == -1.0) { - discard; - } - -#ifndef SELECT_EDGES - lineOutput = pack_line_data(gl_FragCoord.xy, edgeStart, edgePos); - fragColor = finalColor; - -# ifdef CUSTOM_DEPTH_BIAS - 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; - float depth_occluder = texture(depthTex, uv).r; - float depth_min = depth_occluder; - vec2 texel_uv_size = drw_view.viewport_size_inverse; - - if (dir_horiz) { - depth_min = min(depth_min, texture(depthTex, uv + vec2(-texel_uv_size.x, 0.0)).r); - depth_min = min(depth_min, texture(depthTex, uv + vec2(texel_uv_size.x, 0.0)).r); - } - else { - depth_min = min(depth_min, texture(depthTex, uv + vec2(0, -texel_uv_size.y)).r); - depth_min = min(depth_min, texture(depthTex, uv + vec2(0, texel_uv_size.y)).r); - } - - float delta = abs(depth_occluder - depth_min); - - if (gl_FragCoord.z < (depth_occluder + delta) && gl_FragCoord.z > depth_occluder) { - gl_FragDepth = depth_occluder; - } - else { - gl_FragDepth = gl_FragCoord.z; - } -# endif -#endif -} diff --git a/source/blender/draw/engines/overlay/shaders/wireframe_vert.glsl b/source/blender/draw/engines/overlay/shaders/wireframe_vert.glsl deleted file mode 100644 index 41bd7791dd7..00000000000 --- a/source/blender/draw/engines/overlay/shaders/wireframe_vert.glsl +++ /dev/null @@ -1,144 +0,0 @@ -#pragma BLENDER_REQUIRE(common_view_clipping_lib.glsl) -#pragma BLENDER_REQUIRE(common_view_lib.glsl) - -float get_edge_sharpness(float wd) -{ - return ((wd == 0.0) ? -1.5 : wd) + wireStepParam; -} - -void wire_color_get(out vec3 rim_col, out vec3 wire_col) -{ - int flag = int(abs(ObjectInfo.w)); - bool is_selected = (flag & DRW_BASE_SELECTED) != 0; - bool is_from_set = (flag & DRW_BASE_FROM_SET) != 0; - bool is_active = (flag & DRW_BASE_ACTIVE) != 0; - - if (is_from_set) { - rim_col = colorWire.rgb; - wire_col = colorWire.rgb; - } - else if (is_selected && useColoring) { - if (isTransform) { - rim_col = colorTransform.rgb; - } - else if (is_active) { - rim_col = colorActive.rgb; - } - else { - rim_col = colorSelect.rgb; - } - wire_col = colorWire.rgb; - } - else { - rim_col = colorWire.rgb; - wire_col = colorBackground.rgb; - } -} - -vec3 hsv_to_rgb(vec3 hsv) -{ - vec3 nrgb = abs(hsv.x * 6.0 - vec3(3.0, 2.0, 4.0)) * vec3(1, -1, -1) + vec3(-1, 2, 2); - nrgb = clamp(nrgb, 0.0, 1.0); - return ((nrgb - 1.0) * hsv.y + 1.0) * hsv.z; -} - -void wire_object_color_get(out vec3 rim_col, out vec3 wire_col) -{ - int flag = int(abs(ObjectInfo.w)); - bool is_selected = (flag & DRW_BASE_SELECTED) != 0; - - if (isObjectColor) { - rim_col = wire_col = ObjectColor.rgb * 0.5; - } - else { - float hue = ObjectInfo.z; - vec3 hsv = vec3(hue, 0.75, 0.8); - rim_col = wire_col = hsv_to_rgb(hsv); - } - - if (is_selected && useColoring) { - /* "Normalize" color. */ - wire_col += 1e-4; /* Avoid division by 0. */ - float brightness = max(wire_col.x, max(wire_col.y, wire_col.z)); - wire_col *= 0.5 / brightness; - rim_col += 0.75; - } - else { - rim_col *= 0.5; - wire_col += 0.5; - } -} - -void main() -{ - bool no_attr = all(equal(nor, vec3(0))); - vec3 wnor = no_attr ? ViewMatrixInverse[2].xyz : normalize(normal_object_to_world(nor)); - vec3 wpos = point_object_to_world(pos); - - if (isHair) { - mat4 obmat = hairDupliMatrix; - wpos = (obmat * vec4(pos, 1.0)).xyz; - wnor = -normalize(mat3(obmat) * nor); - } - - bool is_persp = (ProjectionMatrix[3][3] == 0.0); - vec3 V = (is_persp) ? normalize(ViewMatrixInverse[3].xyz - wpos) : ViewMatrixInverse[2].xyz; - - float facing = dot(wnor, V); - - gl_Position = point_world_to_ndc(wpos); - -#ifndef CUSTOM_DEPTH_BIAS - float facing_ratio = clamp(1.0 - facing * facing, 0.0, 1.0); - float flip = sign(facing); /* Flip when not facing the normal (i.e.: backfacing). */ - float curvature = (1.0 - wd * 0.75); /* Avoid making things worse for curvy areas. */ - vec3 wofs = wnor * (facing_ratio * curvature * flip); - 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; - - /* Push the vertex towards the camera. Helps a bit. */ - gl_Position.z -= facing_ratio * curvature * 1.0e-6 * gl_Position.w; -#endif - - /* Convert to screen position [0..sizeVp]. */ - edgeStart = ((gl_Position.xy / gl_Position.w) * 0.5 + 0.5) * sizeViewport.xy; - -#ifndef SELECT_EDGES - edgePos = edgeStart; - - vec3 rim_col, wire_col; - if (isObjectColor || isRandomColor) { - wire_object_color_get(rim_col, wire_col); - } - else { - wire_color_get(rim_col, wire_col); - } - - facing = clamp(abs(facing), 0.0, 1.0); - - /* Do interpolation in a non-linear space to have a better visual result. */ - rim_col = pow(rim_col, vec3(1.0 / 2.2)); - wire_col = pow(wire_col, vec3(1.0 / 2.2)); - vec3 final_front_col = mix(rim_col, wire_col, 0.35); - finalColor.rgb = mix(rim_col, final_front_col, facing); - finalColor.rgb = pow(finalColor.rgb, vec3(2.2)); - finalColor.a = wireOpacity; - finalColor.rgb *= wireOpacity; -#endif - - /* Cull flat edges below threshold. */ - if (!no_attr && (get_edge_sharpness(wd) < 0.0)) { - edgeStart = vec2(-1.0); - } - -#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); -#endif - - view_clipping_distances(wpos); -} diff --git a/source/blender/draw/engines/overlay/shaders/xray_fade_frag.glsl b/source/blender/draw/engines/overlay/shaders/xray_fade_frag.glsl deleted file mode 100644 index 9aa2fdc3796..00000000000 --- a/source/blender/draw/engines/overlay/shaders/xray_fade_frag.glsl +++ /dev/null @@ -1,7 +0,0 @@ - -void main() -{ - float depth = texture(depthTex, uvcoordsvar.xy).r; - float depth_xray = texture(xrayDepthTex, uvcoordsvar.xy).r; - fragColor = vec4((depth < 1.0 && depth > depth_xray) ? opacity : 1.0); -} -- cgit v1.2.3