From bc8b15f1a532b078fcc4072295c442d140cdbc06 Mon Sep 17 00:00:00 2001 From: Omar Emara Date: Wed, 2 Nov 2022 13:55:23 +0200 Subject: Realtime Compositor: Move shaders to compositor module This patch moves the GLSL shaders and their infos to the compositor module as decided by the EEVEE & Viewport module. This is a non functional change. Differential Revision: https://developer.blender.org/D16360 Reviewed By: Clement Foucault --- .../compositor/realtime_compositor/CMakeLists.txt | 125 +++++++++++++++++ .../shaders/compositor_alpha_crop.glsl | 11 ++ .../shaders/compositor_bilateral_blur.glsl | 31 +++++ .../shaders/compositor_blur.glsl | 66 +++++++++ .../shaders/compositor_blur_variable_size.glsl | 71 ++++++++++ .../shaders/compositor_bokeh_image.glsl | 118 ++++++++++++++++ .../shaders/compositor_box_mask.glsl | 27 ++++ .../shaders/compositor_convert.glsl | 8 ++ .../shaders/compositor_despeckle.glsl | 70 ++++++++++ .../shaders/compositor_directional_blur.glsl | 21 +++ .../shaders/compositor_edge_filter.glsl | 31 +++++ .../shaders/compositor_ellipse_mask.glsl | 27 ++++ .../shaders/compositor_filter.glsl | 20 +++ .../shaders/compositor_flip.glsl | 15 ++ .../shaders/compositor_image_crop.glsl | 7 + .../shaders/compositor_morphological_distance.glsl | 24 ++++ .../compositor_morphological_distance_feather.glsl | 101 ++++++++++++++ ...ompositor_morphological_distance_threshold.glsl | 88 ++++++++++++ .../shaders/compositor_morphological_step.glsl | 19 +++ .../shaders/compositor_normalize.glsl | 10 ++ .../shaders/compositor_parallel_reduction.glsl | 98 +++++++++++++ .../compositor_projector_lens_distortion.glsl | 16 +++ .../shaders/compositor_realize_on_domain.glsl | 29 ++++ .../shaders/compositor_screen_lens_distortion.glsl | 151 +++++++++++++++++++++ .../shaders/compositor_set_alpha.glsl | 8 ++ .../shaders/compositor_split_viewer.glsl | 14 ++ .../shaders/compositor_symmetric_blur.glsl | 77 +++++++++++ .../compositor_symmetric_separable_blur.glsl | 53 ++++++++ .../shaders/compositor_tone_map_photoreceptor.glsl | 22 +++ .../shaders/compositor_tone_map_simple.glsl | 26 ++++ .../shaders/infos/compositor_alpha_crop_info.hh | 12 ++ .../infos/compositor_bilateral_blur_info.hh | 13 ++ .../shaders/infos/compositor_blur_info.hh | 14 ++ .../infos/compositor_blur_variable_size_info.hh | 15 ++ .../shaders/infos/compositor_bokeh_image_info.hh | 14 ++ .../shaders/infos/compositor_box_mask_info.hh | 35 +++++ .../shaders/infos/compositor_convert_info.hh | 69 ++++++++++ .../shaders/infos/compositor_despeckle_info.hh | 13 ++ .../infos/compositor_directional_blur_info.hh | 12 ++ .../shaders/infos/compositor_edge_filter_info.hh | 12 ++ .../shaders/infos/compositor_ellipse_mask_info.hh | 35 +++++ .../shaders/infos/compositor_filter_info.hh | 12 ++ .../shaders/infos/compositor_flip_info.hh | 12 ++ .../shaders/infos/compositor_image_crop_info.hh | 11 ++ ...mpositor_morphological_distance_feather_info.hh | 21 +++ .../compositor_morphological_distance_info.hh | 22 +++ ...ositor_morphological_distance_threshold_info.hh | 13 ++ .../infos/compositor_morphological_step_info.hh | 22 +++ .../shaders/infos/compositor_normalize_info.hh | 12 ++ .../infos/compositor_parallel_reduction_info.hh | 149 ++++++++++++++++++++ .../compositor_projector_lens_distortion_info.hh | 11 ++ .../infos/compositor_realize_on_domain_info.hh | 24 ++++ .../compositor_screen_lens_distortion_info.hh | 20 +++ .../shaders/infos/compositor_set_alpha_info.hh | 11 ++ .../shaders/infos/compositor_split_viewer_info.hh | 22 +++ .../infos/compositor_symmetric_blur_info.hh | 13 ++ .../compositor_symmetric_separable_blur_info.hh | 14 ++ .../compositor_tone_map_photoreceptor_info.hh | 16 +++ .../infos/compositor_tone_map_simple_info.hh | 13 ++ .../library/gpu_shader_compositor_alpha_over.glsl | 48 +++++++ .../library/gpu_shader_compositor_blur_common.glsl | 32 +++++ .../gpu_shader_compositor_bright_contrast.glsl | 38 ++++++ .../gpu_shader_compositor_channel_matte.glsl | 52 +++++++ .../gpu_shader_compositor_chroma_matte.glsl | 43 ++++++ .../gpu_shader_compositor_color_balance.glsl | 34 +++++ .../gpu_shader_compositor_color_correction.glsl | 87 ++++++++++++ .../library/gpu_shader_compositor_color_matte.glsl | 27 ++++ .../library/gpu_shader_compositor_color_spill.glsl | 13 ++ .../gpu_shader_compositor_color_to_luminance.glsl | 6 + .../gpu_shader_compositor_difference_matte.glsl | 10 ++ .../gpu_shader_compositor_distance_matte.glsl | 26 ++++ .../library/gpu_shader_compositor_exposure.glsl | 6 + .../library/gpu_shader_compositor_gamma.glsl | 7 + .../library/gpu_shader_compositor_hue_correct.glsl | 39 ++++++ ...gpu_shader_compositor_hue_saturation_value.glsl | 16 +++ .../library/gpu_shader_compositor_invert.glsl | 13 ++ .../gpu_shader_compositor_luminance_matte.glsl | 14 ++ .../library/gpu_shader_compositor_main.glsl | 7 + .../library/gpu_shader_compositor_map_value.glsl | 56 ++++++++ .../library/gpu_shader_compositor_normal.glsl | 9 ++ .../library/gpu_shader_compositor_posterize.glsl | 6 + .../gpu_shader_compositor_separate_combine.glsl | 132 ++++++++++++++++++ .../library/gpu_shader_compositor_set_alpha.glsl | 9 ++ .../gpu_shader_compositor_store_output.glsl | 26 ++++ .../gpu_shader_compositor_texture_utilities.glsl | 35 +++++ .../gpu_shader_compositor_type_conversion.glsl | 29 ++++ source/blender/gpu/CMakeLists.txt | 90 +----------- .../blender/gpu/intern/gpu_shader_create_info.cc | 1 + source/blender/gpu/intern/gpu_shader_dependency.cc | 2 + .../shaders/compositor/compositor_alpha_crop.glsl | 11 -- .../compositor/compositor_bilateral_blur.glsl | 31 ----- .../gpu/shaders/compositor/compositor_blur.glsl | 66 --------- .../compositor/compositor_blur_variable_size.glsl | 71 ---------- .../shaders/compositor/compositor_bokeh_image.glsl | 118 ---------------- .../shaders/compositor/compositor_box_mask.glsl | 27 ---- .../gpu/shaders/compositor/compositor_convert.glsl | 8 -- .../shaders/compositor/compositor_despeckle.glsl | 70 ---------- .../compositor/compositor_directional_blur.glsl | 21 --- .../shaders/compositor/compositor_edge_filter.glsl | 31 ----- .../compositor/compositor_ellipse_mask.glsl | 27 ---- .../gpu/shaders/compositor/compositor_filter.glsl | 20 --- .../gpu/shaders/compositor/compositor_flip.glsl | 15 -- .../shaders/compositor/compositor_image_crop.glsl | 7 - .../compositor_morphological_distance.glsl | 24 ---- .../compositor_morphological_distance_feather.glsl | 101 -------------- ...ompositor_morphological_distance_threshold.glsl | 88 ------------ .../compositor/compositor_morphological_step.glsl | 19 --- .../shaders/compositor/compositor_normalize.glsl | 10 -- .../compositor/compositor_parallel_reduction.glsl | 98 ------------- .../compositor_projector_lens_distortion.glsl | 16 --- .../compositor/compositor_realize_on_domain.glsl | 29 ---- .../compositor_screen_lens_distortion.glsl | 151 --------------------- .../shaders/compositor/compositor_set_alpha.glsl | 8 -- .../compositor/compositor_split_viewer.glsl | 14 -- .../compositor/compositor_symmetric_blur.glsl | 77 ----------- .../compositor_symmetric_separable_blur.glsl | 53 -------- .../compositor_tone_map_photoreceptor.glsl | 22 --- .../compositor/compositor_tone_map_simple.glsl | 26 ---- .../compositor/infos/compositor_alpha_crop_info.hh | 12 -- .../infos/compositor_bilateral_blur_info.hh | 13 -- .../compositor/infos/compositor_blur_info.hh | 14 -- .../infos/compositor_blur_variable_size_info.hh | 15 -- .../infos/compositor_bokeh_image_info.hh | 14 -- .../compositor/infos/compositor_box_mask_info.hh | 35 ----- .../compositor/infos/compositor_convert_info.hh | 69 ---------- .../compositor/infos/compositor_despeckle_info.hh | 13 -- .../infos/compositor_directional_blur_info.hh | 12 -- .../infos/compositor_edge_filter_info.hh | 12 -- .../infos/compositor_ellipse_mask_info.hh | 35 ----- .../compositor/infos/compositor_filter_info.hh | 12 -- .../compositor/infos/compositor_flip_info.hh | 12 -- .../compositor/infos/compositor_image_crop_info.hh | 11 -- ...mpositor_morphological_distance_feather_info.hh | 21 --- .../compositor_morphological_distance_info.hh | 22 --- ...ositor_morphological_distance_threshold_info.hh | 13 -- .../infos/compositor_morphological_step_info.hh | 22 --- .../compositor/infos/compositor_normalize_info.hh | 12 -- .../infos/compositor_parallel_reduction_info.hh | 149 -------------------- .../compositor_projector_lens_distortion_info.hh | 11 -- .../infos/compositor_realize_on_domain_info.hh | 24 ---- .../compositor_screen_lens_distortion_info.hh | 20 --- .../compositor/infos/compositor_set_alpha_info.hh | 11 -- .../infos/compositor_split_viewer_info.hh | 22 --- .../infos/compositor_symmetric_blur_info.hh | 13 -- .../compositor_symmetric_separable_blur_info.hh | 14 -- .../compositor_tone_map_photoreceptor_info.hh | 16 --- .../infos/compositor_tone_map_simple_info.hh | 13 -- .../library/gpu_shader_compositor_alpha_over.glsl | 48 ------- .../library/gpu_shader_compositor_blur_common.glsl | 32 ----- .../gpu_shader_compositor_bright_contrast.glsl | 38 ------ .../gpu_shader_compositor_channel_matte.glsl | 52 ------- .../gpu_shader_compositor_chroma_matte.glsl | 43 ------ .../gpu_shader_compositor_color_balance.glsl | 34 ----- .../gpu_shader_compositor_color_correction.glsl | 87 ------------ .../library/gpu_shader_compositor_color_matte.glsl | 27 ---- .../library/gpu_shader_compositor_color_spill.glsl | 13 -- .../gpu_shader_compositor_color_to_luminance.glsl | 6 - .../gpu_shader_compositor_difference_matte.glsl | 10 -- .../gpu_shader_compositor_distance_matte.glsl | 26 ---- .../library/gpu_shader_compositor_exposure.glsl | 6 - .../library/gpu_shader_compositor_gamma.glsl | 7 - .../library/gpu_shader_compositor_hue_correct.glsl | 39 ------ ...gpu_shader_compositor_hue_saturation_value.glsl | 16 --- .../library/gpu_shader_compositor_invert.glsl | 13 -- .../gpu_shader_compositor_luminance_matte.glsl | 14 -- .../library/gpu_shader_compositor_main.glsl | 7 - .../library/gpu_shader_compositor_map_value.glsl | 56 -------- .../library/gpu_shader_compositor_normal.glsl | 9 -- .../library/gpu_shader_compositor_posterize.glsl | 6 - .../gpu_shader_compositor_separate_combine.glsl | 132 ------------------ .../library/gpu_shader_compositor_set_alpha.glsl | 9 -- .../gpu_shader_compositor_store_output.glsl | 26 ---- .../gpu_shader_compositor_texture_utilities.glsl | 35 ----- .../gpu_shader_compositor_type_conversion.glsl | 29 ---- 174 files changed, 2871 insertions(+), 2829 deletions(-) create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_alpha_crop.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_bilateral_blur.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_blur.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_blur_variable_size.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_bokeh_image.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_box_mask.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_convert.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_despeckle.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_directional_blur.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_edge_filter.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_ellipse_mask.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_filter.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_flip.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_image_crop.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance_feather.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance_threshold.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_morphological_step.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_normalize.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_parallel_reduction.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_projector_lens_distortion.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_realize_on_domain.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_screen_lens_distortion.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_set_alpha.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_split_viewer.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_symmetric_blur.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_symmetric_separable_blur.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_tone_map_photoreceptor.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/compositor_tone_map_simple.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_alpha_crop_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_bilateral_blur_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_blur_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_blur_variable_size_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_bokeh_image_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_box_mask_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_convert_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_despeckle_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_directional_blur_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_edge_filter_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_ellipse_mask_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_filter_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_flip_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_image_crop_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_feather_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_threshold_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_step_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_normalize_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_parallel_reduction_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_projector_lens_distortion_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_realize_on_domain_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_screen_lens_distortion_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_set_alpha_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_split_viewer_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_symmetric_blur_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_symmetric_separable_blur_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_tone_map_photoreceptor_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/infos/compositor_tone_map_simple_info.hh create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_alpha_over.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_blur_common.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_bright_contrast.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_channel_matte.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_chroma_matte.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_balance.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_correction.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_matte.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_spill.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_to_luminance.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_difference_matte.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_distance_matte.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_exposure.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_gamma.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_hue_correct.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_hue_saturation_value.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_invert.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_luminance_matte.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_main.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_map_value.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_normal.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_posterize.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_separate_combine.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_set_alpha.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_store_output.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_texture_utilities.glsl create mode 100644 source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_type_conversion.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_alpha_crop.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_bilateral_blur.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_blur.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_blur_variable_size.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_bokeh_image.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_box_mask.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_convert.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_despeckle.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_directional_blur.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_edge_filter.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_ellipse_mask.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_filter.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_flip.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_image_crop.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_morphological_distance.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_morphological_distance_feather.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_morphological_distance_threshold.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_morphological_step.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_normalize.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_parallel_reduction.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_projector_lens_distortion.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_realize_on_domain.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_screen_lens_distortion.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_set_alpha.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_split_viewer.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_symmetric_blur.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_symmetric_separable_blur.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_tone_map_photoreceptor.glsl delete mode 100644 source/blender/gpu/shaders/compositor/compositor_tone_map_simple.glsl delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_alpha_crop_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_bilateral_blur_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_blur_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_blur_variable_size_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_bokeh_image_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_box_mask_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_convert_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_despeckle_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_directional_blur_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_edge_filter_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_ellipse_mask_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_filter_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_flip_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_image_crop_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_feather_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_threshold_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_morphological_step_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_normalize_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_parallel_reduction_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_projector_lens_distortion_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_realize_on_domain_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_screen_lens_distortion_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_set_alpha_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_split_viewer_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_symmetric_blur_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_symmetric_separable_blur_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_tone_map_photoreceptor_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/infos/compositor_tone_map_simple_info.hh delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_alpha_over.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_blur_common.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_bright_contrast.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_channel_matte.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_chroma_matte.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_balance.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_correction.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_matte.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_spill.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_to_luminance.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_difference_matte.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_distance_matte.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_exposure.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_gamma.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_correct.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_saturation_value.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_invert.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_luminance_matte.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_main.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_map_value.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_normal.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_posterize.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_separate_combine.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_set_alpha.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_store_output.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_texture_utilities.glsl delete mode 100644 source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_type_conversion.glsl (limited to 'source/blender') diff --git a/source/blender/compositor/realtime_compositor/CMakeLists.txt b/source/blender/compositor/realtime_compositor/CMakeLists.txt index bab0b5385ec..2402adcadaf 100644 --- a/source/blender/compositor/realtime_compositor/CMakeLists.txt +++ b/source/blender/compositor/realtime_compositor/CMakeLists.txt @@ -68,4 +68,129 @@ set(LIB bf_blenkernel ) +set(GLSL_SRC + shaders/compositor_alpha_crop.glsl + shaders/compositor_bilateral_blur.glsl + shaders/compositor_blur.glsl + shaders/compositor_blur_variable_size.glsl + shaders/compositor_bokeh_image.glsl + shaders/compositor_box_mask.glsl + shaders/compositor_convert.glsl + shaders/compositor_despeckle.glsl + shaders/compositor_directional_blur.glsl + shaders/compositor_edge_filter.glsl + shaders/compositor_ellipse_mask.glsl + shaders/compositor_filter.glsl + shaders/compositor_flip.glsl + shaders/compositor_image_crop.glsl + shaders/compositor_morphological_distance.glsl + shaders/compositor_morphological_distance_feather.glsl + shaders/compositor_morphological_distance_threshold.glsl + shaders/compositor_morphological_step.glsl + shaders/compositor_normalize.glsl + shaders/compositor_parallel_reduction.glsl + shaders/compositor_projector_lens_distortion.glsl + shaders/compositor_realize_on_domain.glsl + shaders/compositor_screen_lens_distortion.glsl + shaders/compositor_set_alpha.glsl + shaders/compositor_split_viewer.glsl + shaders/compositor_symmetric_blur.glsl + shaders/compositor_symmetric_separable_blur.glsl + shaders/compositor_tone_map_photoreceptor.glsl + shaders/compositor_tone_map_simple.glsl + + shaders/library/gpu_shader_compositor_alpha_over.glsl + shaders/library/gpu_shader_compositor_blur_common.glsl + shaders/library/gpu_shader_compositor_bright_contrast.glsl + shaders/library/gpu_shader_compositor_channel_matte.glsl + shaders/library/gpu_shader_compositor_chroma_matte.glsl + shaders/library/gpu_shader_compositor_color_balance.glsl + shaders/library/gpu_shader_compositor_color_correction.glsl + shaders/library/gpu_shader_compositor_color_matte.glsl + shaders/library/gpu_shader_compositor_color_spill.glsl + shaders/library/gpu_shader_compositor_color_to_luminance.glsl + shaders/library/gpu_shader_compositor_difference_matte.glsl + shaders/library/gpu_shader_compositor_distance_matte.glsl + shaders/library/gpu_shader_compositor_exposure.glsl + shaders/library/gpu_shader_compositor_gamma.glsl + shaders/library/gpu_shader_compositor_hue_correct.glsl + shaders/library/gpu_shader_compositor_hue_saturation_value.glsl + shaders/library/gpu_shader_compositor_invert.glsl + shaders/library/gpu_shader_compositor_luminance_matte.glsl + shaders/library/gpu_shader_compositor_main.glsl + shaders/library/gpu_shader_compositor_map_value.glsl + shaders/library/gpu_shader_compositor_normal.glsl + shaders/library/gpu_shader_compositor_posterize.glsl + shaders/library/gpu_shader_compositor_separate_combine.glsl + shaders/library/gpu_shader_compositor_set_alpha.glsl + shaders/library/gpu_shader_compositor_store_output.glsl + shaders/library/gpu_shader_compositor_texture_utilities.glsl + shaders/library/gpu_shader_compositor_type_conversion.glsl +) + +set(GLSL_C) +foreach(GLSL_FILE ${GLSL_SRC}) + data_to_c_simple(${GLSL_FILE} GLSL_C) +endforeach() + +blender_add_lib(bf_compositor_shaders "${GLSL_C}" "" "" "") + +list(APPEND LIB + bf_compositor_shaders +) + +set(GLSL_SOURCE_CONTENT "") +foreach(GLSL_FILE ${GLSL_SRC}) + get_filename_component(GLSL_FILE_NAME ${GLSL_FILE} NAME) + string(REPLACE "." "_" GLSL_FILE_NAME_UNDERSCORES ${GLSL_FILE_NAME}) + string(APPEND GLSL_SOURCE_CONTENT "SHADER_SOURCE\(datatoc_${GLSL_FILE_NAME_UNDERSCORES}, \"${GLSL_FILE_NAME}\", \"${GLSL_FILE}\"\)\n") +endforeach() + +set(glsl_source_list_file "${CMAKE_CURRENT_BINARY_DIR}/glsl_compositor_source_list.h") +file(GENERATE OUTPUT ${glsl_source_list_file} CONTENT "${GLSL_SOURCE_CONTENT}") +list(APPEND SRC ${glsl_source_list_file}) +list(APPEND INC ${CMAKE_CURRENT_BINARY_DIR}) + +target_include_directories(bf_compositor_shaders PUBLIC ${CMAKE_CURRENT_BINARY_DIR}) + +set(SRC_SHADER_CREATE_INFOS + shaders/infos/compositor_alpha_crop_info.hh + shaders/infos/compositor_bilateral_blur_info.hh + shaders/infos/compositor_blur_info.hh + shaders/infos/compositor_blur_variable_size_info.hh + shaders/infos/compositor_bokeh_image_info.hh + shaders/infos/compositor_box_mask_info.hh + shaders/infos/compositor_convert_info.hh + shaders/infos/compositor_despeckle_info.hh + shaders/infos/compositor_directional_blur_info.hh + shaders/infos/compositor_edge_filter_info.hh + shaders/infos/compositor_ellipse_mask_info.hh + shaders/infos/compositor_filter_info.hh + shaders/infos/compositor_flip_info.hh + shaders/infos/compositor_image_crop_info.hh + shaders/infos/compositor_morphological_distance_feather_info.hh + shaders/infos/compositor_morphological_distance_info.hh + shaders/infos/compositor_morphological_distance_threshold_info.hh + shaders/infos/compositor_morphological_step_info.hh + shaders/infos/compositor_normalize_info.hh + shaders/infos/compositor_parallel_reduction_info.hh + shaders/infos/compositor_projector_lens_distortion_info.hh + shaders/infos/compositor_realize_on_domain_info.hh + shaders/infos/compositor_screen_lens_distortion_info.hh + shaders/infos/compositor_set_alpha_info.hh + shaders/infos/compositor_split_viewer_info.hh + shaders/infos/compositor_symmetric_blur_info.hh + shaders/infos/compositor_symmetric_separable_blur_info.hh + shaders/infos/compositor_tone_map_photoreceptor_info.hh + shaders/infos/compositor_tone_map_simple_info.hh +) + +set(SHADER_CREATE_INFOS_CONTENT "") +foreach(DESCRIPTOR_FILE ${SRC_SHADER_CREATE_INFOS}) + string(APPEND SHADER_CREATE_INFOS_CONTENT "#include \"${DESCRIPTOR_FILE}\"\n") +endforeach() + +set(shader_create_info_list_file "${CMAKE_CURRENT_BINARY_DIR}/compositor_shader_create_info_list.hh") +file(GENERATE OUTPUT ${shader_create_info_list_file} CONTENT "${SHADER_CREATE_INFOS_CONTENT}") + blender_add_lib(bf_realtime_compositor "${SRC}" "${INC}" "${INC_SYS}" "${LIB}") diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_alpha_crop.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_alpha_crop.glsl new file mode 100644 index 00000000000..d55c8efd4c6 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_alpha_crop.glsl @@ -0,0 +1,11 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + /* The lower bound is inclusive and upper bound is exclusive. */ + bool is_inside = all(greaterThanEqual(texel, lower_bound)) && all(lessThan(texel, upper_bound)); + /* Write the pixel color if it is inside the cropping region, otherwise, write zero. */ + vec4 color = is_inside ? texture_load(input_tx, texel) : vec4(0.0); + imageStore(output_img, texel, color); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_bilateral_blur.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_bilateral_blur.glsl new file mode 100644 index 00000000000..c7c5ada7a9f --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_bilateral_blur.glsl @@ -0,0 +1,31 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + vec4 center_determinator = texture_load(determinator_tx, texel); + + /* Go over the pixels in the blur window of the specified radius around the center pixel, and for + * pixels whose determinator is close enough to the determinator of the center pixel, accumulate + * their color as well as their weights. */ + float accumulated_weight = 0.0; + vec4 accumulated_color = vec4(0.0); + for (int y = -radius; y <= radius; y++) { + for (int x = -radius; x <= radius; x++) { + vec4 determinator = texture_load(determinator_tx, texel + ivec2(x, y)); + float difference = dot(abs(center_determinator - determinator).rgb, vec3(1.0)); + + if (difference < threshold) { + accumulated_weight += 1.0; + accumulated_color += texture_load(input_tx, texel + ivec2(x, y)); + } + } + } + + /* Write the accumulated color divided by the accumulated weight if any pixel in the window was + * accumulated, otherwise, write a fallback black color. */ + vec4 fallback = vec4(vec3(0.0), 1.0); + vec4 color = (accumulated_weight != 0.0) ? (accumulated_color / accumulated_weight) : fallback; + imageStore(output_img, texel, color); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_blur.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_blur.glsl new file mode 100644 index 00000000000..c7ac620f99b --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_blur.glsl @@ -0,0 +1,66 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +vec4 load_input(ivec2 texel) +{ + vec4 color; + if (extend_bounds) { + /* If bounds are extended, then we treat the input as padded by a radius amount of pixels. So + * we load the input with an offset by the radius amount and fallback to a transparent color if + * it is out of bounds. */ + color = texture_load(input_tx, texel - radius, vec4(0.0)); + } + else { + color = texture_load(input_tx, texel); + } + + return color; +} + +/* Given the texel in the range [-radius, radius] in both axis, load the appropriate weight from + * the weights texture, where the given texel (0, 0) corresponds the center of weights texture. + * Note that we load the weights texture inverted along both directions to maintain the shape of + * the weights if it was not symmetrical. To understand why inversion makes sense, consider a 1D + * weights texture whose right half is all ones and whose left half is all zeros. Further, consider + * that we are blurring a single white pixel on a black background. When computing the value of a + * pixel that is to the right of the white pixel, the white pixel will be in the left region of the + * search window, and consequently, without inversion, a zero will be sampled from the left side of + * the weights texture and result will be zero. However, what we expect is that pixels to the right + * of the white pixel will be white, that is, they should sample a weight of 1 from the right side + * of the weights texture, hence the need for inversion. */ +vec4 load_weight(ivec2 texel) +{ + /* Add the radius to transform the texel into the range [0, radius * 2], with an additional 0.5 + * to sample at the center of the pixels, then divide by the upper bound plus one to transform + * the texel into the normalized range [0, 1] needed to sample the weights sampler. Finally, + * invert the textures coordinates by subtracting from 1 to maintain the shape of the weights as + * mentioned in the function description. */ + return texture(weights_tx, 1.0 - ((texel + vec2(radius + 0.5)) / (radius * 2 + 1))); +} + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* The mask input is treated as a boolean. If it is zero, then no blurring happens for this + * pixel. Otherwise, the pixel is blurred normally and the mask value is irrelevant. */ + float mask = texture_load(mask_tx, texel).x; + if (mask == 0.0) { + imageStore(output_img, texel, texture_load(input_tx, texel)); + return; + } + + /* Go over the window of the given radius and accumulate the colors multiplied by their + * respective weights as well as the weights themselves. */ + vec4 accumulated_color = vec4(0.0); + vec4 accumulated_weight = vec4(0.0); + for (int y = -radius; y <= radius; y++) { + for (int x = -radius; x <= radius; x++) { + vec4 weight = load_weight(ivec2(x, y)); + accumulated_color += load_input(texel + ivec2(x, y)) * weight; + accumulated_weight += weight; + } + } + + imageStore(output_img, texel, safe_divide(accumulated_color, accumulated_weight)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_blur_variable_size.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_blur_variable_size.glsl new file mode 100644 index 00000000000..9383bbf9825 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_blur_variable_size.glsl @@ -0,0 +1,71 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +/* Given the texel in the range [-radius, radius] in both axis, load the appropriate weight from + * the weights texture, where the given texel (0, 0) corresponds the center of weights texture. + * Note that we load the weights texture inverted along both directions to maintain the shape of + * the weights if it was not symmetrical. To understand why inversion makes sense, consider a 1D + * weights texture whose right half is all ones and whose left half is all zeros. Further, consider + * that we are blurring a single white pixel on a black background. When computing the value of a + * pixel that is to the right of the white pixel, the white pixel will be in the left region of the + * search window, and consequently, without inversion, a zero will be sampled from the left side of + * the weights texture and result will be zero. However, what we expect is that pixels to the right + * of the white pixel will be white, that is, they should sample a weight of 1 from the right side + * of the weights texture, hence the need for inversion. */ +vec4 load_weight(ivec2 texel, float radius) +{ + /* The center zero texel is always assigned a unit weight regardless of the corresponding weight + * in the weights texture. That's to guarantee that at last the center pixel will be accumulated + * even if the weights texture is zero at its center. */ + if (texel == ivec2(0)) { + return vec4(1.0); + } + + /* Add the radius to transform the texel into the range [0, radius * 2], with an additional 0.5 + * to sample at the center of the pixels, then divide by the upper bound plus one to transform + * the texel into the normalized range [0, 1] needed to sample the weights sampler. Finally, + * invert the textures coordinates by subtracting from 1 to maintain the shape of the weights as + * mentioned in the function description. */ + return texture(weights_tx, 1.0 - ((texel + vec2(radius + 0.5)) / (radius * 2 + 1))); +} + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* The mask input is treated as a boolean. If it is zero, then no blurring happens for this + * pixel. Otherwise, the pixel is blurred normally and the mask value is irrelevant. */ + float mask = texture_load(mask_tx, texel).x; + if (mask == 0.0) { + imageStore(output_img, texel, texture_load(input_tx, texel)); + return; + } + + float center_size = texture_load(size_tx, texel).x * base_size; + + /* Go over the window of the given search radius and accumulate the colors multiplied by their + * respective weights as well as the weights themselves, but only if both the size of the center + * pixel and the size of the candidate pixel are less than both the x and y distances of the + * candidate pixel. */ + vec4 accumulated_color = vec4(0.0); + vec4 accumulated_weight = vec4(0.0); + for (int y = -search_radius; y <= search_radius; y++) { + for (int x = -search_radius; x <= search_radius; x++) { + float candidate_size = texture_load(size_tx, texel + ivec2(x, y)).x * base_size; + + /* Skip accumulation if either the x or y distances of the candidate pixel are larger than + * either the center or candidate pixel size. Note that the max and min functions here denote + * "either" in the aforementioned description. */ + float size = min(center_size, candidate_size); + if (max(abs(x), abs(y)) > size) { + continue; + } + + vec4 weight = load_weight(ivec2(x, y), size); + accumulated_color += texture_load(input_tx, texel + ivec2(x, y)) * weight; + accumulated_weight += weight; + } + } + + imageStore(output_img, texel, safe_divide(accumulated_color, accumulated_weight)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_bokeh_image.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_bokeh_image.glsl new file mode 100644 index 00000000000..6e98aa9fe17 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_bokeh_image.glsl @@ -0,0 +1,118 @@ +#pragma BLENDER_REQUIRE(common_math_lib.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +/* Get the 2D vertex position of the vertex with the given index in the regular polygon + * representing this bokeh. The polygon is rotated by the rotation amount and have a unit + * circumradius. The regular polygon is one whose vertices' exterior angles are given by + * exterior_angle. See the bokeh function for more information. */ +vec2 get_regular_polygon_vertex_position(int vertex_index) +{ + float angle = exterior_angle * vertex_index - rotation; + return vec2(cos(angle), sin(angle)); +} + +/* Find the closest point to the given point on the given line. This assumes the length of the + * given line is not zero. */ +vec2 closest_point_on_line(vec2 point, vec2 line_start, vec2 line_end) +{ + vec2 line_vector = line_end - line_start; + vec2 point_vector = point - line_start; + float line_length_squared = dot(line_vector, line_vector); + float parameter = dot(point_vector, line_vector) / line_length_squared; + return line_start + line_vector * parameter; +} + +/* Compute the value of the bokeh at the given point. The computed bokeh is essentially a regular + * polygon centered in space having the given circumradius. The regular polygon is one whose + * vertices' exterior angles are given by "exterior_angle", which relates to the number of vertices + * n through the equation "exterior angle = 2 pi / n". The regular polygon may additionally morph + * into a shape with the given properties: + * + * - The regular polygon may have a circular hole in its center whose radius is controlled by the + * "catadioptric" value. + * - The regular polygon is rotated by the "rotation" value. + * - The regular polygon can morph into a circle controlled by the "roundness" value, such that it + * becomes a full circle at unit roundness. + * + * The function returns 0 when the point lies inside the regular polygon and 1 otherwise. However, + * at the edges, it returns a narrow band gradient as a form of anti-aliasing. */ +float bokeh(vec2 point, float circumradius) +{ + /* Get the index of the vertex of the regular polygon whose polar angle is maximum but less than + * the polar angle of the given point, taking rotation into account. This essentially finds the + * vertex closest to the given point in the clock-wise direction. */ + float angle = mod(atan(point.y, point.x) + rotation, M_2PI); + int vertex_index = int(angle / exterior_angle); + + /* Compute the shortest distance between the origin and the polygon edge composed from the + * previously selected vertex and the one following it. */ + vec2 first_vertex = get_regular_polygon_vertex_position(vertex_index) * circumradius; + vec2 second_vertex = get_regular_polygon_vertex_position(vertex_index + 1) * circumradius; + vec2 closest_point = closest_point_on_line(point, first_vertex, second_vertex); + float distance_to_edge = length(closest_point); + + /* Mix the distance to the edge with the circumradius, making it tend to the distance to a + * circle when roundness tends to 1. */ + float distance_to_edge_round = mix(distance_to_edge, circumradius, roundness); + + /* The point is outside of the bokeh, so we return 0. */ + float distance = length(point); + if (distance > distance_to_edge_round) { + return 0.0; + } + + /* The point is inside the catadioptric hole and is not part of the bokeh, so we return 0. */ + float catadioptric_distance = distance_to_edge_round * catadioptric; + if (distance < catadioptric_distance) { + return 0.0; + } + + /* The point is very close to the edge of the bokeh, so we return the difference between the + * distance to the edge and the distance as a form of anti-aliasing. */ + if (distance_to_edge_round - distance < 1.0) { + return distance_to_edge_round - distance; + } + + /* The point is very close to the edge of the catadioptric hole, so we return the difference + * between the distance to the hole and the distance as a form of anti-aliasing. */ + if (catadioptric != 0.0 && distance - catadioptric_distance < 1.0) { + return distance - catadioptric_distance; + } + + /* Otherwise, the point is part of the bokeh and we return 1. */ + return 1.0; +} + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* Since we need the regular polygon to occupy the entirety of the output image, the circumradius + * of the regular polygon is half the width of the output image. */ + float circumradius = float(imageSize(output_img).x) / 2.0; + + /* Move the texel coordinates such that the regular polygon is centered. */ + vec2 point = vec2(texel) - circumradius; + + /* Each of the color channels of the output image contains a bokeh with a different circumradius. + * The largest one occupies the whole image as stated above, while the other two have circumradii + * that are shifted by an amount that is proportional to the "lens_shift" value. The alpha + * channel of the output is the average of all three values. */ + float min_shift = abs(lens_shift * circumradius); + float min = mix(bokeh(point, circumradius - min_shift), 0.0, min_shift == circumradius); + + float median_shift = min_shift / 2.0; + float median = bokeh(point, circumradius - median_shift); + + float max = bokeh(point, circumradius); + vec4 bokeh = vec4(min, median, max, (max + median + min) / 3.0); + + /* If the lens shift is negative, swap the min and max bokeh values, which are stored in the red + * and blue channels respectively. Note that we take the absolute value of the lens shift above, + * so the sign of the lens shift only controls this swap. */ + if (lens_shift < 0) { + bokeh = bokeh.zyxw; + } + + imageStore(output_img, texel, bokeh); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_box_mask.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_box_mask.glsl new file mode 100644 index 00000000000..fad23f28fde --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_box_mask.glsl @@ -0,0 +1,27 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + vec2 uv = vec2(texel) / vec2(domain_size - ivec2(1)); + uv -= location; + uv.y *= float(domain_size.y) / float(domain_size.x); + uv = mat2(cos_angle, -sin_angle, sin_angle, cos_angle) * uv; + bool is_inside = all(lessThan(abs(uv), size)); + + float base_mask_value = texture_load(base_mask_tx, texel).x; + float value = texture_load(mask_value_tx, texel).x; + +#if defined(CMP_NODE_MASKTYPE_ADD) + float output_mask_value = is_inside ? max(base_mask_value, value) : base_mask_value; +#elif defined(CMP_NODE_MASKTYPE_SUBTRACT) + float output_mask_value = is_inside ? clamp(base_mask_value - value, 0.0, 1.0) : base_mask_value; +#elif defined(CMP_NODE_MASKTYPE_MULTIPLY) + float output_mask_value = is_inside ? base_mask_value * value : 0.0; +#elif defined(CMP_NODE_MASKTYPE_NOT) + float output_mask_value = is_inside ? (base_mask_value > 0.0 ? 0.0 : value) : base_mask_value; +#endif + + imageStore(output_mask_img, texel, vec4(output_mask_value)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_convert.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_convert.glsl new file mode 100644 index 00000000000..044fb057ca5 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_convert.glsl @@ -0,0 +1,8 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + vec4 value = texture_load(input_tx, texel); + imageStore(output_img, texel, CONVERT_EXPRESSION(value)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_despeckle.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_despeckle.glsl new file mode 100644 index 00000000000..e4743d69d17 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_despeckle.glsl @@ -0,0 +1,70 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +/* Returns true if the given color is close enough to the given reference color within the + * threshold supplied by the user, and returns false otherwise. */ +bool is_close(vec4 reference_color, vec4 color) +{ + return all(lessThan(abs(reference_color - color).rgb, vec3(threshold))); +} + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* A 3x3 weights kernel whose weights are the inverse of the distance to the center of the + * kernel. So the center weight is zero, the corners weights are (1 / sqrt(2)), and the rest + * of the weights are 1. The total sum of weights is 4 plus quadruple the corner weight. */ + float corner_weight = 1.0 / sqrt(2.0); + float sum_of_weights = 4.0 + corner_weight * 4.0; + mat3 weights = mat3(vec3(corner_weight, 1.0, corner_weight), + vec3(1.0, 0.0, 1.0), + vec3(corner_weight, 1.0, corner_weight)); + + vec4 center_color = texture_load(input_tx, texel); + + /* Go over the pixels in the 3x3 window around the center pixel and compute the total sum of + * their colors multiplied by their weights. Additionally, for pixels whose colors are not close + * enough to the color of the center pixel, accumulate their color as well as their weights. */ + vec4 sum_of_colors = vec4(0); + float accumulated_weight = 0.0; + vec4 accumulated_color = vec4(0); + for (int j = 0; j < 3; j++) { + for (int i = 0; i < 3; i++) { + float weight = weights[j][i]; + vec4 color = texture_load(input_tx, texel + ivec2(i - 1, j - 1)) * weight; + sum_of_colors += color; + if (!is_close(center_color, color)) { + accumulated_color += color; + accumulated_weight += weight; + } + } + } + + /* If the accumulated weight is zero, that means all pixels in the 3x3 window are similar and no + * need to despeckle anything, so write the original center color and return. */ + if (accumulated_weight == 0.0) { + imageStore(output_img, texel, center_color); + return; + } + + /* If the ratio between the accumulated weights and the total sum of weights is not larger than + * the user specified neighbor threshold, then the number of pixels in the neighborhood that are + * not close enough to the center pixel is low, and no need to despeckle anything, so write the + * original center color and return. */ + if (accumulated_weight / sum_of_weights < neighbor_threshold) { + imageStore(output_img, texel, center_color); + return; + } + + /* If the weighted average color of the neighborhood is close enough to the center pixel, then no + * need to despeckle anything, so write the original center color and return. */ + if (is_close(center_color, sum_of_colors / sum_of_weights)) { + imageStore(output_img, texel, center_color); + return; + } + + /* We need to despeckle, so write the mean accumulated color. */ + float factor = texture_load(factor_tx, texel).x; + vec4 mean_color = accumulated_color / accumulated_weight; + imageStore(output_img, texel, mix(center_color, mean_color, factor)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_directional_blur.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_directional_blur.glsl new file mode 100644 index 00000000000..1805cb5a7f5 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_directional_blur.glsl @@ -0,0 +1,21 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + ivec2 input_size = texture_size(input_tx); + + /* Add 0.5 to evaluate the input sampler at the center of the pixel. */ + vec2 coordinates = vec2(texel) + vec2(0.5); + + /* For each iteration, accumulate the input at the normalize coordinates, hence the divide by + * input size, then transform the coordinates for the next iteration. */ + vec4 accumulated_color = vec4(0.0); + for (int i = 0; i < iterations; i++) { + accumulated_color += texture(input_tx, coordinates / input_size); + coordinates = (mat3(inverse_transformation) * vec3(coordinates, 1.0)).xy; + } + + /* Write the accumulated color divided by the number of iterations. */ + imageStore(output_img, texel, accumulated_color / iterations); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_edge_filter.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_edge_filter.glsl new file mode 100644 index 00000000000..67e27c22602 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_edge_filter.glsl @@ -0,0 +1,31 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* Compute the dot product between the 3x3 window around the pixel and the edge detection kernel + * in the X direction and Y direction. The Y direction kernel is computed by transposing the + * given X direction kernel. */ + vec3 color_x = vec3(0); + vec3 color_y = vec3(0); + for (int j = 0; j < 3; j++) { + for (int i = 0; i < 3; i++) { + vec3 color = texture_load(input_tx, texel + ivec2(i - 1, j - 1)).rgb; + color_x += color * kernel[j][i]; + color_y += color * kernel[i][j]; + } + } + + /* Compute the channel-wise magnitude of the 2D vector composed from the X and Y edge detection + * filter results. */ + vec3 magnitude = sqrt(color_x * color_x + color_y * color_y); + + /* Mix the channel-wise magnitude with the original color at the center of the kernel using the + * input factor. */ + vec4 color = texture_load(input_tx, texel); + magnitude = mix(color.rgb, magnitude, texture_load(factor_tx, texel).x); + + /* Store the channel-wise magnitude with the original alpha of the input. */ + imageStore(output_img, texel, vec4(magnitude, color.a)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_ellipse_mask.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_ellipse_mask.glsl new file mode 100644 index 00000000000..28f725067e0 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_ellipse_mask.glsl @@ -0,0 +1,27 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + vec2 uv = vec2(texel) / vec2(domain_size - ivec2(1)); + uv -= location; + uv.y *= float(domain_size.y) / float(domain_size.x); + uv = mat2(cos_angle, -sin_angle, sin_angle, cos_angle) * uv; + bool is_inside = length(uv / radius) < 1.0; + + float base_mask_value = texture_load(base_mask_tx, texel).x; + float value = texture_load(mask_value_tx, texel).x; + +#if defined(CMP_NODE_MASKTYPE_ADD) + float output_mask_value = is_inside ? max(base_mask_value, value) : base_mask_value; +#elif defined(CMP_NODE_MASKTYPE_SUBTRACT) + float output_mask_value = is_inside ? clamp(base_mask_value - value, 0.0, 1.0) : base_mask_value; +#elif defined(CMP_NODE_MASKTYPE_MULTIPLY) + float output_mask_value = is_inside ? base_mask_value * value : 0.0; +#elif defined(CMP_NODE_MASKTYPE_NOT) + float output_mask_value = is_inside ? (base_mask_value > 0.0 ? 0.0 : value) : base_mask_value; +#endif + + imageStore(output_mask_img, texel, vec4(output_mask_value)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_filter.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_filter.glsl new file mode 100644 index 00000000000..e501c563dda --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_filter.glsl @@ -0,0 +1,20 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* Compute the dot product between the 3x3 window around the pixel and the filter kernel. */ + vec4 color = vec4(0); + for (int j = 0; j < 3; j++) { + for (int i = 0; i < 3; i++) { + color += texture_load(input_tx, texel + ivec2(i - 1, j - 1)) * kernel[j][i]; + } + } + + /* Mix with the original color at the center of the kernel using the input factor. */ + color = mix(texture_load(input_tx, texel), color, texture_load(factor_tx, texel).x); + + /* Store the color making sure it is not negative. */ + imageStore(output_img, texel, max(color, 0.0)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_flip.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_flip.glsl new file mode 100644 index 00000000000..919c454ee63 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_flip.glsl @@ -0,0 +1,15 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + ivec2 size = texture_size(input_tx); + ivec2 flipped_texel = texel; + if (flip_x) { + flipped_texel.x = size.x - texel.x - 1; + } + if (flip_y) { + flipped_texel.y = size.y - texel.y - 1; + } + imageStore(output_img, texel, texture_load(input_tx, flipped_texel)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_image_crop.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_image_crop.glsl new file mode 100644 index 00000000000..f20e033dee4 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_image_crop.glsl @@ -0,0 +1,7 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + imageStore(output_img, texel, texture_load(input_tx, texel + lower_bound)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance.glsl new file mode 100644 index 00000000000..09f896b7a9d --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance.glsl @@ -0,0 +1,24 @@ +#pragma BLENDER_REQUIRE(common_math_lib.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* Find the minimum/maximum value in the circular window of the given radius around the pixel. By + * circular window, we mean that pixels in the window whose distance to the center of window is + * larger than the given radius are skipped and not considered. Consequently, the dilation or + * erosion that take place produces round results as opposed to squarish ones. This is + * essentially a morphological operator with a circular structuring element. The LIMIT value + * should be FLT_MAX if OPERATOR is min and FLT_MIN if OPERATOR is max. */ + float value = LIMIT; + for (int y = -radius; y <= radius; y++) { + for (int x = -radius; x <= radius; x++) { + if (x * x + y * y <= radius * radius) { + value = OPERATOR(value, texture_load(input_tx, texel + ivec2(x, y), vec4(LIMIT)).x); + } + } + } + + imageStore(output_img, texel, vec4(value)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance_feather.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance_feather.glsl new file mode 100644 index 00000000000..acdd8a40342 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance_feather.glsl @@ -0,0 +1,101 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +/* The Morphological Distance Feather operation is a linear combination between the result of two + * operations. The first operation is a Gaussian blur with a radius equivalent to the dilate/erode + * distance, which is straightforward and implemented as a separable filter similar to the blur + * operation. + * + * The second operation is an approximation of a morphological inverse distance operation evaluated + * at a distance falloff function. The result of a morphological inverse distance operation is a + * narrow band distance field that starts at its maximum value at boundaries where a difference in + * values took place and linearly deceases until it reaches zero in the span of a number of pixels + * equivalent to the erode/dilate distance. Additionally, instead of linearly decreasing, the user + * may choose a different falloff which is evaluated at the computed distance. For dilation, the + * distance field decreases outwards, and for erosion, the distance field decreased inwards. + * + * The reason why the result of a Gaussian blur is mixed in with the distance field is because the + * distance field is merely approximated and not accurately computed, the defects of which is more + * apparent away from boundaries and especially at corners where the distance field should take a + * circular shape. That's why the Gaussian blur is mostly mixed only further from boundaries. + * + * The morphological inverse distance operation is approximated using a separable implementation + * and intertwined with the Gaussian blur implementation as follows. A search window of a radius + * equivalent to the dilate/erode distance is applied on the image to find either the minimum or + * maximum pixel value multiplied by its corresponding falloff value in the window. For dilation, + * we try to find the maximum, and for erosion, we try to find the minimum. Additionally, we also + * save the falloff value where the minimum or maximum was found. The found value will be that of + * the narrow band distance field and the saved falloff value will be used as the mixing factor + * with the Gaussian blur. + * + * To make sense of the aforementioned algorithm, assume we are dilating a binary image by 5 pixels + * whose half has a value of 1 and the other half has a value of zero. Consider the following: + * + * - A pixel of value 1 already has the maximum possible value, so its value will remain unchanged + * regardless of its position. + * - A pixel of value 0 that is right at the boundary of the 1's region will have a maximum value + * of around 0.8 depending on the falloff. That's because the search window intersects the 1's + * region, which when multiplied by the falloff gives the first value of the falloff, which is + * larger than the initially zero value computed at the center of the search window. + * - A pixel of value 0 that is 3 pixels away from the boundary will have a maximum value of around + * 0.4 depending on the falloff. That's because the search window intersects the 1's region, + * which when multiplied by the falloff gives the third value of the falloff, which is larger + * than the initially zero value computed at the center of the search window. + * - Finally, a pixel of value 0 that is 6 pixels away from the boundary will have a maximum value + * of 0, because the search window doesn't intersects the 1's region and only spans zero values. + * + * The previous example demonstrates how the distance field naturally arises, and the same goes for + * the erode case, except the minimum value is computed instead. + */ +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* A value for accumulating the blur result. */ + float accumulated_value = 0.0; + + /* Compute the contribution of the center pixel to the blur result. */ + float center_value = texture_load(input_tx, texel).x; + accumulated_value += center_value * texture_load(weights_tx, 0).x; + + /* Start with the center value as the maximum/minimum distance and reassign to the true maximum + * or minimum in the search loop below. Additionally, the center falloff is always 1.0, so start + * with that. */ + float limit_distance = center_value; + float limit_distance_falloff = 1.0; + + /* Compute the contributions of the pixels to the right and left, noting that the weights and + * falloffs textures only store the weights and falloffs for the positive half, but since the + * they are both symmetric, the same weights and falloffs are used for the negative half and we + * compute both of their contributions. */ + for (int i = 1; i < texture_size(weights_tx); i++) { + float weight = texture_load(weights_tx, i).x; + float falloff = texture_load(falloffs_tx, i).x; + + /* Loop for two iterations, where s takes the value of -1 and 1, which is used as the sign + * needed to evaluated the positive and negative sides as explain above. */ + for (int s = -1; s < 2; s += 2) { + /* Compute the contribution of the pixel to the blur result. */ + float value = texture_load(input_tx, texel + ivec2(s * i, 0)).x; + accumulated_value += value * weight; + + /* The distance is computed such that its highest value is the pixel value itself, so + * multiply the distance falloff by the pixel value. */ + float falloff_distance = value * falloff; + + /* Find either the maximum or the minimum for the dilate and erode cases respectively. */ + if (COMPARE(falloff_distance, limit_distance)) { + limit_distance = falloff_distance; + limit_distance_falloff = falloff; + } + } + } + + /* Mix between the limit distance and the blurred accumulated value such that the limit distance + * is used for pixels closer to the boundary and the blurred value is used for pixels away from + * the boundary. */ + float value = mix(accumulated_value, limit_distance, limit_distance_falloff); + + /* Write the value using the transposed texel. See the execute_distance_feather_horizontal_pass + * method for more information on the rational behind this. */ + imageStore(output_img, texel.yx, vec4(value)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance_threshold.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance_threshold.glsl new file mode 100644 index 00000000000..e6625e7419f --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_distance_threshold.glsl @@ -0,0 +1,88 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +/* The Morphological Distance Threshold operation is effectively three consecutive operations + * implemented as a single operation. The three operations are as follows: + * + * .-----------. .--------------. .----------------. + * | Threshold |-->| Dilate/Erode |-->| Distance Inset | + * '-----------' '--------------' '----------------' + * + * The threshold operation just converts the input into a binary image, where the pixel is 1 if it + * is larger than 0.5 and 0 otherwise. Pixels that are 1 in the output of the threshold operation + * are said to be masked. The dilate/erode operation is a dilate or erode morphological operation + * with a circular structuring element depending on the sign of the distance, where it is a dilate + * operation if the distance is positive and an erode operation otherwise. This is equivalent to + * the Morphological Distance operation, see its implementation for more information. Finally, the + * distance inset is an operation that converts the binary image into a narrow band distance field. + * That is, pixels that are unmasked will remain 0, while pixels that are masked will start from + * zero at the boundary of the masked region and linearly increase until reaching 1 in the span of + * a number pixels given by the inset value. + * + * As a performance optimization, the dilate/erode operation is omitted and its effective result is + * achieved by slightly adjusting the distance inset operation. The base distance inset operation + * works by computing the signed distance from the current center pixel to the nearest pixel with a + * different value. Since our image is a binary image, that means that if the pixel is masked, we + * compute the signed distance to the nearest unmasked pixel, and if the pixel unmasked, we compute + * the signed distance to the nearest masked pixel. The distance is positive if the pixel is masked + * and negative otherwise. The distance is then normalized by dividing by the given inset value and + * clamped to the [0, 1] range. Since distances larger than the inset value are eventually clamped, + * the distance search window is limited to a radius equivalent to the inset value. + * + * To archive the effective result of the omitted dilate/erode operation, we adjust the distance + * inset operation as follows. First, we increase the radius of the distance search window by the + * radius of the dilate/erode operation. Then we adjust the resulting narrow band signed distance + * field as follows. + * + * For the erode case, we merely subtract the erode distance, which makes the outermost erode + * distance number of pixels zero due to clamping, consequently achieving the result of the erode, + * while retaining the needed inset because we increased the distance search window by the same + * amount we subtracted. + * + * Similarly, for the dilate case, we add the dilate distance, which makes the dilate distance + * number of pixels just outside of the masked region positive and part of the narrow band distance + * field, consequently achieving the result of the dilate, while at the same time, the innermost + * dilate distance number of pixels become 1 due to clamping, retaining the needed inset because we + * increased the distance search window by the same amount we added. + * + * Since the erode/dilate distance is already signed appropriately as described before, we just add + * it in both cases. */ +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* Apply a threshold operation on the center pixel, where the threshold is currently hard-coded + * at 0.5. The pixels with values larger than the threshold are said to be masked. */ + bool is_center_masked = texture_load(input_tx, texel).x > 0.5; + + /* Since the distance search window will access pixels outside of the bounds of the image, we use + * a texture loader with a fallback value. And since we don't want those values to affect the + * result, the fallback value is chosen such that the inner condition fails, which is when the + * sampled pixel and the center pixel are the same, so choose a fallback that will be considered + * masked if the center pixel is masked and unmasked otherwise. */ + vec4 fallback = vec4(is_center_masked ? 1.0 : 0.0); + + /* Since the distance search window is limited to the given radius, the maximum possible squared + * distance to the center is double the squared radius. */ + int minimum_squared_distance = radius * radius * 2; + + /* Find the squared distance to the nearest different pixel in the search window of the given + * radius. */ + for (int y = -radius; y <= radius; y++) { + for (int x = -radius; x <= radius; x++) { + bool is_sample_masked = texture_load(input_tx, texel + ivec2(x, y), fallback).x > 0.5; + if (is_center_masked != is_sample_masked) { + minimum_squared_distance = min(minimum_squared_distance, x * x + y * y); + } + } + } + + /* Compute the actual distance from the squared distance and assign it an appropriate sign + * depending on whether it lies in a masked region or not. */ + float signed_minimum_distance = sqrt(minimum_squared_distance) * (is_center_masked ? 1.0 : -1.0); + + /* Add the erode/dilate distance and divide by the inset amount as described in the discussion, + * then clamp to the [0, 1] range. */ + float value = clamp((signed_minimum_distance + distance) / inset, 0.0, 1.0); + + imageStore(output_img, texel, vec4(value)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_step.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_step.glsl new file mode 100644 index 00000000000..6992bc2afa5 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_morphological_step.glsl @@ -0,0 +1,19 @@ +#pragma BLENDER_REQUIRE(common_math_lib.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* Find the minimum/maximum value in the window of the given radius around the pixel. This is + * essentially a morphological operator with a square structuring element. The LIMIT value should + * be FLT_MAX if OPERATOR is min and FLT_MIN if OPERATOR is max. */ + float value = LIMIT; + for (int i = -radius; i <= radius; i++) { + value = OPERATOR(value, texture_load(input_tx, texel + ivec2(i, 0), vec4(LIMIT)).x); + } + + /* Write the value using the transposed texel. See the execute_step_horizontal_pass method for + * more information on the rational behind this. */ + imageStore(output_img, texel.yx, vec4(value)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_normalize.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_normalize.glsl new file mode 100644 index 00000000000..53dfeb01730 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_normalize.glsl @@ -0,0 +1,10 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + float value = texture_load(input_tx, texel).x; + float normalized_value = (value - minimum) * scale; + float clamped_value = clamp(normalized_value, 0.0, 1.0); + imageStore(output_img, texel, vec4(clamped_value)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_parallel_reduction.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_parallel_reduction.glsl new file mode 100644 index 00000000000..f6f84aa24c1 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_parallel_reduction.glsl @@ -0,0 +1,98 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +/* This shader reduces the given texture into a smaller texture of a size equal to the number of + * work groups. In particular, each work group reduces its contents into a single value and writes + * that value to a single pixel in the output image. The shader can be dispatched multiple times to + * eventually reduce the image into a single pixel. + * + * The shader works by loading the whole data of each work group into a linear array, then it + * reduces the second half of the array onto the first half of the array, then it reduces the + * second quarter of the array onto the first quarter or the array, and so on until only one + * element remains. The following figure illustrates the process for sum reduction on 8 elements. + * + * .---. .---. .---. .---. .---. .---. .---. .---. + * | 0 | | 1 | | 2 | | 3 | | 4 | | 5 | | 6 | | 7 | Original data. + * '---' '---' '---' '---' '---' '---' '---' '---' + * |.____|_____|_____|_____| | | | + * || |.____|_____|___________| | | + * || || |.____|_________________| | + * || || || |.______________________| <--First reduction. Stride = 4. + * || || || || + * .---. .---. .---. .----. + * | 4 | | 6 | | 8 | | 10 | <--Data after first reduction. + * '---' '---' '---' '----' + * |.____|_____| | + * || |.__________| <--Second reduction. Stride = 2. + * || || + * .----. .----. + * | 12 | | 16 | <--Data after second reduction. + * '----' '----' + * |.____| + * || <--Third reduction. Stride = 1. + * .----. + * | 28 | + * '----' <--Data after third reduction. + * + * + * The shader is generic enough to implement many types of reductions. This is done by using macros + * that the developer should define to implement a certain reduction operation. Those include, + * TYPE, IDENTITY, INITIALIZE, LOAD, and REDUCE. See the implementation below for more information + * as well as the compositor_parallel_reduction_info.hh for example reductions operations. */ + +/* Doing the reduction in shared memory is faster, so create a shared array where the whole data + * of the work group will be loaded and reduced. The 2D structure of the work group is irrelevant + * for reduction, so we just load the data in a 1D array to simplify reduction. The developer is + * expected to define the TYPE macro to be a float or a vec4, depending on the type of data being + * reduced. */ +const uint reduction_size = gl_WorkGroupSize.x * gl_WorkGroupSize.y; +shared TYPE reduction_data[reduction_size]; + +void main() +{ + /* Load the data from the texture, while returning IDENTITY for out of bound coordinates. The + * developer is expected to define the IDENTITY macro to be a vec4 that does not affect the + * output of the reduction. For instance, sum reductions have an identity of vec4(0.0), while + * max value reductions have an identity of vec4(FLT_MIN). */ + vec4 value = texture_load(input_tx, ivec2(gl_GlobalInvocationID.xy), IDENTITY); + + /* Initialize the shared array given the previously loaded value. This step can be different + * depending on whether this is the initial reduction pass or a latter one. Indeed, the input + * texture for the initial reduction is the source texture itself, while the input texture to a + * latter reduction pass is an intermediate texture after one or more reductions have happened. + * This is significant because the data being reduced might be computed from the original data + * and different from it, for instance, when summing the luminance of an image, the original data + * is a vec4 color, while the reduced data is a float luminance value. So for the initial + * reduction pass, the luminance will be computed from the color, reduced, then stored into an + * intermediate float texture. On the other hand, for latter reduction passes, the luminance will + * be loaded directly and reduced without extra processing. So the developer is expected to + * define the INITIALIZE and LOAD macros to be expressions that derive the needed value from the + * loaded value for the initial reduction pass and latter ones respectively. */ + reduction_data[gl_LocalInvocationIndex] = is_initial_reduction ? INITIALIZE(value) : LOAD(value); + + /* Reduce the reduction data by half on every iteration until only one element remains. See the + * above figure for an intuitive understanding of the stride value. */ + for (uint stride = reduction_size / 2; stride > 0; stride /= 2) { + barrier(); + + /* Only the threads up to the current stride should be active as can be seen in the diagram + * above. */ + if (gl_LocalInvocationIndex >= stride) { + continue; + } + + /* Reduce each two elements that are stride apart, writing the result to the element with the + * lower index, as can be seen in the diagram above. The developer is expected to define the + * REDUCE macro to be a commutative and associative binary operator suitable for parallel + * reduction. */ + reduction_data[gl_LocalInvocationIndex] = REDUCE( + reduction_data[gl_LocalInvocationIndex], reduction_data[gl_LocalInvocationIndex + stride]); + } + + /* Finally, the result of the reduction is available as the first element in the reduction data, + * write it to the pixel corresponding to the work group, making sure only the one thread writes + * it. */ + barrier(); + if (gl_LocalInvocationIndex == 0) { + imageStore(output_img, ivec2(gl_WorkGroupID.xy), vec4(reduction_data[0])); + } +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_projector_lens_distortion.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_projector_lens_distortion.glsl new file mode 100644 index 00000000000..ab44dac93e6 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_projector_lens_distortion.glsl @@ -0,0 +1,16 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* Get the normalized coordinates of the pixel centers. */ + vec2 normalized_texel = (vec2(texel) + vec2(0.5)) / vec2(texture_size(input_tx)); + + /* Sample the red and blue channels shifted by the dispersion amount. */ + const float red = texture(input_tx, normalized_texel + vec2(dispersion, 0.0)).r; + const float green = texture_load(input_tx, texel).g; + const float blue = texture(input_tx, normalized_texel - vec2(dispersion, 0.0)).b; + + imageStore(output_img, texel, vec4(red, green, blue, 1.0)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_realize_on_domain.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_realize_on_domain.glsl new file mode 100644 index 00000000000..b8561e5f059 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_realize_on_domain.glsl @@ -0,0 +1,29 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* Add 0.5 to evaluate the input sampler at the center of the pixel. */ + vec2 coordinates = vec2(texel) + vec2(0.5); + + /* Transform the input image by transforming the domain coordinates with the inverse of input + * image's transformation. The inverse transformation is an affine matrix and thus the + * coordinates should be in homogeneous coordinates. */ + coordinates = (mat3(inverse_transformation) * vec3(coordinates, 1.0)).xy; + + /* Since an input image with an identity transformation is supposed to be centered in the domain, + * we subtract the offset between the lower left corners of the input image and the domain, which + * is half the difference between their sizes, because the difference in size is on both sides of + * the centered image. Additionally, we floor the offset to retain the 0.5 offset added above in + * case the difference in sizes was odd. */ + ivec2 domain_size = imageSize(domain_img); + ivec2 input_size = texture_size(input_tx); + vec2 offset = floor((domain_size - input_size) / 2.0); + + /* Subtract the offset and divide by the input image size to get the relevant coordinates into + * the sampler's expected [0, 1] range. */ + vec2 normalized_coordinates = (coordinates - offset) / input_size; + + imageStore(domain_img, texel, texture(input_tx, normalized_coordinates)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_screen_lens_distortion.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_screen_lens_distortion.glsl new file mode 100644 index 00000000000..dc572ea5aaf --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_screen_lens_distortion.glsl @@ -0,0 +1,151 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_hash.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +/* A model that approximates lens distortion parameterized by a distortion parameter and dependent + * on the squared distance to the center of the image. The distorted pixel is then computed as the + * scalar multiplication of the pixel coordinates with the value returned by this model. See the + * compute_distorted_uv function for more details. */ +float compute_distortion_scale(float distortion, float distance_squared) +{ + return 1.0 / (1.0 + sqrt(max(0.0, 1.0 - distortion * distance_squared))); +} + +/* A vectorized version of compute_distortion_scale that is applied on the chromatic distortion + * parameters passed to the shader. */ +vec3 compute_chromatic_distortion_scale(float distance_squared) +{ + return 1.0 / (1.0 + sqrt(max(vec3(0.0), 1.0 - chromatic_distortion * distance_squared))); +} + +/* Compute the image coordinates after distortion by the given distortion scale computed by the + * compute_distortion_scale function. Note that the function expects centered normalized UV + * coordinates but outputs non-centered image coordinates. */ +vec2 compute_distorted_uv(vec2 uv, float scale) +{ + return (uv * scale + 0.5) * texture_size(input_tx) - 0.5; +} + +/* Compute the number of integration steps that should be used to approximate the distorted pixel + * using a heuristic, see the compute_number_of_steps function for more details. The numbers of + * steps is proportional to the number of pixels spanned by the distortion amount. For jitter + * distortion, the square root of the distortion amount plus 1 is used with a minimum of 2 steps. + * For non-jitter distortion, the distortion amount plus 1 is used as the number of steps */ +int compute_number_of_integration_steps_heuristic(float distortion) +{ +#if defined(JITTER) + return distortion < 4.0 ? 2 : int(sqrt(distortion + 1.0)); +#else + return int(distortion + 1.0); +#endif +} + +/* Compute the number of integration steps that should be used to compute each channel of the + * distorted pixel. Each of the channels are distorted by their respective chromatic distortion + * amount, then the amount of distortion between each two consecutive channels is computed, this + * amount is then used to heuristically infer the number of needed integration steps, see the + * integrate_distortion function for more information. */ +ivec3 compute_number_of_integration_steps(vec2 uv, float distance_squared) +{ + /* Distort each channel by its respective chromatic distortion amount. */ + vec3 distortion_scale = compute_chromatic_distortion_scale(distance_squared); + vec2 distorted_uv_red = compute_distorted_uv(uv, distortion_scale.r); + vec2 distorted_uv_green = compute_distorted_uv(uv, distortion_scale.g); + vec2 distorted_uv_blue = compute_distorted_uv(uv, distortion_scale.b); + + /* Infer the number of needed integration steps to compute the distorted red channel starting + * from the green channel. */ + float distortion_red = distance(distorted_uv_red, distorted_uv_green); + int steps_red = compute_number_of_integration_steps_heuristic(distortion_red); + + /* Infer the number of needed integration steps to compute the distorted blue channel starting + * from the green channel. */ + float distortion_blue = distance(distorted_uv_green, distorted_uv_blue); + int steps_blue = compute_number_of_integration_steps_heuristic(distortion_blue); + + /* The number of integration steps used to compute the green channel is the sum of both the red + * and the blue channel steps because it is computed once with each of them. */ + return ivec3(steps_red, steps_red + steps_blue, steps_blue); +} + +/* Returns a random jitter amount, which is essentially a random value in the [0, 1] range. If + * jitter is not enabled, return a constant 0.5 value instead. */ +float get_jitter(int seed) +{ +#if defined(JITTER) + return hash_uint3_to_float(gl_GlobalInvocationID.x, gl_GlobalInvocationID.y, seed); +#else + return 0.5; +#endif +} + +/* Each color channel may have a different distortion with the guarantee that the red will have the + * lowest distortion while the blue will have the highest one. If each channel is distorted + * independently, the image will look disintegrated, with each channel seemingly merely shifted. + * Consequently, the distorted pixels needs to be computed by integrating along the path of change + * of distortion starting from one channel to another. For instance, to compute the distorted red + * from the distorted green, we accumulate the color of the distorted pixel starting from the + * distortion of the red, taking small steps until we reach the distortion of the green. The pixel + * color is weighted such that it is maximum at the start distortion and zero at the end distortion + * in an arithmetic progression. The integration steps can be augmented with random values to + * simulate lens jitter. Finally, it should be noted that this function integrates both the start + * and end channels in reverse directions for more efficient computation. */ +vec3 integrate_distortion(int start, int end, float distance_squared, vec2 uv, int steps) +{ + vec3 accumulated_color = vec3(0.0); + float distortion_amount = chromatic_distortion[end] - chromatic_distortion[start]; + for (int i = 0; i < steps; i++) { + /* The increment will be in the [0, 1) range across iterations. */ + float increment = (i + get_jitter(i)) / steps; + float distortion = chromatic_distortion[start] + increment * distortion_amount; + float distortion_scale = compute_distortion_scale(distortion, distance_squared); + + /* Sample the color at the distorted coordinates and accumulate it weighted by the increment + * value for both the start and end channels. */ + vec2 distorted_uv = compute_distorted_uv(uv, distortion_scale); + vec4 color = texture(input_tx, distorted_uv / texture_size(input_tx)); + accumulated_color[start] += (1.0 - increment) * color[start]; + accumulated_color[end] += increment * color[end]; + } + return accumulated_color; +} + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + /* Compute the UV image coordinates in the range [-1, 1] as well as the squared distance to the + * center of the image, which is at (0, 0) in the UV coordinates. */ + vec2 center = texture_size(input_tx) / 2.0; + vec2 uv = scale * (texel + 0.5 - center) / center; + float distance_squared = dot(uv, uv); + + /* If any of the color channels will get distorted outside of the screen beyond what is possible, + * write a zero transparent color and return. */ + if (any(greaterThan(chromatic_distortion * distance_squared, vec3(1.0)))) { + imageStore(output_img, texel, vec4(0.0)); + return; + } + + /* Compute the number of integration steps that should be used to compute each channel of the + * distorted pixel. */ + ivec3 number_of_steps = compute_number_of_integration_steps(uv, distance_squared); + + /* Integrate the distortion of the red and green, then the green and blue channels. That means + * the green will be integrated twice, but this is accounted for in the number of steps which the + * color will later be divided by. See the compute_number_of_integration_steps function for more + * details. */ + vec3 color = vec3(0.0); + color += integrate_distortion(0, 1, distance_squared, uv, number_of_steps.r); + color += integrate_distortion(1, 2, distance_squared, uv, number_of_steps.b); + + /* The integration above performed weighted accumulation, and thus the color needs to be divided + * by the sum of the weights. Assuming no jitter, the weights are generated as an arithmetic + * progression starting from (0.5 / n) to ((n - 0.5) / n) for n terms. The sum of an arithmetic + * progression can be computed as (n * (start + end) / 2), which when subsisting the start and + * end reduces to (n / 2). So the color should be multiplied by 2 / n. The jitter sequence + * approximately sums to the same value because it is a uniform random value whose mean value is + * 0.5, so the expression doesn't change regardless of jitter. */ + color *= 2.0 / vec3(number_of_steps); + + imageStore(output_img, texel, vec4(color, 1.0)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_set_alpha.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_set_alpha.glsl new file mode 100644 index 00000000000..7dd40581790 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_set_alpha.glsl @@ -0,0 +1,8 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + vec4 color = vec4(texture_load(image_tx, texel).rgb, texture_load(alpha_tx, texel).x); + imageStore(output_img, texel, color); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_split_viewer.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_split_viewer.glsl new file mode 100644 index 00000000000..866b9045da2 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_split_viewer.glsl @@ -0,0 +1,14 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); +#if defined(SPLIT_HORIZONTAL) + bool condition = (view_size.x * split_ratio) < texel.x; +#elif defined(SPLIT_VERTICAL) + bool condition = (view_size.y * split_ratio) < texel.y; +#endif + vec4 color = condition ? texture_load(first_image_tx, texel) : + texture_load(second_image_tx, texel); + imageStore(output_img, texel, color); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_symmetric_blur.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_symmetric_blur.glsl new file mode 100644 index 00000000000..df08991a35c --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_symmetric_blur.glsl @@ -0,0 +1,77 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_blur_common.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +vec4 load_input(ivec2 texel) +{ + vec4 color; + if (extend_bounds) { + /* If bounds are extended, then we treat the input as padded by a radius amount of pixels. So + * we load the input with an offset by the radius amount and fallback to a transparent color if + * it is out of bounds. Notice that we subtract 1 because the weights texture have an extra + * center weight, see the SymmetricBlurWeights for more information. */ + ivec2 blur_size = texture_size(weights_tx) - 1; + color = texture_load(input_tx, texel - blur_size, vec4(0.0)); + } + else { + color = texture_load(input_tx, texel); + } + + if (gamma_correct) { + color = gamma_correct_blur_input(color); + } + + return color; +} + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + vec4 accumulated_color = vec4(0.0); + + /* First, compute the contribution of the center pixel. */ + vec4 center_color = load_input(texel); + accumulated_color += center_color * texture_load(weights_tx, ivec2(0)).x; + + ivec2 weights_size = texture_size(weights_tx); + + /* Then, compute the contributions of the pixels along the x axis of the filter, noting that the + * weights texture only stores the weights for the positive half, but since the filter is + * symmetric, the same weight is used for the negative half and we add both of their + * contributions. */ + for (int x = 1; x < weights_size.x; x++) { + float weight = texture_load(weights_tx, ivec2(x, 0)).x; + accumulated_color += load_input(texel + ivec2(x, 0)) * weight; + accumulated_color += load_input(texel + ivec2(-x, 0)) * weight; + } + + /* Then, compute the contributions of the pixels along the y axis of the filter, noting that the + * weights texture only stores the weights for the positive half, but since the filter is + * symmetric, the same weight is used for the negative half and we add both of their + * contributions. */ + for (int y = 1; y < weights_size.y; y++) { + float weight = texture_load(weights_tx, ivec2(0, y)).x; + accumulated_color += load_input(texel + ivec2(0, y)) * weight; + accumulated_color += load_input(texel + ivec2(0, -y)) * weight; + } + + /* Finally, compute the contributions of the pixels in the four quadrants of the filter, noting + * that the weights texture only stores the weights for the upper right quadrant, but since the + * filter is symmetric, the same weight is used for the rest of the quadrants and we add all four + * of their contributions. */ + for (int y = 1; y < weights_size.y; y++) { + for (int x = 1; x < weights_size.x; x++) { + float weight = texture_load(weights_tx, ivec2(x, y)).x; + accumulated_color += load_input(texel + ivec2(x, y)) * weight; + accumulated_color += load_input(texel + ivec2(-x, y)) * weight; + accumulated_color += load_input(texel + ivec2(x, -y)) * weight; + accumulated_color += load_input(texel + ivec2(-x, -y)) * weight; + } + } + + if (gamma_correct) { + accumulated_color = gamma_uncorrect_blur_output(accumulated_color); + } + + imageStore(output_img, texel, accumulated_color); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_symmetric_separable_blur.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_symmetric_separable_blur.glsl new file mode 100644 index 00000000000..ab0c7baa787 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_symmetric_separable_blur.glsl @@ -0,0 +1,53 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_blur_common.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +vec4 load_input(ivec2 texel) +{ + vec4 color; + if (extend_bounds) { + /* If bounds are extended, then we treat the input as padded by a radius amount of pixels. So + * we load the input with an offset by the radius amount and fallback to a transparent color if + * it is out of bounds. Notice that we subtract 1 because the weights texture have an extra + * center weight, see the SymmetricSeparableBlurWeights for more information. */ + int blur_size = texture_size(weights_tx) - 1; + color = texture_load(input_tx, texel - ivec2(blur_size, 0), vec4(0.0)); + } + else { + color = texture_load(input_tx, texel); + } + + if (gamma_correct_input) { + color = gamma_correct_blur_input(color); + } + + return color; +} + +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + vec4 accumulated_color = vec4(0.0); + + /* First, compute the contribution of the center pixel. */ + vec4 center_color = load_input(texel); + accumulated_color += center_color * texture_load(weights_tx, 0).x; + + /* Then, compute the contributions of the pixel to the right and left, noting that the + * weights texture only stores the weights for the positive half, but since the filter is + * symmetric, the same weight is used for the negative half and we add both of their + * contributions. */ + for (int i = 1; i < texture_size(weights_tx); i++) { + float weight = texture_load(weights_tx, i).x; + accumulated_color += load_input(texel + ivec2(i, 0)) * weight; + accumulated_color += load_input(texel + ivec2(-i, 0)) * weight; + } + + if (gamma_uncorrect_output) { + accumulated_color = gamma_uncorrect_blur_output(accumulated_color); + } + + /* Write the color using the transposed texel. See the execute_separable_blur_horizontal_pass + * method for more information on the rational behind this. */ + imageStore(output_img, texel.yx, accumulated_color); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_tone_map_photoreceptor.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_tone_map_photoreceptor.glsl new file mode 100644 index 00000000000..167006585ca --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_tone_map_photoreceptor.glsl @@ -0,0 +1,22 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) + +/* Tone mapping based on equation (1) and the trilinear interpolation between equations (6) and (7) + * from Reinhard, Erik, and Kate Devlin. "Dynamic range reduction inspired by photoreceptor + * physiology." IEEE transactions on visualization and computer graphics 11.1 (2005): 13-24. */ +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + vec4 input_color = texture_load(input_tx, texel); + float input_luminance = dot(input_color.rgb, luminance_coefficients); + + /* Trilinear interpolation between equations (6) and (7) from Reinhard's 2005 paper. */ + vec4 local_adaptation_level = mix(vec4(input_luminance), input_color, chromatic_adaptation); + vec4 adaptation_level = mix(global_adaptation_level, local_adaptation_level, light_adaptation); + + /* Equation (1) from Reinhard's 2005 paper, assuming Vmax is 1. */ + vec4 semi_saturation = pow(intensity * adaptation_level, vec4(contrast)); + vec4 tone_mapped_color = input_color / (input_color + semi_saturation); + + imageStore(output_img, texel, vec4(tone_mapped_color.rgb, input_color.a)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/compositor_tone_map_simple.glsl b/source/blender/compositor/realtime_compositor/shaders/compositor_tone_map_simple.glsl new file mode 100644 index 00000000000..ce42d021dd1 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/compositor_tone_map_simple.glsl @@ -0,0 +1,26 @@ +#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) + +/* Tone mapping based on equation (3) from Reinhard, Erik, et al. "Photographic tone reproduction + * for digital images." Proceedings of the 29th annual conference on Computer graphics and + * interactive techniques. 2002. */ +void main() +{ + ivec2 texel = ivec2(gl_GlobalInvocationID.xy); + + vec4 input_color = texture_load(input_tx, texel); + + /* Equation (2) from Reinhard's 2002 paper. */ + vec4 scaled_color = input_color * luminance_scale; + + /* Equation (3) from Reinhard's 2002 paper, but with the 1 replaced with the blend factor for + * more flexibility. See ToneMapOperation::compute_luminance_scale_blend_factor. */ + vec4 denominator = luminance_scale_blend_factor + scaled_color; + vec4 tone_mapped_color = safe_divide(scaled_color, denominator); + + if (inverse_gamma != 0.0) { + tone_mapped_color = pow(max(tone_mapped_color, vec4(0.0)), vec4(inverse_gamma)); + } + + imageStore(output_img, texel, vec4(tone_mapped_color.rgb, input_color.a)); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_alpha_crop_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_alpha_crop_info.hh new file mode 100644 index 00000000000..11f2f329cd8 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_alpha_crop_info.hh @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_alpha_crop) + .local_group_size(16, 16) + .push_constant(Type::IVEC2, "lower_bound") + .push_constant(Type::IVEC2, "upper_bound") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_alpha_crop.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_bilateral_blur_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_bilateral_blur_info.hh new file mode 100644 index 00000000000..301cd6acd9e --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_bilateral_blur_info.hh @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_bilateral_blur) + .local_group_size(16, 16) + .push_constant(Type::INT, "radius") + .push_constant(Type::FLOAT, "threshold") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .sampler(1, ImageType::FLOAT_2D, "determinator_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_bilateral_blur.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_blur_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_blur_info.hh new file mode 100644 index 00000000000..36b772aa486 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_blur_info.hh @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_blur) + .local_group_size(16, 16) + .push_constant(Type::INT, "radius") + .push_constant(Type::BOOL, "extend_bounds") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .sampler(1, ImageType::FLOAT_2D, "weights_tx") + .sampler(2, ImageType::FLOAT_2D, "mask_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_blur.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_blur_variable_size_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_blur_variable_size_info.hh new file mode 100644 index 00000000000..05b6385fd1e --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_blur_variable_size_info.hh @@ -0,0 +1,15 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_blur_variable_size) + .local_group_size(16, 16) + .push_constant(Type::FLOAT, "base_size") + .push_constant(Type::INT, "search_radius") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .sampler(1, ImageType::FLOAT_2D, "weights_tx") + .sampler(2, ImageType::FLOAT_2D, "size_tx") + .sampler(3, ImageType::FLOAT_2D, "mask_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_blur_variable_size.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_bokeh_image_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_bokeh_image_info.hh new file mode 100644 index 00000000000..3541de53070 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_bokeh_image_info.hh @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_bokeh_image) + .local_group_size(16, 16) + .push_constant(Type::FLOAT, "exterior_angle") + .push_constant(Type::FLOAT, "rotation") + .push_constant(Type::FLOAT, "roundness") + .push_constant(Type::FLOAT, "catadioptric") + .push_constant(Type::FLOAT, "lens_shift") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_bokeh_image.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_box_mask_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_box_mask_info.hh new file mode 100644 index 00000000000..ecb253bbab1 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_box_mask_info.hh @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_box_mask_shared) + .local_group_size(16, 16) + .push_constant(Type::IVEC2, "domain_size") + .push_constant(Type::VEC2, "location") + .push_constant(Type::VEC2, "size") + .push_constant(Type::FLOAT, "cos_angle") + .push_constant(Type::FLOAT, "sin_angle") + .sampler(0, ImageType::FLOAT_2D, "base_mask_tx") + .sampler(1, ImageType::FLOAT_2D, "mask_value_tx") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_mask_img") + .compute_source("compositor_box_mask.glsl"); + +GPU_SHADER_CREATE_INFO(compositor_box_mask_add) + .additional_info("compositor_box_mask_shared") + .define("CMP_NODE_MASKTYPE_ADD") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_box_mask_subtract) + .additional_info("compositor_box_mask_shared") + .define("CMP_NODE_MASKTYPE_SUBTRACT") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_box_mask_multiply) + .additional_info("compositor_box_mask_shared") + .define("CMP_NODE_MASKTYPE_MULTIPLY") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_box_mask_not) + .additional_info("compositor_box_mask_shared") + .define("CMP_NODE_MASKTYPE_NOT") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_convert_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_convert_info.hh new file mode 100644 index 00000000000..35e60056736 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_convert_info.hh @@ -0,0 +1,69 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_convert_shared) + .local_group_size(16, 16) + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .typedef_source("gpu_shader_compositor_type_conversion.glsl") + .compute_source("compositor_convert.glsl"); + +GPU_SHADER_CREATE_INFO(compositor_convert_float_to_vector) + .additional_info("compositor_convert_shared") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("CONVERT_EXPRESSION(value)", "vec4(vec3_from_float(value.x), 0.0)") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_convert_float_to_color) + .additional_info("compositor_convert_shared") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("CONVERT_EXPRESSION(value)", "vec4_from_float(value.x)") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_convert_color_to_float) + .additional_info("compositor_convert_shared") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("CONVERT_EXPRESSION(value)", "vec4(float_from_vec4(value), vec3(0.0))") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_convert_color_to_vector) + .additional_info("compositor_convert_shared") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("CONVERT_EXPRESSION(value)", "vec4(vec3_from_vec4(value), 0.0)") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_convert_vector_to_float) + .additional_info("compositor_convert_shared") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("CONVERT_EXPRESSION(value)", "vec4(float_from_vec3(value.xyz), vec3(0.0))") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_convert_vector_to_color) + .additional_info("compositor_convert_shared") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("CONVERT_EXPRESSION(value)", "vec4_from_vec3(value.xyz)") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_extract_alpha_from_color) + .additional_info("compositor_convert_shared") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("CONVERT_EXPRESSION(value)", "vec4(value.a, vec3(0.0))") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_convert_color_to_half_color) + .additional_info("compositor_convert_shared") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("CONVERT_EXPRESSION(value)", "value") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_convert_float_to_half_float) + .additional_info("compositor_convert_shared") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("CONVERT_EXPRESSION(value)", "vec4(value.r, vec3(0.0))") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_convert_color_to_opaque) + .additional_info("compositor_convert_shared") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("CONVERT_EXPRESSION(value)", "vec4(value.rgb, 1.0)") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_despeckle_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_despeckle_info.hh new file mode 100644 index 00000000000..df86c3a8258 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_despeckle_info.hh @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_despeckle) + .local_group_size(16, 16) + .push_constant(Type::FLOAT, "threshold") + .push_constant(Type::FLOAT, "neighbor_threshold") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .sampler(1, ImageType::FLOAT_2D, "factor_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_despeckle.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_directional_blur_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_directional_blur_info.hh new file mode 100644 index 00000000000..bb9199dcd26 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_directional_blur_info.hh @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_directional_blur) + .local_group_size(16, 16) + .push_constant(Type::INT, "iterations") + .push_constant(Type::MAT4, "inverse_transformation") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_directional_blur.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_edge_filter_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_edge_filter_info.hh new file mode 100644 index 00000000000..916ec62bdba --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_edge_filter_info.hh @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_edge_filter) + .local_group_size(16, 16) + .push_constant(Type::MAT4, "kernel") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .sampler(1, ImageType::FLOAT_2D, "factor_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_edge_filter.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_ellipse_mask_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_ellipse_mask_info.hh new file mode 100644 index 00000000000..52db91c94e5 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_ellipse_mask_info.hh @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_shared) + .local_group_size(16, 16) + .push_constant(Type::IVEC2, "domain_size") + .push_constant(Type::VEC2, "location") + .push_constant(Type::VEC2, "radius") + .push_constant(Type::FLOAT, "cos_angle") + .push_constant(Type::FLOAT, "sin_angle") + .sampler(0, ImageType::FLOAT_2D, "base_mask_tx") + .sampler(1, ImageType::FLOAT_2D, "mask_value_tx") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_mask_img") + .compute_source("compositor_ellipse_mask.glsl"); + +GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_add) + .additional_info("compositor_ellipse_mask_shared") + .define("CMP_NODE_MASKTYPE_ADD") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_subtract) + .additional_info("compositor_ellipse_mask_shared") + .define("CMP_NODE_MASKTYPE_SUBTRACT") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_multiply) + .additional_info("compositor_ellipse_mask_shared") + .define("CMP_NODE_MASKTYPE_MULTIPLY") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_not) + .additional_info("compositor_ellipse_mask_shared") + .define("CMP_NODE_MASKTYPE_NOT") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_filter_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_filter_info.hh new file mode 100644 index 00000000000..9d565cf4b8a --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_filter_info.hh @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_filter) + .local_group_size(16, 16) + .push_constant(Type::MAT4, "kernel") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .sampler(1, ImageType::FLOAT_2D, "factor_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_filter.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_flip_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_flip_info.hh new file mode 100644 index 00000000000..db831518cb7 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_flip_info.hh @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_flip) + .local_group_size(16, 16) + .push_constant(Type::BOOL, "flip_x") + .push_constant(Type::BOOL, "flip_y") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_flip.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_image_crop_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_image_crop_info.hh new file mode 100644 index 00000000000..e7736744c40 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_image_crop_info.hh @@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_image_crop) + .local_group_size(16, 16) + .push_constant(Type::IVEC2, "lower_bound") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_image_crop.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_feather_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_feather_info.hh new file mode 100644 index 00000000000..9f17f60129d --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_feather_info.hh @@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_morphological_distance_feather_shared) + .local_group_size(16, 16) + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .sampler(1, ImageType::FLOAT_1D, "weights_tx") + .sampler(2, ImageType::FLOAT_1D, "falloffs_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_morphological_distance_feather.glsl"); + +GPU_SHADER_CREATE_INFO(compositor_morphological_distance_feather_dilate) + .additional_info("compositor_morphological_distance_feather_shared") + .define("COMPARE(x, y)", "x > y") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_morphological_distance_feather_erode) + .additional_info("compositor_morphological_distance_feather_shared") + .define("COMPARE(x, y)", "x < y") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_info.hh new file mode 100644 index 00000000000..fc960e119e5 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_info.hh @@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_morphological_distance_shared) + .local_group_size(16, 16) + .push_constant(Type::INT, "radius") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_morphological_distance.glsl"); + +GPU_SHADER_CREATE_INFO(compositor_morphological_distance_dilate) + .additional_info("compositor_morphological_distance_shared") + .define("OPERATOR(a, b)", "max(a, b)") + .define("LIMIT", "FLT_MIN") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_morphological_distance_erode) + .additional_info("compositor_morphological_distance_shared") + .define("OPERATOR(a, b)", "min(a, b)") + .define("LIMIT", "FLT_MAX") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_threshold_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_threshold_info.hh new file mode 100644 index 00000000000..b1d64f61b80 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_distance_threshold_info.hh @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_morphological_distance_threshold) + .local_group_size(16, 16) + .push_constant(Type::INT, "radius") + .push_constant(Type::INT, "distance") + .push_constant(Type::FLOAT, "inset") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_morphological_distance_threshold.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_step_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_step_info.hh new file mode 100644 index 00000000000..e97ffd9feea --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_morphological_step_info.hh @@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_morphological_step_shared) + .local_group_size(16, 16) + .push_constant(Type::INT, "radius") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_morphological_step.glsl"); + +GPU_SHADER_CREATE_INFO(compositor_morphological_step_dilate) + .additional_info("compositor_morphological_step_shared") + .define("OPERATOR(a, b)", "max(a, b)") + .define("LIMIT", "FLT_MIN") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_morphological_step_erode) + .additional_info("compositor_morphological_step_shared") + .define("OPERATOR(a, b)", "min(a, b)") + .define("LIMIT", "FLT_MAX") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_normalize_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_normalize_info.hh new file mode 100644 index 00000000000..02fdc424014 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_normalize_info.hh @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_normalize) + .local_group_size(16, 16) + .push_constant(Type::FLOAT, "minimum") + .push_constant(Type::FLOAT, "scale") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_normalize.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_parallel_reduction_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_parallel_reduction_info.hh new file mode 100644 index 00000000000..e2252b14758 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_parallel_reduction_info.hh @@ -0,0 +1,149 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_parallel_reduction_shared) + .local_group_size(16, 16) + .push_constant(Type::BOOL, "is_initial_reduction") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .compute_source("compositor_parallel_reduction.glsl"); + +/* -------------------------------------------------------------------- + * Sum Reductions. + */ + +GPU_SHADER_CREATE_INFO(compositor_sum_shared) + .additional_info("compositor_parallel_reduction_shared") + .define("IDENTITY", "vec4(0.0)") + .define("REDUCE(lhs, rhs)", "lhs + rhs"); + +GPU_SHADER_CREATE_INFO(compositor_sum_float_shared) + .additional_info("compositor_sum_shared") + .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("TYPE", "float") + .define("LOAD(value)", "value.x"); + +GPU_SHADER_CREATE_INFO(compositor_sum_red) + .additional_info("compositor_sum_float_shared") + .define("INITIALIZE(value)", "value.r") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_sum_green) + .additional_info("compositor_sum_float_shared") + .define("INITIALIZE(value)", "value.g") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_sum_blue) + .additional_info("compositor_sum_float_shared") + .define("INITIALIZE(value)", "value.b") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_sum_luminance) + .additional_info("compositor_sum_float_shared") + .push_constant(Type::VEC3, "luminance_coefficients") + .define("INITIALIZE(value)", "dot(value.rgb, luminance_coefficients)") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_sum_log_luminance) + .additional_info("compositor_sum_float_shared") + .push_constant(Type::VEC3, "luminance_coefficients") + .define("INITIALIZE(value)", "log(max(dot(value.rgb, luminance_coefficients), 1e-5))") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_sum_color) + .additional_info("compositor_sum_shared") + .image(0, GPU_RGBA32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .define("TYPE", "vec4") + .define("INITIALIZE(value)", "value") + .define("LOAD(value)", "value") + .do_static_compilation(true); + +/* -------------------------------------------------------------------- + * Sum Of Squared Difference Reductions. + */ + +GPU_SHADER_CREATE_INFO(compositor_sum_squared_difference_float_shared) + .additional_info("compositor_parallel_reduction_shared") + .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .push_constant(Type::FLOAT, "subtrahend") + .define("TYPE", "float") + .define("IDENTITY", "vec4(subtrahend)") + .define("LOAD(value)", "value.x") + .define("REDUCE(lhs, rhs)", "lhs + rhs"); + +GPU_SHADER_CREATE_INFO(compositor_sum_red_squared_difference) + .additional_info("compositor_sum_squared_difference_float_shared") + .define("INITIALIZE(value)", "pow(value.r - subtrahend, 2.0)") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_sum_green_squared_difference) + .additional_info("compositor_sum_squared_difference_float_shared") + .define("INITIALIZE(value)", "pow(value.g - subtrahend, 2.0)") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_sum_blue_squared_difference) + .additional_info("compositor_sum_squared_difference_float_shared") + .define("INITIALIZE(value)", "pow(value.b - subtrahend, 2.0)") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_sum_luminance_squared_difference) + .additional_info("compositor_sum_squared_difference_float_shared") + .push_constant(Type::VEC3, "luminance_coefficients") + .define("INITIALIZE(value)", "pow(dot(value.rgb, luminance_coefficients) - subtrahend, 2.0)") + .do_static_compilation(true); + +/* -------------------------------------------------------------------- + * Maximum Reductions. + */ + +GPU_SHADER_CREATE_INFO(compositor_maximum_luminance) + .additional_info("compositor_parallel_reduction_shared") + .typedef_source("common_math_lib.glsl") + .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .push_constant(Type::VEC3, "luminance_coefficients") + .define("TYPE", "float") + .define("IDENTITY", "vec4(FLT_MIN)") + .define("INITIALIZE(value)", "dot(value.rgb, luminance_coefficients)") + .define("LOAD(value)", "value.x") + .define("REDUCE(lhs, rhs)", "max(lhs, rhs)") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_maximum_float_in_range) + .additional_info("compositor_parallel_reduction_shared") + .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .push_constant(Type::FLOAT, "lower_bound") + .push_constant(Type::FLOAT, "upper_bound") + .define("TYPE", "float") + .define("IDENTITY", "vec4(lower_bound)") + .define("INITIALIZE(v)", "((v.x <= upper_bound) && (v.x >= lower_bound)) ? v.x : lower_bound") + .define("LOAD(value)", "value.x") + .define("REDUCE(lhs, rhs)", "((rhs > lhs) && (rhs <= upper_bound)) ? rhs : lhs") + .do_static_compilation(true); + +/* -------------------------------------------------------------------- + * Minimum Reductions. + */ + +GPU_SHADER_CREATE_INFO(compositor_minimum_luminance) + .additional_info("compositor_parallel_reduction_shared") + .typedef_source("common_math_lib.glsl") + .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .push_constant(Type::VEC3, "luminance_coefficients") + .define("TYPE", "float") + .define("IDENTITY", "vec4(FLT_MAX)") + .define("INITIALIZE(value)", "dot(value.rgb, luminance_coefficients)") + .define("LOAD(value)", "value.x") + .define("REDUCE(lhs, rhs)", "min(lhs, rhs)") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_minimum_float_in_range) + .additional_info("compositor_parallel_reduction_shared") + .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .push_constant(Type::FLOAT, "lower_bound") + .push_constant(Type::FLOAT, "upper_bound") + .define("TYPE", "float") + .define("IDENTITY", "vec4(upper_bound)") + .define("INITIALIZE(v)", "((v.x <= upper_bound) && (v.x >= lower_bound)) ? v.x : upper_bound") + .define("LOAD(value)", "value.x") + .define("REDUCE(lhs, rhs)", "((rhs < lhs) && (rhs >= lower_bound)) ? rhs : lhs") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_projector_lens_distortion_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_projector_lens_distortion_info.hh new file mode 100644 index 00000000000..98fe1731703 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_projector_lens_distortion_info.hh @@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_projector_lens_distortion) + .local_group_size(16, 16) + .push_constant(Type::FLOAT, "dispersion") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_projector_lens_distortion.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_realize_on_domain_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_realize_on_domain_info.hh new file mode 100644 index 00000000000..4528649ae98 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_realize_on_domain_info.hh @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_shared) + .local_group_size(16, 16) + .push_constant(Type::MAT4, "inverse_transformation") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .compute_source("compositor_realize_on_domain.glsl"); + +GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_color) + .additional_info("compositor_realize_on_domain_shared") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "domain_img") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_vector) + .additional_info("compositor_realize_on_domain_shared") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "domain_img") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_float) + .additional_info("compositor_realize_on_domain_shared") + .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "domain_img") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_screen_lens_distortion_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_screen_lens_distortion_info.hh new file mode 100644 index 00000000000..c42f2b328d4 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_screen_lens_distortion_info.hh @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_screen_lens_distortion_shared) + .local_group_size(16, 16) + .push_constant(Type::VEC3, "chromatic_distortion") + .push_constant(Type::FLOAT, "scale") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_screen_lens_distortion.glsl"); + +GPU_SHADER_CREATE_INFO(compositor_screen_lens_distortion) + .additional_info("compositor_screen_lens_distortion_shared") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_screen_lens_distortion_jitter) + .additional_info("compositor_screen_lens_distortion_shared") + .define("JITTER") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_set_alpha_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_set_alpha_info.hh new file mode 100644 index 00000000000..ca28194e921 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_set_alpha_info.hh @@ -0,0 +1,11 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_set_alpha) + .local_group_size(16, 16) + .sampler(0, ImageType::FLOAT_2D, "image_tx") + .sampler(1, ImageType::FLOAT_2D, "alpha_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_set_alpha.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_split_viewer_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_split_viewer_info.hh new file mode 100644 index 00000000000..d5793b0ce59 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_split_viewer_info.hh @@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_split_viewer_shared) + .local_group_size(16, 16) + .push_constant(Type::FLOAT, "split_ratio") + .push_constant(Type::IVEC2, "view_size") + .sampler(0, ImageType::FLOAT_2D, "first_image_tx") + .sampler(1, ImageType::FLOAT_2D, "second_image_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_split_viewer.glsl"); + +GPU_SHADER_CREATE_INFO(compositor_split_viewer_horizontal) + .additional_info("compositor_split_viewer_shared") + .define("SPLIT_HORIZONTAL") + .do_static_compilation(true); + +GPU_SHADER_CREATE_INFO(compositor_split_viewer_vertical) + .additional_info("compositor_split_viewer_shared") + .define("SPLIT_VERTICAL") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_symmetric_blur_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_symmetric_blur_info.hh new file mode 100644 index 00000000000..8ba2b4e04ef --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_symmetric_blur_info.hh @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_symmetric_blur) + .local_group_size(16, 16) + .push_constant(Type::BOOL, "extend_bounds") + .push_constant(Type::BOOL, "gamma_correct") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .sampler(1, ImageType::FLOAT_2D, "weights_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_symmetric_blur.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_symmetric_separable_blur_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_symmetric_separable_blur_info.hh new file mode 100644 index 00000000000..57247dba4b8 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_symmetric_separable_blur_info.hh @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_symmetric_separable_blur) + .local_group_size(16, 16) + .push_constant(Type::BOOL, "extend_bounds") + .push_constant(Type::BOOL, "gamma_correct_input") + .push_constant(Type::BOOL, "gamma_uncorrect_output") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .sampler(1, ImageType::FLOAT_1D, "weights_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_symmetric_separable_blur.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_tone_map_photoreceptor_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_tone_map_photoreceptor_info.hh new file mode 100644 index 00000000000..a460c9d58a6 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_tone_map_photoreceptor_info.hh @@ -0,0 +1,16 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_tone_map_photoreceptor) + .local_group_size(16, 16) + .push_constant(Type::VEC4, "global_adaptation_level") + .push_constant(Type::FLOAT, "contrast") + .push_constant(Type::FLOAT, "intensity") + .push_constant(Type::FLOAT, "chromatic_adaptation") + .push_constant(Type::FLOAT, "light_adaptation") + .push_constant(Type::VEC3, "luminance_coefficients") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_tone_map_photoreceptor.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/infos/compositor_tone_map_simple_info.hh b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_tone_map_simple_info.hh new file mode 100644 index 00000000000..2b220af9460 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/infos/compositor_tone_map_simple_info.hh @@ -0,0 +1,13 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "gpu_shader_create_info.hh" + +GPU_SHADER_CREATE_INFO(compositor_tone_map_simple) + .local_group_size(16, 16) + .push_constant(Type::FLOAT, "luminance_scale") + .push_constant(Type::FLOAT, "luminance_scale_blend_factor") + .push_constant(Type::FLOAT, "inverse_gamma") + .sampler(0, ImageType::FLOAT_2D, "input_tx") + .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") + .compute_source("compositor_tone_map_simple.glsl") + .do_static_compilation(true); diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_alpha_over.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_alpha_over.glsl new file mode 100644 index 00000000000..8e3e033147f --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_alpha_over.glsl @@ -0,0 +1,48 @@ +void node_composite_alpha_over_mixed( + float factor, vec4 color, vec4 over_color, float premultiply_factor, out vec4 result) +{ + if (over_color.a <= 0.0) { + result = color; + } + else if (factor == 1.0 && over_color.a >= 1.0) { + result = over_color; + } + else { + float add_factor = 1.0 - premultiply_factor + over_color.a * premultiply_factor; + float premultiplier = factor * add_factor; + float multiplier = 1.0 - factor * over_color.a; + + result = multiplier * color + vec2(premultiplier, factor).xxxy * over_color; + } +} + +void node_composite_alpha_over_key(float factor, vec4 color, vec4 over_color, out vec4 result) +{ + if (over_color.a <= 0.0) { + result = color; + } + else if (factor == 1.0 && over_color.a >= 1.0) { + result = over_color; + } + else { + result = mix(color, vec4(over_color.rgb, 1.0), factor * over_color.a); + } +} + +void node_composite_alpha_over_premultiply(float factor, + vec4 color, + vec4 over_color, + out vec4 result) +{ + if (over_color.a < 0.0) { + result = color; + } + else if (factor == 1.0 && over_color.a >= 1.0) { + result = over_color; + } + else { + float multiplier = 1.0 - factor * over_color.a; + + result = multiplier * color + factor * over_color; + } +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_blur_common.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_blur_common.glsl new file mode 100644 index 00000000000..e404c03bbb0 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_blur_common.glsl @@ -0,0 +1,32 @@ +/* Preprocess the input of the blur filter by squaring it in its alpha straight form, assuming the + * given color is alpha premultiplied. */ +vec4 gamma_correct_blur_input(vec4 color) +{ + /* Unpremultiply alpha. */ + color.rgb /= color.a > 0.0 ? color.a : 1.0; + + /* Square color channel if it is positive, otherwise zero it. */ + color.rgb *= mix(color.rgb, vec3(0.0), lessThan(color.rgb, vec3(0.0))); + + /* Premultiply alpha to undo previous alpha unpremultiplication. */ + color.rgb *= color.a > 0.0 ? color.a : 1.0; + + return color; +} + +/* Postprocess the output of the blur filter by taking its square root it in its alpha straight + * form, assuming the given color is alpha premultiplied. This essential undoes the processing done + * by the gamma_correct_blur_input function. */ +vec4 gamma_uncorrect_blur_output(vec4 color) +{ + /* Unpremultiply alpha. */ + color.rgb /= color.a > 0.0 ? color.a : 1.0; + + /* Take the square root of the color channel if it is positive, otherwise zero it. */ + color.rgb = mix(sqrt(color.rgb), vec3(0.0), lessThan(color.rgb, vec3(0.0))); + + /* Premultiply alpha to undo previous alpha unpremultiplication. */ + color.rgb *= color.a > 0.0 ? color.a : 1.0; + + return color; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_bright_contrast.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_bright_contrast.glsl new file mode 100644 index 00000000000..ce71b4fd8a4 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_bright_contrast.glsl @@ -0,0 +1,38 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +/* The algorithm is by Werner D. Streidt + * (http://visca.com/ffactory/archives/5-99/msg00021.html) + * Extracted of OpenCV demhist.c + */ + +#define FLT_EPSILON 1.192092896e-07F + +void node_composite_bright_contrast( + vec4 color, float brightness, float contrast, const float use_premultiply, out vec4 result) +{ + brightness /= 100.0; + float delta = contrast / 200.0; + + float multiplier, offset; + if (contrast > 0.0) { + multiplier = 1.0 - delta * 2.0; + multiplier = 1.0 / max(multiplier, FLT_EPSILON); + offset = multiplier * (brightness - delta); + } + else { + delta *= -1.0; + multiplier = max(1.0 - delta * 2.0, 0.0); + offset = multiplier * brightness + delta; + } + + if (use_premultiply != 0.0) { + color_alpha_unpremultiply(color, color); + } + + result.rgb = color.rgb * multiplier + offset; + result.a = color.a; + + if (use_premultiply != 0.0) { + color_alpha_premultiply(result, result); + } +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_channel_matte.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_channel_matte.glsl new file mode 100644 index 00000000000..f2dcc9543f2 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_channel_matte.glsl @@ -0,0 +1,52 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +#define CMP_NODE_CHANNEL_MATTE_CS_RGB 1.0 +#define CMP_NODE_CHANNEL_MATTE_CS_HSV 2.0 +#define CMP_NODE_CHANNEL_MATTE_CS_YUV 3.0 +#define CMP_NODE_CHANNEL_MATTE_CS_YCC 4.0 + +void node_composite_channel_matte(vec4 color, + const float color_space, + const float matte_channel, + const vec2 limit_channels, + float max_limit, + float min_limit, + out vec4 result, + out float matte) +{ + vec4 channels; + if (color_space == CMP_NODE_CHANNEL_MATTE_CS_HSV) { + rgb_to_hsv(color, channels); + } + else if (color_space == CMP_NODE_CHANNEL_MATTE_CS_YUV) { + rgba_to_yuva_itu_709(color, channels); + } + else if (color_space == CMP_NODE_CHANNEL_MATTE_CS_YCC) { + rgba_to_ycca_itu_709(color, channels); + } + else { + channels = color; + } + + float matte_value = channels[int(matte_channel)]; + float limit_value = max(channels[int(limit_channels.x)], channels[int(limit_channels.y)]); + + float alpha = 1.0 - (matte_value - limit_value); + if (alpha > max_limit) { + alpha = color.a; + } + else if (alpha < min_limit) { + alpha = 0.0; + } + else { + alpha = (alpha - min_limit) / (max_limit - min_limit); + } + + matte = min(alpha, color.a); + result = color * matte; +} + +#undef CMP_NODE_CHANNEL_MATTE_CS_RGB +#undef CMP_NODE_CHANNEL_MATTE_CS_HSV +#undef CMP_NODE_CHANNEL_MATTE_CS_YUV +#undef CMP_NODE_CHANNEL_MATTE_CS_YCC diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_chroma_matte.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_chroma_matte.glsl new file mode 100644 index 00000000000..5d6bea0c9db --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_chroma_matte.glsl @@ -0,0 +1,43 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +/* Algorithm from the book Video Demystified. Chapter 7. Chroma Keying. */ +void node_composite_chroma_matte(vec4 color, + vec4 key, + float acceptance, + float cutoff, + float falloff, + out vec4 result, + out float matte) +{ + vec4 color_ycca; + rgba_to_ycca_itu_709(color, color_ycca); + vec4 key_ycca; + rgba_to_ycca_itu_709(key, key_ycca); + + /* Normalize the CrCb components into the [-1, 1] range. */ + vec2 color_cc = color_ycca.yz * 2.0 - 1.0; + vec2 key_cc = key_ycca.yz * 2.0 - 1.0; + + /* Rotate the color onto the space of the key such that x axis of the color space passes through + * the key color. */ + color_cc = vector_to_rotation_matrix(key_cc * vec2(1.0, -1.0)) * color_cc; + + /* Compute foreground key. If positive, the value is in the [0, 1] range. */ + float foreground_key = color_cc.x - (abs(color_cc.y) / acceptance); + + /* Negative foreground key values retain the original alpha. Positive values are scaled by the + * falloff, while colors that make an angle less than the cutoff angle get a zero alpha. */ + float alpha = color.a; + if (foreground_key > 0.0) { + alpha = 1.0 - (foreground_key / falloff); + + if (abs(atan(color_cc.y, color_cc.x)) < (cutoff / 2.0)) { + alpha = 0.0; + } + } + + /* Compute output. */ + matte = min(alpha, color.a); + result = color * matte; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_balance.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_balance.glsl new file mode 100644 index 00000000000..bffb94cdedb --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_balance.glsl @@ -0,0 +1,34 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +void node_composite_color_balance_lgg( + float factor, vec4 color, vec3 lift, vec3 gamma, vec3 gain, out vec4 result) +{ + lift = 2.0 - lift; + vec3 srgb_color = linear_rgb_to_srgb(color.rgb); + vec3 lift_balanced = ((srgb_color - 1.0) * lift) + 1.0; + + vec3 gain_balanced = lift_balanced * gain; + gain_balanced = max(gain_balanced, vec3(0.0)); + + vec3 linear_color = srgb_to_linear_rgb(gain_balanced); + gamma = mix(gamma, vec3(1e-6), equal(gamma, vec3(0.0))); + vec3 gamma_balanced = pow(linear_color, 1.0 / gamma); + + result.rgb = mix(color.rgb, gamma_balanced, min(factor, 1.0)); + result.a = color.a; +} + +void node_composite_color_balance_asc_cdl(float factor, + vec4 color, + vec3 offset, + vec3 power, + vec3 slope, + float offset_basis, + out vec4 result) +{ + offset += offset_basis; + vec3 balanced = color.rgb * slope + offset; + balanced = pow(max(balanced, vec3(0.0)), power); + result.rgb = mix(color.rgb, balanced, min(factor, 1.0)); + result.a = color.a; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_correction.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_correction.glsl new file mode 100644 index 00000000000..9b4858f03be --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_correction.glsl @@ -0,0 +1,87 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +void node_composite_color_correction(vec4 color, + float mask, + const vec3 enabled_channels, + float start_midtones, + float end_midtones, + float master_saturation, + float master_contrast, + float master_gamma, + float master_gain, + float master_lift, + float shadows_saturation, + float shadows_contrast, + float shadows_gamma, + float shadows_gain, + float shadows_lift, + float midtones_saturation, + float midtones_contrast, + float midtones_gamma, + float midtones_gain, + float midtones_lift, + float highlights_saturation, + float highlights_contrast, + float highlights_gamma, + float highlights_gain, + float highlights_lift, + const vec3 luminance_coefficients, + out vec4 result) +{ + const float margin = 0.10; + const float margin_divider = 0.5 / margin; + float level = (color.r + color.g + color.b) / 3.0; + float level_shadows = 0.0; + float level_midtones = 0.0; + float level_highlights = 0.0; + if (level < (start_midtones - margin)) { + level_shadows = 1.0; + } + else if (level < (start_midtones + margin)) { + level_midtones = ((level - start_midtones) * margin_divider) + 0.5; + level_shadows = 1.0 - level_midtones; + } + else if (level < (end_midtones - margin)) { + level_midtones = 1.0; + } + else if (level < (end_midtones + margin)) { + level_highlights = ((level - end_midtones) * margin_divider) + 0.5; + level_midtones = 1.0 - level_highlights; + } + else { + level_highlights = 1.0; + } + + float contrast = level_shadows * shadows_contrast; + contrast += level_midtones * midtones_contrast; + contrast += level_highlights * highlights_contrast; + contrast *= master_contrast; + float saturation = level_shadows * shadows_saturation; + saturation += level_midtones * midtones_saturation; + saturation += level_highlights * highlights_saturation; + saturation *= master_saturation; + float gamma = level_shadows * shadows_gamma; + gamma += level_midtones * midtones_gamma; + gamma += level_highlights * highlights_gamma; + gamma *= master_gamma; + float gain = level_shadows * shadows_gain; + gain += level_midtones * midtones_gain; + gain += level_highlights * highlights_gain; + gain *= master_gain; + float lift = level_shadows * shadows_lift; + lift += level_midtones * midtones_lift; + lift += level_highlights * highlights_lift; + lift += master_lift; + + float inverse_gamma = 1.0 / gamma; + float luma = get_luminance(color.rgb, luminance_coefficients); + + vec3 corrected = luma + saturation * (color.rgb - luma); + corrected = 0.5 + (corrected - 0.5) * contrast; + corrected = fallback_pow(corrected * gain + lift, inverse_gamma, corrected); + corrected = mix(color.rgb, corrected, min(mask, 1.0)); + + result.rgb = mix(corrected, color.rgb, equal(enabled_channels, vec3(0.0))); + result.a = color.a; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_matte.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_matte.glsl new file mode 100644 index 00000000000..038471bc1bc --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_matte.glsl @@ -0,0 +1,27 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +void node_composite_color_matte(vec4 color, + vec4 key, + float hue_epsilon, + float saturation_epsilon, + float value_epsilon, + out vec4 result, + out float matte) + +{ + vec4 color_hsva; + rgb_to_hsv(color, color_hsva); + vec4 key_hsva; + rgb_to_hsv(key, key_hsva); + + bool is_within_saturation = distance(color_hsva.y, key_hsva.y) < saturation_epsilon; + bool is_within_value = distance(color_hsva.z, key_hsva.z) < value_epsilon; + bool is_within_hue = distance(color_hsva.x, key_hsva.x) < hue_epsilon; + /* Hue wraps around, so check the distance around the boundary. */ + float min_hue = min(color_hsva.x, key_hsva.x); + float max_hue = max(color_hsva.x, key_hsva.x); + is_within_hue = is_within_hue || ((min_hue + (1.0 - max_hue)) < hue_epsilon); + + matte = (is_within_hue && is_within_saturation && is_within_value) ? 0.0 : color.a; + result = color * matte; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_spill.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_spill.glsl new file mode 100644 index 00000000000..0adad53ad80 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_spill.glsl @@ -0,0 +1,13 @@ +void node_composite_color_spill(vec4 color, + float factor, + const float spill_channel, + vec3 spill_scale, + const vec2 limit_channels, + float limit_scale, + out vec4 result) +{ + float average_limit = (color[int(limit_channels.x)] + color[int(limit_channels.y)]) / 2.0; + float map = factor * color[int(spill_channel)] - limit_scale * average_limit; + result.rgb = map > 0.0 ? color.rgb + spill_scale * map : color.rgb; + result.a = color.a; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_to_luminance.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_to_luminance.glsl new file mode 100644 index 00000000000..bcdd625bd4f --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_color_to_luminance.glsl @@ -0,0 +1,6 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +void color_to_luminance(vec4 color, const vec3 luminance_coefficients, out float result) +{ + result = get_luminance(color.rgb, luminance_coefficients); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_difference_matte.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_difference_matte.glsl new file mode 100644 index 00000000000..d769cadce3c --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_difference_matte.glsl @@ -0,0 +1,10 @@ +void node_composite_difference_matte( + vec4 color, vec4 key, float tolerance, float falloff, out vec4 result, out float matte) +{ + vec4 difference = abs(color - key); + float average_difference = (difference.r + difference.g + difference.b) / 3.0; + bool is_opaque = average_difference > tolerance + falloff; + float alpha = is_opaque ? color.a : (max(0.0, average_difference - tolerance) / falloff); + matte = min(alpha, color.a); + result = color * matte; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_distance_matte.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_distance_matte.glsl new file mode 100644 index 00000000000..9beed66826c --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_distance_matte.glsl @@ -0,0 +1,26 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +void node_composite_distance_matte_rgba( + vec4 color, vec4 key, float tolerance, float falloff, out vec4 result, out float matte) +{ + float difference = distance(color.rgb, key.rgb); + bool is_opaque = difference > tolerance + falloff; + float alpha = is_opaque ? color.a : max(0.0, difference - tolerance) / falloff; + matte = min(alpha, color.a); + result = color * matte; +} + +void node_composite_distance_matte_ycca( + vec4 color, vec4 key, float tolerance, float falloff, out vec4 result, out float matte) +{ + vec4 color_ycca; + rgba_to_ycca_itu_709(color, color_ycca); + vec4 key_ycca; + rgba_to_ycca_itu_709(key, key_ycca); + + float difference = distance(color_ycca.yz, key_ycca.yz); + bool is_opaque = difference > tolerance + falloff; + float alpha = is_opaque ? color.a : max(0.0, difference - tolerance) / falloff; + matte = min(alpha, color.a); + result = color * matte; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_exposure.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_exposure.glsl new file mode 100644 index 00000000000..f246635a91e --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_exposure.glsl @@ -0,0 +1,6 @@ +void node_composite_exposure(vec4 color, float exposure, out vec4 result) +{ + float multiplier = exp2(exposure); + result.rgb = color.rgb * multiplier; + result.a = color.a; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_gamma.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_gamma.glsl new file mode 100644 index 00000000000..53070d4b0e2 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_gamma.glsl @@ -0,0 +1,7 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) + +void node_composite_gamma(vec4 color, float gamma, out vec4 result) +{ + result.rgb = fallback_pow(color.rgb, gamma, color.rgb); + result.a = color.a; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_hue_correct.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_hue_correct.glsl new file mode 100644 index 00000000000..99eb125cdf2 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_hue_correct.glsl @@ -0,0 +1,39 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +/* Curve maps are stored in sampler objects that are evaluated in the [0, 1] range, so normalize + * parameters accordingly. */ +#define NORMALIZE_PARAMETER(parameter, minimum, range) ((parameter - minimum) * range) + +void node_composite_hue_correct(float factor, + vec4 color, + sampler1DArray curve_map, + const float layer, + vec3 minimums, + vec3 range_dividers, + out vec4 result) +{ + vec4 hsv; + rgb_to_hsv(color, hsv); + + /* First, adjust the hue channel on its own, since corrections in the saturation and value + * channels depends on the new value of the hue, not its original value. A curve map value of 0.5 + * means no change in hue, so adjust the value to get an identity at 0.5. Since the identity of + * addition is 0, we subtract 0.5 (0.5 - 0.5 = 0). */ + const float hue_parameter = NORMALIZE_PARAMETER(hsv.x, minimums.x, range_dividers.x); + hsv.x += texture(curve_map, vec2(hue_parameter, layer)).x - 0.5; + + /* Second, adjust the saturation and value based on the new value of the hue. A curve map value + * of 0.5 means no change in hue, so adjust the value to get an identity at 0.5. Since the + * identity of duplication is 1, we multiply by 2 (0.5 * 2 = 1). */ + vec2 parameters = NORMALIZE_PARAMETER(hsv.x, minimums.yz, range_dividers.yz); + hsv.y *= texture(curve_map, vec2(parameters.x, layer)).y * 2.0; + hsv.z *= texture(curve_map, vec2(parameters.y, layer)).z * 2.0; + + /* Sanitize the new hue and saturation values. */ + hsv.x = fract(hsv.x); + hsv.y = clamp(hsv.y, 0.0, 1.0); + + hsv_to_rgb(hsv, result); + + result = mix(color, result, factor); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_hue_saturation_value.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_hue_saturation_value.glsl new file mode 100644 index 00000000000..dd5eb33d318 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_hue_saturation_value.glsl @@ -0,0 +1,16 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +void node_composite_hue_saturation_value( + vec4 color, float hue, float saturation, float value, float factor, out vec4 result) +{ + vec4 hsv; + rgb_to_hsv(color, hsv); + + hsv.x = fract(hsv.x + hue + 0.5); + hsv.y = clamp(hsv.y * saturation, 0.0, 1.0); + hsv.z = hsv.z * value; + + hsv_to_rgb(hsv, result); + + result = mix(color, result, factor); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_invert.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_invert.glsl new file mode 100644 index 00000000000..59be746da7f --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_invert.glsl @@ -0,0 +1,13 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +void node_composite_invert(float fac, vec4 color, float do_rgb, float do_alpha, out vec4 result) +{ + result = color; + if (do_rgb != 0.0) { + result.rgb = 1.0 - result.rgb; + } + if (do_alpha != 0.0) { + result.a = 1.0 - result.a; + } + result = mix(color, result, fac); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_luminance_matte.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_luminance_matte.glsl new file mode 100644 index 00000000000..3647ac583fe --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_luminance_matte.glsl @@ -0,0 +1,14 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +void node_composite_luminance_matte(vec4 color, + float high, + float low, + const vec3 luminance_coefficients, + out vec4 result, + out float matte) +{ + float luminance = get_luminance(color.rgb, luminance_coefficients); + float alpha = clamp(0.0, 1.0, (luminance - low) / (high - low)); + matte = min(alpha, color.a); + result = color * matte; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_main.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_main.glsl new file mode 100644 index 00000000000..27624223dbc --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_main.glsl @@ -0,0 +1,7 @@ +/* The compute shader that will be dispatched by the compositor ShaderOperation. It just calls the + * evaluate function that will be dynamically generated and appended to this shader in the + * ShaderOperation::generate_code method. */ +void main() +{ + evaluate(); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_map_value.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_map_value.glsl new file mode 100644 index 00000000000..20874b4ef44 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_map_value.glsl @@ -0,0 +1,56 @@ +/* An arbitrary value determined by Blender. */ +#define BLENDER_ZMAX 10000.0 + +void node_composite_map_range(float value, + float from_min, + float from_max, + float to_min, + float to_max, + const float should_clamp, + out float result) +{ + if (abs(from_max - from_min) < 1e-6) { + result = 0.0; + } + else { + if (value >= -BLENDER_ZMAX && value <= BLENDER_ZMAX) { + result = (value - from_min) / (from_max - from_min); + result = to_min + result * (to_max - to_min); + } + else if (value > BLENDER_ZMAX) { + result = to_max; + } + else { + result = to_min; + } + + if (should_clamp != 0.0) { + if (to_max > to_min) { + result = clamp(result, to_min, to_max); + } + else { + result = clamp(result, to_max, to_min); + } + } + } +} + +void node_composite_map_value(float value, + float offset, + float size, + const float use_min, + float min, + const float use_max, + float max, + out float result) +{ + result = (value + offset) * size; + + if (use_min != 0.0 && result < min) { + result = min; + } + + if (use_max != 0.0 && result > max) { + result = max; + } +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_normal.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_normal.glsl new file mode 100644 index 00000000000..a2e3b6c4aaa --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_normal.glsl @@ -0,0 +1,9 @@ +void node_composite_normal(vec3 input_vector, + vec3 input_normal, + out vec3 result_normal, + out float result_dot) +{ + vec3 normal = normalize(input_normal); + result_normal = normal; + result_dot = -dot(input_vector, normal); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_posterize.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_posterize.glsl new file mode 100644 index 00000000000..ee8ae234abe --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_posterize.glsl @@ -0,0 +1,6 @@ +void node_composite_posterize(vec4 color, float steps, out vec4 result) +{ + steps = clamp(steps, 2.0, 1024.0); + result = floor(color * steps) / steps; + result.a = color.a; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_separate_combine.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_separate_combine.glsl new file mode 100644 index 00000000000..d72d2260394 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_separate_combine.glsl @@ -0,0 +1,132 @@ +#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) + +/* ** Combine/Separate XYZ ** */ + +void node_composite_combine_xyz(float x, float y, float z, out vec3 vector) +{ + vector = vec3(x, y, z); +} + +void node_composite_separate_xyz(vec3 vector, out float x, out float y, out float z) +{ + x = vector.x; + y = vector.y; + z = vector.z; +} + +/* ** Combine/Separate RGBA ** */ + +void node_composite_combine_rgba(float r, float g, float b, float a, out vec4 color) +{ + color = vec4(r, g, b, a); +} + +void node_composite_separate_rgba(vec4 color, out float r, out float g, out float b, out float a) +{ + r = color.r; + g = color.g; + b = color.b; + a = color.a; +} + +/* ** Combine/Separate HSVA ** */ + +void node_composite_combine_hsva(float h, float s, float v, float a, out vec4 color) +{ + hsv_to_rgb(vec4(h, s, v, a), color); +} + +void node_composite_separate_hsva(vec4 color, out float h, out float s, out float v, out float a) +{ + vec4 hsva; + rgb_to_hsv(color, hsva); + h = hsva.x; + s = hsva.y; + v = hsva.z; + a = hsva.a; +} + +/* ** Combine/Separate HSLA ** */ + +void node_composite_combine_hsla(float h, float s, float l, float a, out vec4 color) +{ + hsl_to_rgb(vec4(h, s, l, a), color); +} + +void node_composite_separate_hsla(vec4 color, out float h, out float s, out float l, out float a) +{ + vec4 hsla; + rgb_to_hsl(color, hsla); + h = hsla.x; + s = hsla.y; + l = hsla.z; + a = hsla.a; +} + +/* ** Combine/Separate YCCA ** */ + +void node_composite_combine_ycca_itu_601(float y, float cb, float cr, float a, out vec4 color) +{ + ycca_to_rgba_itu_601(vec4(y, cb, cr, a), color); +} + +void node_composite_combine_ycca_itu_709(float y, float cb, float cr, float a, out vec4 color) +{ + ycca_to_rgba_itu_709(vec4(y, cb, cr, a), color); +} + +void node_composite_combine_ycca_jpeg(float y, float cb, float cr, float a, out vec4 color) +{ + ycca_to_rgba_jpeg(vec4(y, cb, cr, a), color); +} + +void node_composite_separate_ycca_itu_601( + vec4 color, out float y, out float cb, out float cr, out float a) +{ + vec4 ycca; + rgba_to_ycca_itu_601(color, ycca); + y = ycca.x; + cb = ycca.y; + cr = ycca.z; + a = ycca.a; +} + +void node_composite_separate_ycca_itu_709( + vec4 color, out float y, out float cb, out float cr, out float a) +{ + vec4 ycca; + rgba_to_ycca_itu_709(color, ycca); + y = ycca.x; + cb = ycca.y; + cr = ycca.z; + a = ycca.a; +} + +void node_composite_separate_ycca_jpeg( + vec4 color, out float y, out float cb, out float cr, out float a) +{ + vec4 ycca; + rgba_to_ycca_jpeg(color, ycca); + y = ycca.x; + cb = ycca.y; + cr = ycca.z; + a = ycca.a; +} + +/* ** Combine/Separate YUVA ** */ + +void node_composite_combine_yuva_itu_709(float y, float u, float v, float a, out vec4 color) +{ + yuva_to_rgba_itu_709(vec4(y, u, v, a), color); +} + +void node_composite_separate_yuva_itu_709( + vec4 color, out float y, out float u, out float v, out float a) +{ + vec4 yuva; + rgba_to_yuva_itu_709(color, yuva); + y = yuva.x; + u = yuva.y; + v = yuva.z; + a = yuva.a; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_set_alpha.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_set_alpha.glsl new file mode 100644 index 00000000000..95380d1ed0f --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_set_alpha.glsl @@ -0,0 +1,9 @@ +void node_composite_set_alpha_apply(vec4 color, float alpha, out vec4 result) +{ + result = color * alpha; +} + +void node_composite_set_alpha_replace(vec4 color, float alpha, out vec4 result) +{ + result = vec4(color.rgb, alpha); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_store_output.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_store_output.glsl new file mode 100644 index 00000000000..7fba26907b5 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_store_output.glsl @@ -0,0 +1,26 @@ +/* The following functions are called to store the given value in the output identified by the + * given ID. The ID is an unsigned integer that is encoded in a float, so floatBitsToUint is called + * to get the actual identifier. The functions have an output value as their last argument that is + * used to establish an output link that is then used to track the nodes that contribute to the + * output of the compositor node tree. + * + * The store_[float|vector|color] functions are dynamically generated in + * ShaderOperation::generate_code_for_outputs. */ + +void node_compositor_store_output_float(const float id, float value, out float out_value) +{ + store_float(floatBitsToUint(id), value); + out_value = value; +} + +void node_compositor_store_output_vector(const float id, vec3 vector, out vec3 out_vector) +{ + store_vector(floatBitsToUint(id), vector); + out_vector = vector; +} + +void node_compositor_store_output_color(const float id, vec4 color, out vec4 out_color) +{ + store_color(floatBitsToUint(id), color); + out_color = color; +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_texture_utilities.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_texture_utilities.glsl new file mode 100644 index 00000000000..128fc6aeaf5 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_texture_utilities.glsl @@ -0,0 +1,35 @@ +/* A shorthand for 1D textureSize with a zero LOD. */ +int texture_size(sampler1D sampler) +{ + return textureSize(sampler, 0); +} + +/* A shorthand for 1D texelFetch with zero LOD and bounded access clamped to border. */ +vec4 texture_load(sampler1D sampler, int x) +{ + const int texture_bound = texture_size(sampler) - 1; + return texelFetch(sampler, clamp(x, 0, texture_bound), 0); +} + +/* A shorthand for 2D textureSize with a zero LOD. */ +ivec2 texture_size(sampler2D sampler) +{ + return textureSize(sampler, 0); +} + +/* A shorthand for 2D texelFetch with zero LOD and bounded access clamped to border. */ +vec4 texture_load(sampler2D sampler, ivec2 texel) +{ + const ivec2 texture_bounds = texture_size(sampler) - ivec2(1); + return texelFetch(sampler, clamp(texel, ivec2(0), texture_bounds), 0); +} + +/* A shorthand for 2D texelFetch with zero LOD and a fallback value for out-of-bound access. */ +vec4 texture_load(sampler2D sampler, ivec2 texel, vec4 fallback) +{ + const ivec2 texture_bounds = texture_size(sampler) - ivec2(1); + if (any(lessThan(texel, ivec2(0))) || any(greaterThan(texel, texture_bounds))) { + return fallback; + } + return texelFetch(sampler, texel, 0); +} diff --git a/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_type_conversion.glsl b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_type_conversion.glsl new file mode 100644 index 00000000000..75c76fd7341 --- /dev/null +++ b/source/blender/compositor/realtime_compositor/shaders/library/gpu_shader_compositor_type_conversion.glsl @@ -0,0 +1,29 @@ +float float_from_vec4(vec4 vector) +{ + return dot(vector.rgb, vec3(1.0)) / 3.0; +} + +float float_from_vec3(vec3 vector) +{ + return dot(vector, vec3(1.0)) / 3.0; +} + +vec3 vec3_from_vec4(vec4 vector) +{ + return vector.rgb; +} + +vec3 vec3_from_float(float value) +{ + return vec3(value); +} + +vec4 vec4_from_vec3(vec3 vector) +{ + return vec4(vector, 1.0); +} + +vec4 vec4_from_float(float value) +{ + return vec4(vec3(value), 1.0); +} diff --git a/source/blender/gpu/CMakeLists.txt b/source/blender/gpu/CMakeLists.txt index bfbbf1be225..8da17720339 100644 --- a/source/blender/gpu/CMakeLists.txt +++ b/source/blender/gpu/CMakeLists.txt @@ -27,6 +27,7 @@ set(INC ../editors/include # For *_info.hh includes. + ../compositor/realtime_compositor ../draw/engines/eevee_next ../draw/intern @@ -366,64 +367,6 @@ set(GLSL_SRC shaders/common/gpu_shader_common_math_utils.glsl shaders/common/gpu_shader_common_mix_rgb.glsl - shaders/compositor/compositor_alpha_crop.glsl - shaders/compositor/compositor_bilateral_blur.glsl - shaders/compositor/compositor_blur.glsl - shaders/compositor/compositor_blur_variable_size.glsl - shaders/compositor/compositor_bokeh_image.glsl - shaders/compositor/compositor_box_mask.glsl - shaders/compositor/compositor_convert.glsl - shaders/compositor/compositor_despeckle.glsl - shaders/compositor/compositor_directional_blur.glsl - shaders/compositor/compositor_edge_filter.glsl - shaders/compositor/compositor_ellipse_mask.glsl - shaders/compositor/compositor_filter.glsl - shaders/compositor/compositor_flip.glsl - shaders/compositor/compositor_image_crop.glsl - shaders/compositor/compositor_morphological_distance.glsl - shaders/compositor/compositor_morphological_distance_feather.glsl - shaders/compositor/compositor_morphological_distance_threshold.glsl - shaders/compositor/compositor_morphological_step.glsl - shaders/compositor/compositor_normalize.glsl - shaders/compositor/compositor_parallel_reduction.glsl - shaders/compositor/compositor_projector_lens_distortion.glsl - shaders/compositor/compositor_realize_on_domain.glsl - shaders/compositor/compositor_screen_lens_distortion.glsl - shaders/compositor/compositor_set_alpha.glsl - shaders/compositor/compositor_split_viewer.glsl - shaders/compositor/compositor_symmetric_blur.glsl - shaders/compositor/compositor_symmetric_separable_blur.glsl - shaders/compositor/compositor_tone_map_photoreceptor.glsl - shaders/compositor/compositor_tone_map_simple.glsl - - shaders/compositor/library/gpu_shader_compositor_alpha_over.glsl - shaders/compositor/library/gpu_shader_compositor_blur_common.glsl - shaders/compositor/library/gpu_shader_compositor_bright_contrast.glsl - shaders/compositor/library/gpu_shader_compositor_channel_matte.glsl - shaders/compositor/library/gpu_shader_compositor_chroma_matte.glsl - shaders/compositor/library/gpu_shader_compositor_color_balance.glsl - shaders/compositor/library/gpu_shader_compositor_color_correction.glsl - shaders/compositor/library/gpu_shader_compositor_color_matte.glsl - shaders/compositor/library/gpu_shader_compositor_color_spill.glsl - shaders/compositor/library/gpu_shader_compositor_color_to_luminance.glsl - shaders/compositor/library/gpu_shader_compositor_difference_matte.glsl - shaders/compositor/library/gpu_shader_compositor_distance_matte.glsl - shaders/compositor/library/gpu_shader_compositor_exposure.glsl - shaders/compositor/library/gpu_shader_compositor_gamma.glsl - shaders/compositor/library/gpu_shader_compositor_hue_correct.glsl - shaders/compositor/library/gpu_shader_compositor_hue_saturation_value.glsl - shaders/compositor/library/gpu_shader_compositor_invert.glsl - shaders/compositor/library/gpu_shader_compositor_luminance_matte.glsl - shaders/compositor/library/gpu_shader_compositor_main.glsl - shaders/compositor/library/gpu_shader_compositor_map_value.glsl - shaders/compositor/library/gpu_shader_compositor_normal.glsl - shaders/compositor/library/gpu_shader_compositor_posterize.glsl - shaders/compositor/library/gpu_shader_compositor_separate_combine.glsl - shaders/compositor/library/gpu_shader_compositor_set_alpha.glsl - shaders/compositor/library/gpu_shader_compositor_store_output.glsl - shaders/compositor/library/gpu_shader_compositor_texture_utilities.glsl - shaders/compositor/library/gpu_shader_compositor_type_conversion.glsl - shaders/material/gpu_shader_material_add_shader.glsl shaders/material/gpu_shader_material_ambient_occlusion.glsl shaders/material/gpu_shader_material_anisotropic.glsl @@ -651,36 +594,6 @@ set(SRC_SHADER_CREATE_INFOS shaders/infos/gpu_shader_simple_lighting_info.hh shaders/infos/gpu_shader_text_info.hh shaders/infos/gpu_srgb_to_framebuffer_space_info.hh - - shaders/compositor/infos/compositor_alpha_crop_info.hh - shaders/compositor/infos/compositor_bilateral_blur_info.hh - shaders/compositor/infos/compositor_blur_info.hh - shaders/compositor/infos/compositor_blur_variable_size_info.hh - shaders/compositor/infos/compositor_bokeh_image_info.hh - shaders/compositor/infos/compositor_box_mask_info.hh - shaders/compositor/infos/compositor_convert_info.hh - shaders/compositor/infos/compositor_despeckle_info.hh - shaders/compositor/infos/compositor_directional_blur_info.hh - shaders/compositor/infos/compositor_edge_filter_info.hh - shaders/compositor/infos/compositor_ellipse_mask_info.hh - shaders/compositor/infos/compositor_filter_info.hh - shaders/compositor/infos/compositor_flip_info.hh - shaders/compositor/infos/compositor_image_crop_info.hh - shaders/compositor/infos/compositor_morphological_distance_feather_info.hh - shaders/compositor/infos/compositor_morphological_distance_info.hh - shaders/compositor/infos/compositor_morphological_distance_threshold_info.hh - shaders/compositor/infos/compositor_morphological_step_info.hh - shaders/compositor/infos/compositor_normalize_info.hh - shaders/compositor/infos/compositor_parallel_reduction_info.hh - shaders/compositor/infos/compositor_projector_lens_distortion_info.hh - shaders/compositor/infos/compositor_realize_on_domain_info.hh - shaders/compositor/infos/compositor_screen_lens_distortion_info.hh - shaders/compositor/infos/compositor_set_alpha_info.hh - shaders/compositor/infos/compositor_split_viewer_info.hh - shaders/compositor/infos/compositor_symmetric_blur_info.hh - shaders/compositor/infos/compositor_symmetric_separable_blur_info.hh - shaders/compositor/infos/compositor_tone_map_photoreceptor_info.hh - shaders/compositor/infos/compositor_tone_map_simple_info.hh ) set(SRC_SHADER_CREATE_INFOS_MTL @@ -715,6 +628,7 @@ endif() blender_add_lib(bf_gpu "${SRC}" "${INC}" "${INC_SYS}" "${LIB}") target_link_libraries(bf_gpu PUBLIC + bf_compositor_shaders bf_draw_shaders bf_gpu_shaders ) diff --git a/source/blender/gpu/intern/gpu_shader_create_info.cc b/source/blender/gpu/intern/gpu_shader_create_info.cc index ff7aa65f03f..ebbddccbe47 100644 --- a/source/blender/gpu/intern/gpu_shader_create_info.cc +++ b/source/blender/gpu/intern/gpu_shader_create_info.cc @@ -284,6 +284,7 @@ void gpu_shader_create_info_init() _info /* Declare, register and construct the infos. */ +#include "compositor_shader_create_info_list.hh" #include "gpu_shader_create_info_list.hh" /* Baked shader data appended to create infos. */ diff --git a/source/blender/gpu/intern/gpu_shader_dependency.cc b/source/blender/gpu/intern/gpu_shader_dependency.cc index be53ee5d945..7d5b8c891b9 100644 --- a/source/blender/gpu/intern/gpu_shader_dependency.cc +++ b/source/blender/gpu/intern/gpu_shader_dependency.cc @@ -24,6 +24,7 @@ extern "C" { #define SHADER_SOURCE(datatoc, filename, filepath) extern char datatoc[]; +#include "glsl_compositor_source_list.h" #include "glsl_draw_source_list.h" #include "glsl_gpu_source_list.h" #ifdef WITH_OCIO @@ -845,6 +846,7 @@ void gpu_shader_dependency_init() #define SHADER_SOURCE(datatoc, filename, filepath) \ g_sources->add_new(filename, new GPUSource(filepath, filename, datatoc, g_functions)); +#include "glsl_compositor_source_list.h" #include "glsl_draw_source_list.h" #include "glsl_gpu_source_list.h" #ifdef WITH_OCIO diff --git a/source/blender/gpu/shaders/compositor/compositor_alpha_crop.glsl b/source/blender/gpu/shaders/compositor/compositor_alpha_crop.glsl deleted file mode 100644 index d55c8efd4c6..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_alpha_crop.glsl +++ /dev/null @@ -1,11 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - /* The lower bound is inclusive and upper bound is exclusive. */ - bool is_inside = all(greaterThanEqual(texel, lower_bound)) && all(lessThan(texel, upper_bound)); - /* Write the pixel color if it is inside the cropping region, otherwise, write zero. */ - vec4 color = is_inside ? texture_load(input_tx, texel) : vec4(0.0); - imageStore(output_img, texel, color); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_bilateral_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_bilateral_blur.glsl deleted file mode 100644 index c7c5ada7a9f..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_bilateral_blur.glsl +++ /dev/null @@ -1,31 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - vec4 center_determinator = texture_load(determinator_tx, texel); - - /* Go over the pixels in the blur window of the specified radius around the center pixel, and for - * pixels whose determinator is close enough to the determinator of the center pixel, accumulate - * their color as well as their weights. */ - float accumulated_weight = 0.0; - vec4 accumulated_color = vec4(0.0); - for (int y = -radius; y <= radius; y++) { - for (int x = -radius; x <= radius; x++) { - vec4 determinator = texture_load(determinator_tx, texel + ivec2(x, y)); - float difference = dot(abs(center_determinator - determinator).rgb, vec3(1.0)); - - if (difference < threshold) { - accumulated_weight += 1.0; - accumulated_color += texture_load(input_tx, texel + ivec2(x, y)); - } - } - } - - /* Write the accumulated color divided by the accumulated weight if any pixel in the window was - * accumulated, otherwise, write a fallback black color. */ - vec4 fallback = vec4(vec3(0.0), 1.0); - vec4 color = (accumulated_weight != 0.0) ? (accumulated_color / accumulated_weight) : fallback; - imageStore(output_img, texel, color); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_blur.glsl deleted file mode 100644 index c7ac620f99b..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_blur.glsl +++ /dev/null @@ -1,66 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -vec4 load_input(ivec2 texel) -{ - vec4 color; - if (extend_bounds) { - /* If bounds are extended, then we treat the input as padded by a radius amount of pixels. So - * we load the input with an offset by the radius amount and fallback to a transparent color if - * it is out of bounds. */ - color = texture_load(input_tx, texel - radius, vec4(0.0)); - } - else { - color = texture_load(input_tx, texel); - } - - return color; -} - -/* Given the texel in the range [-radius, radius] in both axis, load the appropriate weight from - * the weights texture, where the given texel (0, 0) corresponds the center of weights texture. - * Note that we load the weights texture inverted along both directions to maintain the shape of - * the weights if it was not symmetrical. To understand why inversion makes sense, consider a 1D - * weights texture whose right half is all ones and whose left half is all zeros. Further, consider - * that we are blurring a single white pixel on a black background. When computing the value of a - * pixel that is to the right of the white pixel, the white pixel will be in the left region of the - * search window, and consequently, without inversion, a zero will be sampled from the left side of - * the weights texture and result will be zero. However, what we expect is that pixels to the right - * of the white pixel will be white, that is, they should sample a weight of 1 from the right side - * of the weights texture, hence the need for inversion. */ -vec4 load_weight(ivec2 texel) -{ - /* Add the radius to transform the texel into the range [0, radius * 2], with an additional 0.5 - * to sample at the center of the pixels, then divide by the upper bound plus one to transform - * the texel into the normalized range [0, 1] needed to sample the weights sampler. Finally, - * invert the textures coordinates by subtracting from 1 to maintain the shape of the weights as - * mentioned in the function description. */ - return texture(weights_tx, 1.0 - ((texel + vec2(radius + 0.5)) / (radius * 2 + 1))); -} - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* The mask input is treated as a boolean. If it is zero, then no blurring happens for this - * pixel. Otherwise, the pixel is blurred normally and the mask value is irrelevant. */ - float mask = texture_load(mask_tx, texel).x; - if (mask == 0.0) { - imageStore(output_img, texel, texture_load(input_tx, texel)); - return; - } - - /* Go over the window of the given radius and accumulate the colors multiplied by their - * respective weights as well as the weights themselves. */ - vec4 accumulated_color = vec4(0.0); - vec4 accumulated_weight = vec4(0.0); - for (int y = -radius; y <= radius; y++) { - for (int x = -radius; x <= radius; x++) { - vec4 weight = load_weight(ivec2(x, y)); - accumulated_color += load_input(texel + ivec2(x, y)) * weight; - accumulated_weight += weight; - } - } - - imageStore(output_img, texel, safe_divide(accumulated_color, accumulated_weight)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_blur_variable_size.glsl b/source/blender/gpu/shaders/compositor/compositor_blur_variable_size.glsl deleted file mode 100644 index 9383bbf9825..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_blur_variable_size.glsl +++ /dev/null @@ -1,71 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -/* Given the texel in the range [-radius, radius] in both axis, load the appropriate weight from - * the weights texture, where the given texel (0, 0) corresponds the center of weights texture. - * Note that we load the weights texture inverted along both directions to maintain the shape of - * the weights if it was not symmetrical. To understand why inversion makes sense, consider a 1D - * weights texture whose right half is all ones and whose left half is all zeros. Further, consider - * that we are blurring a single white pixel on a black background. When computing the value of a - * pixel that is to the right of the white pixel, the white pixel will be in the left region of the - * search window, and consequently, without inversion, a zero will be sampled from the left side of - * the weights texture and result will be zero. However, what we expect is that pixels to the right - * of the white pixel will be white, that is, they should sample a weight of 1 from the right side - * of the weights texture, hence the need for inversion. */ -vec4 load_weight(ivec2 texel, float radius) -{ - /* The center zero texel is always assigned a unit weight regardless of the corresponding weight - * in the weights texture. That's to guarantee that at last the center pixel will be accumulated - * even if the weights texture is zero at its center. */ - if (texel == ivec2(0)) { - return vec4(1.0); - } - - /* Add the radius to transform the texel into the range [0, radius * 2], with an additional 0.5 - * to sample at the center of the pixels, then divide by the upper bound plus one to transform - * the texel into the normalized range [0, 1] needed to sample the weights sampler. Finally, - * invert the textures coordinates by subtracting from 1 to maintain the shape of the weights as - * mentioned in the function description. */ - return texture(weights_tx, 1.0 - ((texel + vec2(radius + 0.5)) / (radius * 2 + 1))); -} - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* The mask input is treated as a boolean. If it is zero, then no blurring happens for this - * pixel. Otherwise, the pixel is blurred normally and the mask value is irrelevant. */ - float mask = texture_load(mask_tx, texel).x; - if (mask == 0.0) { - imageStore(output_img, texel, texture_load(input_tx, texel)); - return; - } - - float center_size = texture_load(size_tx, texel).x * base_size; - - /* Go over the window of the given search radius and accumulate the colors multiplied by their - * respective weights as well as the weights themselves, but only if both the size of the center - * pixel and the size of the candidate pixel are less than both the x and y distances of the - * candidate pixel. */ - vec4 accumulated_color = vec4(0.0); - vec4 accumulated_weight = vec4(0.0); - for (int y = -search_radius; y <= search_radius; y++) { - for (int x = -search_radius; x <= search_radius; x++) { - float candidate_size = texture_load(size_tx, texel + ivec2(x, y)).x * base_size; - - /* Skip accumulation if either the x or y distances of the candidate pixel are larger than - * either the center or candidate pixel size. Note that the max and min functions here denote - * "either" in the aforementioned description. */ - float size = min(center_size, candidate_size); - if (max(abs(x), abs(y)) > size) { - continue; - } - - vec4 weight = load_weight(ivec2(x, y), size); - accumulated_color += texture_load(input_tx, texel + ivec2(x, y)) * weight; - accumulated_weight += weight; - } - } - - imageStore(output_img, texel, safe_divide(accumulated_color, accumulated_weight)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_bokeh_image.glsl b/source/blender/gpu/shaders/compositor/compositor_bokeh_image.glsl deleted file mode 100644 index 6e98aa9fe17..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_bokeh_image.glsl +++ /dev/null @@ -1,118 +0,0 @@ -#pragma BLENDER_REQUIRE(common_math_lib.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -/* Get the 2D vertex position of the vertex with the given index in the regular polygon - * representing this bokeh. The polygon is rotated by the rotation amount and have a unit - * circumradius. The regular polygon is one whose vertices' exterior angles are given by - * exterior_angle. See the bokeh function for more information. */ -vec2 get_regular_polygon_vertex_position(int vertex_index) -{ - float angle = exterior_angle * vertex_index - rotation; - return vec2(cos(angle), sin(angle)); -} - -/* Find the closest point to the given point on the given line. This assumes the length of the - * given line is not zero. */ -vec2 closest_point_on_line(vec2 point, vec2 line_start, vec2 line_end) -{ - vec2 line_vector = line_end - line_start; - vec2 point_vector = point - line_start; - float line_length_squared = dot(line_vector, line_vector); - float parameter = dot(point_vector, line_vector) / line_length_squared; - return line_start + line_vector * parameter; -} - -/* Compute the value of the bokeh at the given point. The computed bokeh is essentially a regular - * polygon centered in space having the given circumradius. The regular polygon is one whose - * vertices' exterior angles are given by "exterior_angle", which relates to the number of vertices - * n through the equation "exterior angle = 2 pi / n". The regular polygon may additionally morph - * into a shape with the given properties: - * - * - The regular polygon may have a circular hole in its center whose radius is controlled by the - * "catadioptric" value. - * - The regular polygon is rotated by the "rotation" value. - * - The regular polygon can morph into a circle controlled by the "roundness" value, such that it - * becomes a full circle at unit roundness. - * - * The function returns 0 when the point lies inside the regular polygon and 1 otherwise. However, - * at the edges, it returns a narrow band gradient as a form of anti-aliasing. */ -float bokeh(vec2 point, float circumradius) -{ - /* Get the index of the vertex of the regular polygon whose polar angle is maximum but less than - * the polar angle of the given point, taking rotation into account. This essentially finds the - * vertex closest to the given point in the clock-wise direction. */ - float angle = mod(atan(point.y, point.x) + rotation, M_2PI); - int vertex_index = int(angle / exterior_angle); - - /* Compute the shortest distance between the origin and the polygon edge composed from the - * previously selected vertex and the one following it. */ - vec2 first_vertex = get_regular_polygon_vertex_position(vertex_index) * circumradius; - vec2 second_vertex = get_regular_polygon_vertex_position(vertex_index + 1) * circumradius; - vec2 closest_point = closest_point_on_line(point, first_vertex, second_vertex); - float distance_to_edge = length(closest_point); - - /* Mix the distance to the edge with the circumradius, making it tend to the distance to a - * circle when roundness tends to 1. */ - float distance_to_edge_round = mix(distance_to_edge, circumradius, roundness); - - /* The point is outside of the bokeh, so we return 0. */ - float distance = length(point); - if (distance > distance_to_edge_round) { - return 0.0; - } - - /* The point is inside the catadioptric hole and is not part of the bokeh, so we return 0. */ - float catadioptric_distance = distance_to_edge_round * catadioptric; - if (distance < catadioptric_distance) { - return 0.0; - } - - /* The point is very close to the edge of the bokeh, so we return the difference between the - * distance to the edge and the distance as a form of anti-aliasing. */ - if (distance_to_edge_round - distance < 1.0) { - return distance_to_edge_round - distance; - } - - /* The point is very close to the edge of the catadioptric hole, so we return the difference - * between the distance to the hole and the distance as a form of anti-aliasing. */ - if (catadioptric != 0.0 && distance - catadioptric_distance < 1.0) { - return distance - catadioptric_distance; - } - - /* Otherwise, the point is part of the bokeh and we return 1. */ - return 1.0; -} - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* Since we need the regular polygon to occupy the entirety of the output image, the circumradius - * of the regular polygon is half the width of the output image. */ - float circumradius = float(imageSize(output_img).x) / 2.0; - - /* Move the texel coordinates such that the regular polygon is centered. */ - vec2 point = vec2(texel) - circumradius; - - /* Each of the color channels of the output image contains a bokeh with a different circumradius. - * The largest one occupies the whole image as stated above, while the other two have circumradii - * that are shifted by an amount that is proportional to the "lens_shift" value. The alpha - * channel of the output is the average of all three values. */ - float min_shift = abs(lens_shift * circumradius); - float min = mix(bokeh(point, circumradius - min_shift), 0.0, min_shift == circumradius); - - float median_shift = min_shift / 2.0; - float median = bokeh(point, circumradius - median_shift); - - float max = bokeh(point, circumradius); - vec4 bokeh = vec4(min, median, max, (max + median + min) / 3.0); - - /* If the lens shift is negative, swap the min and max bokeh values, which are stored in the red - * and blue channels respectively. Note that we take the absolute value of the lens shift above, - * so the sign of the lens shift only controls this swap. */ - if (lens_shift < 0) { - bokeh = bokeh.zyxw; - } - - imageStore(output_img, texel, bokeh); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_box_mask.glsl b/source/blender/gpu/shaders/compositor/compositor_box_mask.glsl deleted file mode 100644 index fad23f28fde..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_box_mask.glsl +++ /dev/null @@ -1,27 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - vec2 uv = vec2(texel) / vec2(domain_size - ivec2(1)); - uv -= location; - uv.y *= float(domain_size.y) / float(domain_size.x); - uv = mat2(cos_angle, -sin_angle, sin_angle, cos_angle) * uv; - bool is_inside = all(lessThan(abs(uv), size)); - - float base_mask_value = texture_load(base_mask_tx, texel).x; - float value = texture_load(mask_value_tx, texel).x; - -#if defined(CMP_NODE_MASKTYPE_ADD) - float output_mask_value = is_inside ? max(base_mask_value, value) : base_mask_value; -#elif defined(CMP_NODE_MASKTYPE_SUBTRACT) - float output_mask_value = is_inside ? clamp(base_mask_value - value, 0.0, 1.0) : base_mask_value; -#elif defined(CMP_NODE_MASKTYPE_MULTIPLY) - float output_mask_value = is_inside ? base_mask_value * value : 0.0; -#elif defined(CMP_NODE_MASKTYPE_NOT) - float output_mask_value = is_inside ? (base_mask_value > 0.0 ? 0.0 : value) : base_mask_value; -#endif - - imageStore(output_mask_img, texel, vec4(output_mask_value)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_convert.glsl b/source/blender/gpu/shaders/compositor/compositor_convert.glsl deleted file mode 100644 index 044fb057ca5..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_convert.glsl +++ /dev/null @@ -1,8 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - vec4 value = texture_load(input_tx, texel); - imageStore(output_img, texel, CONVERT_EXPRESSION(value)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_despeckle.glsl b/source/blender/gpu/shaders/compositor/compositor_despeckle.glsl deleted file mode 100644 index e4743d69d17..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_despeckle.glsl +++ /dev/null @@ -1,70 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -/* Returns true if the given color is close enough to the given reference color within the - * threshold supplied by the user, and returns false otherwise. */ -bool is_close(vec4 reference_color, vec4 color) -{ - return all(lessThan(abs(reference_color - color).rgb, vec3(threshold))); -} - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* A 3x3 weights kernel whose weights are the inverse of the distance to the center of the - * kernel. So the center weight is zero, the corners weights are (1 / sqrt(2)), and the rest - * of the weights are 1. The total sum of weights is 4 plus quadruple the corner weight. */ - float corner_weight = 1.0 / sqrt(2.0); - float sum_of_weights = 4.0 + corner_weight * 4.0; - mat3 weights = mat3(vec3(corner_weight, 1.0, corner_weight), - vec3(1.0, 0.0, 1.0), - vec3(corner_weight, 1.0, corner_weight)); - - vec4 center_color = texture_load(input_tx, texel); - - /* Go over the pixels in the 3x3 window around the center pixel and compute the total sum of - * their colors multiplied by their weights. Additionally, for pixels whose colors are not close - * enough to the color of the center pixel, accumulate their color as well as their weights. */ - vec4 sum_of_colors = vec4(0); - float accumulated_weight = 0.0; - vec4 accumulated_color = vec4(0); - for (int j = 0; j < 3; j++) { - for (int i = 0; i < 3; i++) { - float weight = weights[j][i]; - vec4 color = texture_load(input_tx, texel + ivec2(i - 1, j - 1)) * weight; - sum_of_colors += color; - if (!is_close(center_color, color)) { - accumulated_color += color; - accumulated_weight += weight; - } - } - } - - /* If the accumulated weight is zero, that means all pixels in the 3x3 window are similar and no - * need to despeckle anything, so write the original center color and return. */ - if (accumulated_weight == 0.0) { - imageStore(output_img, texel, center_color); - return; - } - - /* If the ratio between the accumulated weights and the total sum of weights is not larger than - * the user specified neighbor threshold, then the number of pixels in the neighborhood that are - * not close enough to the center pixel is low, and no need to despeckle anything, so write the - * original center color and return. */ - if (accumulated_weight / sum_of_weights < neighbor_threshold) { - imageStore(output_img, texel, center_color); - return; - } - - /* If the weighted average color of the neighborhood is close enough to the center pixel, then no - * need to despeckle anything, so write the original center color and return. */ - if (is_close(center_color, sum_of_colors / sum_of_weights)) { - imageStore(output_img, texel, center_color); - return; - } - - /* We need to despeckle, so write the mean accumulated color. */ - float factor = texture_load(factor_tx, texel).x; - vec4 mean_color = accumulated_color / accumulated_weight; - imageStore(output_img, texel, mix(center_color, mean_color, factor)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_directional_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_directional_blur.glsl deleted file mode 100644 index 1805cb5a7f5..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_directional_blur.glsl +++ /dev/null @@ -1,21 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - ivec2 input_size = texture_size(input_tx); - - /* Add 0.5 to evaluate the input sampler at the center of the pixel. */ - vec2 coordinates = vec2(texel) + vec2(0.5); - - /* For each iteration, accumulate the input at the normalize coordinates, hence the divide by - * input size, then transform the coordinates for the next iteration. */ - vec4 accumulated_color = vec4(0.0); - for (int i = 0; i < iterations; i++) { - accumulated_color += texture(input_tx, coordinates / input_size); - coordinates = (mat3(inverse_transformation) * vec3(coordinates, 1.0)).xy; - } - - /* Write the accumulated color divided by the number of iterations. */ - imageStore(output_img, texel, accumulated_color / iterations); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_edge_filter.glsl b/source/blender/gpu/shaders/compositor/compositor_edge_filter.glsl deleted file mode 100644 index 67e27c22602..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_edge_filter.glsl +++ /dev/null @@ -1,31 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* Compute the dot product between the 3x3 window around the pixel and the edge detection kernel - * in the X direction and Y direction. The Y direction kernel is computed by transposing the - * given X direction kernel. */ - vec3 color_x = vec3(0); - vec3 color_y = vec3(0); - for (int j = 0; j < 3; j++) { - for (int i = 0; i < 3; i++) { - vec3 color = texture_load(input_tx, texel + ivec2(i - 1, j - 1)).rgb; - color_x += color * kernel[j][i]; - color_y += color * kernel[i][j]; - } - } - - /* Compute the channel-wise magnitude of the 2D vector composed from the X and Y edge detection - * filter results. */ - vec3 magnitude = sqrt(color_x * color_x + color_y * color_y); - - /* Mix the channel-wise magnitude with the original color at the center of the kernel using the - * input factor. */ - vec4 color = texture_load(input_tx, texel); - magnitude = mix(color.rgb, magnitude, texture_load(factor_tx, texel).x); - - /* Store the channel-wise magnitude with the original alpha of the input. */ - imageStore(output_img, texel, vec4(magnitude, color.a)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_ellipse_mask.glsl b/source/blender/gpu/shaders/compositor/compositor_ellipse_mask.glsl deleted file mode 100644 index 28f725067e0..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_ellipse_mask.glsl +++ /dev/null @@ -1,27 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - vec2 uv = vec2(texel) / vec2(domain_size - ivec2(1)); - uv -= location; - uv.y *= float(domain_size.y) / float(domain_size.x); - uv = mat2(cos_angle, -sin_angle, sin_angle, cos_angle) * uv; - bool is_inside = length(uv / radius) < 1.0; - - float base_mask_value = texture_load(base_mask_tx, texel).x; - float value = texture_load(mask_value_tx, texel).x; - -#if defined(CMP_NODE_MASKTYPE_ADD) - float output_mask_value = is_inside ? max(base_mask_value, value) : base_mask_value; -#elif defined(CMP_NODE_MASKTYPE_SUBTRACT) - float output_mask_value = is_inside ? clamp(base_mask_value - value, 0.0, 1.0) : base_mask_value; -#elif defined(CMP_NODE_MASKTYPE_MULTIPLY) - float output_mask_value = is_inside ? base_mask_value * value : 0.0; -#elif defined(CMP_NODE_MASKTYPE_NOT) - float output_mask_value = is_inside ? (base_mask_value > 0.0 ? 0.0 : value) : base_mask_value; -#endif - - imageStore(output_mask_img, texel, vec4(output_mask_value)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_filter.glsl b/source/blender/gpu/shaders/compositor/compositor_filter.glsl deleted file mode 100644 index e501c563dda..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_filter.glsl +++ /dev/null @@ -1,20 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* Compute the dot product between the 3x3 window around the pixel and the filter kernel. */ - vec4 color = vec4(0); - for (int j = 0; j < 3; j++) { - for (int i = 0; i < 3; i++) { - color += texture_load(input_tx, texel + ivec2(i - 1, j - 1)) * kernel[j][i]; - } - } - - /* Mix with the original color at the center of the kernel using the input factor. */ - color = mix(texture_load(input_tx, texel), color, texture_load(factor_tx, texel).x); - - /* Store the color making sure it is not negative. */ - imageStore(output_img, texel, max(color, 0.0)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_flip.glsl b/source/blender/gpu/shaders/compositor/compositor_flip.glsl deleted file mode 100644 index 919c454ee63..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_flip.glsl +++ /dev/null @@ -1,15 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - ivec2 size = texture_size(input_tx); - ivec2 flipped_texel = texel; - if (flip_x) { - flipped_texel.x = size.x - texel.x - 1; - } - if (flip_y) { - flipped_texel.y = size.y - texel.y - 1; - } - imageStore(output_img, texel, texture_load(input_tx, flipped_texel)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_image_crop.glsl b/source/blender/gpu/shaders/compositor/compositor_image_crop.glsl deleted file mode 100644 index f20e033dee4..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_image_crop.glsl +++ /dev/null @@ -1,7 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - imageStore(output_img, texel, texture_load(input_tx, texel + lower_bound)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_morphological_distance.glsl b/source/blender/gpu/shaders/compositor/compositor_morphological_distance.glsl deleted file mode 100644 index 09f896b7a9d..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_morphological_distance.glsl +++ /dev/null @@ -1,24 +0,0 @@ -#pragma BLENDER_REQUIRE(common_math_lib.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* Find the minimum/maximum value in the circular window of the given radius around the pixel. By - * circular window, we mean that pixels in the window whose distance to the center of window is - * larger than the given radius are skipped and not considered. Consequently, the dilation or - * erosion that take place produces round results as opposed to squarish ones. This is - * essentially a morphological operator with a circular structuring element. The LIMIT value - * should be FLT_MAX if OPERATOR is min and FLT_MIN if OPERATOR is max. */ - float value = LIMIT; - for (int y = -radius; y <= radius; y++) { - for (int x = -radius; x <= radius; x++) { - if (x * x + y * y <= radius * radius) { - value = OPERATOR(value, texture_load(input_tx, texel + ivec2(x, y), vec4(LIMIT)).x); - } - } - } - - imageStore(output_img, texel, vec4(value)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_morphological_distance_feather.glsl b/source/blender/gpu/shaders/compositor/compositor_morphological_distance_feather.glsl deleted file mode 100644 index acdd8a40342..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_morphological_distance_feather.glsl +++ /dev/null @@ -1,101 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -/* The Morphological Distance Feather operation is a linear combination between the result of two - * operations. The first operation is a Gaussian blur with a radius equivalent to the dilate/erode - * distance, which is straightforward and implemented as a separable filter similar to the blur - * operation. - * - * The second operation is an approximation of a morphological inverse distance operation evaluated - * at a distance falloff function. The result of a morphological inverse distance operation is a - * narrow band distance field that starts at its maximum value at boundaries where a difference in - * values took place and linearly deceases until it reaches zero in the span of a number of pixels - * equivalent to the erode/dilate distance. Additionally, instead of linearly decreasing, the user - * may choose a different falloff which is evaluated at the computed distance. For dilation, the - * distance field decreases outwards, and for erosion, the distance field decreased inwards. - * - * The reason why the result of a Gaussian blur is mixed in with the distance field is because the - * distance field is merely approximated and not accurately computed, the defects of which is more - * apparent away from boundaries and especially at corners where the distance field should take a - * circular shape. That's why the Gaussian blur is mostly mixed only further from boundaries. - * - * The morphological inverse distance operation is approximated using a separable implementation - * and intertwined with the Gaussian blur implementation as follows. A search window of a radius - * equivalent to the dilate/erode distance is applied on the image to find either the minimum or - * maximum pixel value multiplied by its corresponding falloff value in the window. For dilation, - * we try to find the maximum, and for erosion, we try to find the minimum. Additionally, we also - * save the falloff value where the minimum or maximum was found. The found value will be that of - * the narrow band distance field and the saved falloff value will be used as the mixing factor - * with the Gaussian blur. - * - * To make sense of the aforementioned algorithm, assume we are dilating a binary image by 5 pixels - * whose half has a value of 1 and the other half has a value of zero. Consider the following: - * - * - A pixel of value 1 already has the maximum possible value, so its value will remain unchanged - * regardless of its position. - * - A pixel of value 0 that is right at the boundary of the 1's region will have a maximum value - * of around 0.8 depending on the falloff. That's because the search window intersects the 1's - * region, which when multiplied by the falloff gives the first value of the falloff, which is - * larger than the initially zero value computed at the center of the search window. - * - A pixel of value 0 that is 3 pixels away from the boundary will have a maximum value of around - * 0.4 depending on the falloff. That's because the search window intersects the 1's region, - * which when multiplied by the falloff gives the third value of the falloff, which is larger - * than the initially zero value computed at the center of the search window. - * - Finally, a pixel of value 0 that is 6 pixels away from the boundary will have a maximum value - * of 0, because the search window doesn't intersects the 1's region and only spans zero values. - * - * The previous example demonstrates how the distance field naturally arises, and the same goes for - * the erode case, except the minimum value is computed instead. - */ -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* A value for accumulating the blur result. */ - float accumulated_value = 0.0; - - /* Compute the contribution of the center pixel to the blur result. */ - float center_value = texture_load(input_tx, texel).x; - accumulated_value += center_value * texture_load(weights_tx, 0).x; - - /* Start with the center value as the maximum/minimum distance and reassign to the true maximum - * or minimum in the search loop below. Additionally, the center falloff is always 1.0, so start - * with that. */ - float limit_distance = center_value; - float limit_distance_falloff = 1.0; - - /* Compute the contributions of the pixels to the right and left, noting that the weights and - * falloffs textures only store the weights and falloffs for the positive half, but since the - * they are both symmetric, the same weights and falloffs are used for the negative half and we - * compute both of their contributions. */ - for (int i = 1; i < texture_size(weights_tx); i++) { - float weight = texture_load(weights_tx, i).x; - float falloff = texture_load(falloffs_tx, i).x; - - /* Loop for two iterations, where s takes the value of -1 and 1, which is used as the sign - * needed to evaluated the positive and negative sides as explain above. */ - for (int s = -1; s < 2; s += 2) { - /* Compute the contribution of the pixel to the blur result. */ - float value = texture_load(input_tx, texel + ivec2(s * i, 0)).x; - accumulated_value += value * weight; - - /* The distance is computed such that its highest value is the pixel value itself, so - * multiply the distance falloff by the pixel value. */ - float falloff_distance = value * falloff; - - /* Find either the maximum or the minimum for the dilate and erode cases respectively. */ - if (COMPARE(falloff_distance, limit_distance)) { - limit_distance = falloff_distance; - limit_distance_falloff = falloff; - } - } - } - - /* Mix between the limit distance and the blurred accumulated value such that the limit distance - * is used for pixels closer to the boundary and the blurred value is used for pixels away from - * the boundary. */ - float value = mix(accumulated_value, limit_distance, limit_distance_falloff); - - /* Write the value using the transposed texel. See the execute_distance_feather_horizontal_pass - * method for more information on the rational behind this. */ - imageStore(output_img, texel.yx, vec4(value)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_morphological_distance_threshold.glsl b/source/blender/gpu/shaders/compositor/compositor_morphological_distance_threshold.glsl deleted file mode 100644 index e6625e7419f..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_morphological_distance_threshold.glsl +++ /dev/null @@ -1,88 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -/* The Morphological Distance Threshold operation is effectively three consecutive operations - * implemented as a single operation. The three operations are as follows: - * - * .-----------. .--------------. .----------------. - * | Threshold |-->| Dilate/Erode |-->| Distance Inset | - * '-----------' '--------------' '----------------' - * - * The threshold operation just converts the input into a binary image, where the pixel is 1 if it - * is larger than 0.5 and 0 otherwise. Pixels that are 1 in the output of the threshold operation - * are said to be masked. The dilate/erode operation is a dilate or erode morphological operation - * with a circular structuring element depending on the sign of the distance, where it is a dilate - * operation if the distance is positive and an erode operation otherwise. This is equivalent to - * the Morphological Distance operation, see its implementation for more information. Finally, the - * distance inset is an operation that converts the binary image into a narrow band distance field. - * That is, pixels that are unmasked will remain 0, while pixels that are masked will start from - * zero at the boundary of the masked region and linearly increase until reaching 1 in the span of - * a number pixels given by the inset value. - * - * As a performance optimization, the dilate/erode operation is omitted and its effective result is - * achieved by slightly adjusting the distance inset operation. The base distance inset operation - * works by computing the signed distance from the current center pixel to the nearest pixel with a - * different value. Since our image is a binary image, that means that if the pixel is masked, we - * compute the signed distance to the nearest unmasked pixel, and if the pixel unmasked, we compute - * the signed distance to the nearest masked pixel. The distance is positive if the pixel is masked - * and negative otherwise. The distance is then normalized by dividing by the given inset value and - * clamped to the [0, 1] range. Since distances larger than the inset value are eventually clamped, - * the distance search window is limited to a radius equivalent to the inset value. - * - * To archive the effective result of the omitted dilate/erode operation, we adjust the distance - * inset operation as follows. First, we increase the radius of the distance search window by the - * radius of the dilate/erode operation. Then we adjust the resulting narrow band signed distance - * field as follows. - * - * For the erode case, we merely subtract the erode distance, which makes the outermost erode - * distance number of pixels zero due to clamping, consequently achieving the result of the erode, - * while retaining the needed inset because we increased the distance search window by the same - * amount we subtracted. - * - * Similarly, for the dilate case, we add the dilate distance, which makes the dilate distance - * number of pixels just outside of the masked region positive and part of the narrow band distance - * field, consequently achieving the result of the dilate, while at the same time, the innermost - * dilate distance number of pixels become 1 due to clamping, retaining the needed inset because we - * increased the distance search window by the same amount we added. - * - * Since the erode/dilate distance is already signed appropriately as described before, we just add - * it in both cases. */ -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* Apply a threshold operation on the center pixel, where the threshold is currently hard-coded - * at 0.5. The pixels with values larger than the threshold are said to be masked. */ - bool is_center_masked = texture_load(input_tx, texel).x > 0.5; - - /* Since the distance search window will access pixels outside of the bounds of the image, we use - * a texture loader with a fallback value. And since we don't want those values to affect the - * result, the fallback value is chosen such that the inner condition fails, which is when the - * sampled pixel and the center pixel are the same, so choose a fallback that will be considered - * masked if the center pixel is masked and unmasked otherwise. */ - vec4 fallback = vec4(is_center_masked ? 1.0 : 0.0); - - /* Since the distance search window is limited to the given radius, the maximum possible squared - * distance to the center is double the squared radius. */ - int minimum_squared_distance = radius * radius * 2; - - /* Find the squared distance to the nearest different pixel in the search window of the given - * radius. */ - for (int y = -radius; y <= radius; y++) { - for (int x = -radius; x <= radius; x++) { - bool is_sample_masked = texture_load(input_tx, texel + ivec2(x, y), fallback).x > 0.5; - if (is_center_masked != is_sample_masked) { - minimum_squared_distance = min(minimum_squared_distance, x * x + y * y); - } - } - } - - /* Compute the actual distance from the squared distance and assign it an appropriate sign - * depending on whether it lies in a masked region or not. */ - float signed_minimum_distance = sqrt(minimum_squared_distance) * (is_center_masked ? 1.0 : -1.0); - - /* Add the erode/dilate distance and divide by the inset amount as described in the discussion, - * then clamp to the [0, 1] range. */ - float value = clamp((signed_minimum_distance + distance) / inset, 0.0, 1.0); - - imageStore(output_img, texel, vec4(value)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_morphological_step.glsl b/source/blender/gpu/shaders/compositor/compositor_morphological_step.glsl deleted file mode 100644 index 6992bc2afa5..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_morphological_step.glsl +++ /dev/null @@ -1,19 +0,0 @@ -#pragma BLENDER_REQUIRE(common_math_lib.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* Find the minimum/maximum value in the window of the given radius around the pixel. This is - * essentially a morphological operator with a square structuring element. The LIMIT value should - * be FLT_MAX if OPERATOR is min and FLT_MIN if OPERATOR is max. */ - float value = LIMIT; - for (int i = -radius; i <= radius; i++) { - value = OPERATOR(value, texture_load(input_tx, texel + ivec2(i, 0), vec4(LIMIT)).x); - } - - /* Write the value using the transposed texel. See the execute_step_horizontal_pass method for - * more information on the rational behind this. */ - imageStore(output_img, texel.yx, vec4(value)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_normalize.glsl b/source/blender/gpu/shaders/compositor/compositor_normalize.glsl deleted file mode 100644 index 53dfeb01730..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_normalize.glsl +++ /dev/null @@ -1,10 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - float value = texture_load(input_tx, texel).x; - float normalized_value = (value - minimum) * scale; - float clamped_value = clamp(normalized_value, 0.0, 1.0); - imageStore(output_img, texel, vec4(clamped_value)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_parallel_reduction.glsl b/source/blender/gpu/shaders/compositor/compositor_parallel_reduction.glsl deleted file mode 100644 index f6f84aa24c1..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_parallel_reduction.glsl +++ /dev/null @@ -1,98 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -/* This shader reduces the given texture into a smaller texture of a size equal to the number of - * work groups. In particular, each work group reduces its contents into a single value and writes - * that value to a single pixel in the output image. The shader can be dispatched multiple times to - * eventually reduce the image into a single pixel. - * - * The shader works by loading the whole data of each work group into a linear array, then it - * reduces the second half of the array onto the first half of the array, then it reduces the - * second quarter of the array onto the first quarter or the array, and so on until only one - * element remains. The following figure illustrates the process for sum reduction on 8 elements. - * - * .---. .---. .---. .---. .---. .---. .---. .---. - * | 0 | | 1 | | 2 | | 3 | | 4 | | 5 | | 6 | | 7 | Original data. - * '---' '---' '---' '---' '---' '---' '---' '---' - * |.____|_____|_____|_____| | | | - * || |.____|_____|___________| | | - * || || |.____|_________________| | - * || || || |.______________________| <--First reduction. Stride = 4. - * || || || || - * .---. .---. .---. .----. - * | 4 | | 6 | | 8 | | 10 | <--Data after first reduction. - * '---' '---' '---' '----' - * |.____|_____| | - * || |.__________| <--Second reduction. Stride = 2. - * || || - * .----. .----. - * | 12 | | 16 | <--Data after second reduction. - * '----' '----' - * |.____| - * || <--Third reduction. Stride = 1. - * .----. - * | 28 | - * '----' <--Data after third reduction. - * - * - * The shader is generic enough to implement many types of reductions. This is done by using macros - * that the developer should define to implement a certain reduction operation. Those include, - * TYPE, IDENTITY, INITIALIZE, LOAD, and REDUCE. See the implementation below for more information - * as well as the compositor_parallel_reduction_info.hh for example reductions operations. */ - -/* Doing the reduction in shared memory is faster, so create a shared array where the whole data - * of the work group will be loaded and reduced. The 2D structure of the work group is irrelevant - * for reduction, so we just load the data in a 1D array to simplify reduction. The developer is - * expected to define the TYPE macro to be a float or a vec4, depending on the type of data being - * reduced. */ -const uint reduction_size = gl_WorkGroupSize.x * gl_WorkGroupSize.y; -shared TYPE reduction_data[reduction_size]; - -void main() -{ - /* Load the data from the texture, while returning IDENTITY for out of bound coordinates. The - * developer is expected to define the IDENTITY macro to be a vec4 that does not affect the - * output of the reduction. For instance, sum reductions have an identity of vec4(0.0), while - * max value reductions have an identity of vec4(FLT_MIN). */ - vec4 value = texture_load(input_tx, ivec2(gl_GlobalInvocationID.xy), IDENTITY); - - /* Initialize the shared array given the previously loaded value. This step can be different - * depending on whether this is the initial reduction pass or a latter one. Indeed, the input - * texture for the initial reduction is the source texture itself, while the input texture to a - * latter reduction pass is an intermediate texture after one or more reductions have happened. - * This is significant because the data being reduced might be computed from the original data - * and different from it, for instance, when summing the luminance of an image, the original data - * is a vec4 color, while the reduced data is a float luminance value. So for the initial - * reduction pass, the luminance will be computed from the color, reduced, then stored into an - * intermediate float texture. On the other hand, for latter reduction passes, the luminance will - * be loaded directly and reduced without extra processing. So the developer is expected to - * define the INITIALIZE and LOAD macros to be expressions that derive the needed value from the - * loaded value for the initial reduction pass and latter ones respectively. */ - reduction_data[gl_LocalInvocationIndex] = is_initial_reduction ? INITIALIZE(value) : LOAD(value); - - /* Reduce the reduction data by half on every iteration until only one element remains. See the - * above figure for an intuitive understanding of the stride value. */ - for (uint stride = reduction_size / 2; stride > 0; stride /= 2) { - barrier(); - - /* Only the threads up to the current stride should be active as can be seen in the diagram - * above. */ - if (gl_LocalInvocationIndex >= stride) { - continue; - } - - /* Reduce each two elements that are stride apart, writing the result to the element with the - * lower index, as can be seen in the diagram above. The developer is expected to define the - * REDUCE macro to be a commutative and associative binary operator suitable for parallel - * reduction. */ - reduction_data[gl_LocalInvocationIndex] = REDUCE( - reduction_data[gl_LocalInvocationIndex], reduction_data[gl_LocalInvocationIndex + stride]); - } - - /* Finally, the result of the reduction is available as the first element in the reduction data, - * write it to the pixel corresponding to the work group, making sure only the one thread writes - * it. */ - barrier(); - if (gl_LocalInvocationIndex == 0) { - imageStore(output_img, ivec2(gl_WorkGroupID.xy), vec4(reduction_data[0])); - } -} diff --git a/source/blender/gpu/shaders/compositor/compositor_projector_lens_distortion.glsl b/source/blender/gpu/shaders/compositor/compositor_projector_lens_distortion.glsl deleted file mode 100644 index ab44dac93e6..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_projector_lens_distortion.glsl +++ /dev/null @@ -1,16 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* Get the normalized coordinates of the pixel centers. */ - vec2 normalized_texel = (vec2(texel) + vec2(0.5)) / vec2(texture_size(input_tx)); - - /* Sample the red and blue channels shifted by the dispersion amount. */ - const float red = texture(input_tx, normalized_texel + vec2(dispersion, 0.0)).r; - const float green = texture_load(input_tx, texel).g; - const float blue = texture(input_tx, normalized_texel - vec2(dispersion, 0.0)).b; - - imageStore(output_img, texel, vec4(red, green, blue, 1.0)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_realize_on_domain.glsl b/source/blender/gpu/shaders/compositor/compositor_realize_on_domain.glsl deleted file mode 100644 index b8561e5f059..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_realize_on_domain.glsl +++ /dev/null @@ -1,29 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* Add 0.5 to evaluate the input sampler at the center of the pixel. */ - vec2 coordinates = vec2(texel) + vec2(0.5); - - /* Transform the input image by transforming the domain coordinates with the inverse of input - * image's transformation. The inverse transformation is an affine matrix and thus the - * coordinates should be in homogeneous coordinates. */ - coordinates = (mat3(inverse_transformation) * vec3(coordinates, 1.0)).xy; - - /* Since an input image with an identity transformation is supposed to be centered in the domain, - * we subtract the offset between the lower left corners of the input image and the domain, which - * is half the difference between their sizes, because the difference in size is on both sides of - * the centered image. Additionally, we floor the offset to retain the 0.5 offset added above in - * case the difference in sizes was odd. */ - ivec2 domain_size = imageSize(domain_img); - ivec2 input_size = texture_size(input_tx); - vec2 offset = floor((domain_size - input_size) / 2.0); - - /* Subtract the offset and divide by the input image size to get the relevant coordinates into - * the sampler's expected [0, 1] range. */ - vec2 normalized_coordinates = (coordinates - offset) / input_size; - - imageStore(domain_img, texel, texture(input_tx, normalized_coordinates)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_screen_lens_distortion.glsl b/source/blender/gpu/shaders/compositor/compositor_screen_lens_distortion.glsl deleted file mode 100644 index dc572ea5aaf..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_screen_lens_distortion.glsl +++ /dev/null @@ -1,151 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_hash.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -/* A model that approximates lens distortion parameterized by a distortion parameter and dependent - * on the squared distance to the center of the image. The distorted pixel is then computed as the - * scalar multiplication of the pixel coordinates with the value returned by this model. See the - * compute_distorted_uv function for more details. */ -float compute_distortion_scale(float distortion, float distance_squared) -{ - return 1.0 / (1.0 + sqrt(max(0.0, 1.0 - distortion * distance_squared))); -} - -/* A vectorized version of compute_distortion_scale that is applied on the chromatic distortion - * parameters passed to the shader. */ -vec3 compute_chromatic_distortion_scale(float distance_squared) -{ - return 1.0 / (1.0 + sqrt(max(vec3(0.0), 1.0 - chromatic_distortion * distance_squared))); -} - -/* Compute the image coordinates after distortion by the given distortion scale computed by the - * compute_distortion_scale function. Note that the function expects centered normalized UV - * coordinates but outputs non-centered image coordinates. */ -vec2 compute_distorted_uv(vec2 uv, float scale) -{ - return (uv * scale + 0.5) * texture_size(input_tx) - 0.5; -} - -/* Compute the number of integration steps that should be used to approximate the distorted pixel - * using a heuristic, see the compute_number_of_steps function for more details. The numbers of - * steps is proportional to the number of pixels spanned by the distortion amount. For jitter - * distortion, the square root of the distortion amount plus 1 is used with a minimum of 2 steps. - * For non-jitter distortion, the distortion amount plus 1 is used as the number of steps */ -int compute_number_of_integration_steps_heuristic(float distortion) -{ -#if defined(JITTER) - return distortion < 4.0 ? 2 : int(sqrt(distortion + 1.0)); -#else - return int(distortion + 1.0); -#endif -} - -/* Compute the number of integration steps that should be used to compute each channel of the - * distorted pixel. Each of the channels are distorted by their respective chromatic distortion - * amount, then the amount of distortion between each two consecutive channels is computed, this - * amount is then used to heuristically infer the number of needed integration steps, see the - * integrate_distortion function for more information. */ -ivec3 compute_number_of_integration_steps(vec2 uv, float distance_squared) -{ - /* Distort each channel by its respective chromatic distortion amount. */ - vec3 distortion_scale = compute_chromatic_distortion_scale(distance_squared); - vec2 distorted_uv_red = compute_distorted_uv(uv, distortion_scale.r); - vec2 distorted_uv_green = compute_distorted_uv(uv, distortion_scale.g); - vec2 distorted_uv_blue = compute_distorted_uv(uv, distortion_scale.b); - - /* Infer the number of needed integration steps to compute the distorted red channel starting - * from the green channel. */ - float distortion_red = distance(distorted_uv_red, distorted_uv_green); - int steps_red = compute_number_of_integration_steps_heuristic(distortion_red); - - /* Infer the number of needed integration steps to compute the distorted blue channel starting - * from the green channel. */ - float distortion_blue = distance(distorted_uv_green, distorted_uv_blue); - int steps_blue = compute_number_of_integration_steps_heuristic(distortion_blue); - - /* The number of integration steps used to compute the green channel is the sum of both the red - * and the blue channel steps because it is computed once with each of them. */ - return ivec3(steps_red, steps_red + steps_blue, steps_blue); -} - -/* Returns a random jitter amount, which is essentially a random value in the [0, 1] range. If - * jitter is not enabled, return a constant 0.5 value instead. */ -float get_jitter(int seed) -{ -#if defined(JITTER) - return hash_uint3_to_float(gl_GlobalInvocationID.x, gl_GlobalInvocationID.y, seed); -#else - return 0.5; -#endif -} - -/* Each color channel may have a different distortion with the guarantee that the red will have the - * lowest distortion while the blue will have the highest one. If each channel is distorted - * independently, the image will look disintegrated, with each channel seemingly merely shifted. - * Consequently, the distorted pixels needs to be computed by integrating along the path of change - * of distortion starting from one channel to another. For instance, to compute the distorted red - * from the distorted green, we accumulate the color of the distorted pixel starting from the - * distortion of the red, taking small steps until we reach the distortion of the green. The pixel - * color is weighted such that it is maximum at the start distortion and zero at the end distortion - * in an arithmetic progression. The integration steps can be augmented with random values to - * simulate lens jitter. Finally, it should be noted that this function integrates both the start - * and end channels in reverse directions for more efficient computation. */ -vec3 integrate_distortion(int start, int end, float distance_squared, vec2 uv, int steps) -{ - vec3 accumulated_color = vec3(0.0); - float distortion_amount = chromatic_distortion[end] - chromatic_distortion[start]; - for (int i = 0; i < steps; i++) { - /* The increment will be in the [0, 1) range across iterations. */ - float increment = (i + get_jitter(i)) / steps; - float distortion = chromatic_distortion[start] + increment * distortion_amount; - float distortion_scale = compute_distortion_scale(distortion, distance_squared); - - /* Sample the color at the distorted coordinates and accumulate it weighted by the increment - * value for both the start and end channels. */ - vec2 distorted_uv = compute_distorted_uv(uv, distortion_scale); - vec4 color = texture(input_tx, distorted_uv / texture_size(input_tx)); - accumulated_color[start] += (1.0 - increment) * color[start]; - accumulated_color[end] += increment * color[end]; - } - return accumulated_color; -} - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - /* Compute the UV image coordinates in the range [-1, 1] as well as the squared distance to the - * center of the image, which is at (0, 0) in the UV coordinates. */ - vec2 center = texture_size(input_tx) / 2.0; - vec2 uv = scale * (texel + 0.5 - center) / center; - float distance_squared = dot(uv, uv); - - /* If any of the color channels will get distorted outside of the screen beyond what is possible, - * write a zero transparent color and return. */ - if (any(greaterThan(chromatic_distortion * distance_squared, vec3(1.0)))) { - imageStore(output_img, texel, vec4(0.0)); - return; - } - - /* Compute the number of integration steps that should be used to compute each channel of the - * distorted pixel. */ - ivec3 number_of_steps = compute_number_of_integration_steps(uv, distance_squared); - - /* Integrate the distortion of the red and green, then the green and blue channels. That means - * the green will be integrated twice, but this is accounted for in the number of steps which the - * color will later be divided by. See the compute_number_of_integration_steps function for more - * details. */ - vec3 color = vec3(0.0); - color += integrate_distortion(0, 1, distance_squared, uv, number_of_steps.r); - color += integrate_distortion(1, 2, distance_squared, uv, number_of_steps.b); - - /* The integration above performed weighted accumulation, and thus the color needs to be divided - * by the sum of the weights. Assuming no jitter, the weights are generated as an arithmetic - * progression starting from (0.5 / n) to ((n - 0.5) / n) for n terms. The sum of an arithmetic - * progression can be computed as (n * (start + end) / 2), which when subsisting the start and - * end reduces to (n / 2). So the color should be multiplied by 2 / n. The jitter sequence - * approximately sums to the same value because it is a uniform random value whose mean value is - * 0.5, so the expression doesn't change regardless of jitter. */ - color *= 2.0 / vec3(number_of_steps); - - imageStore(output_img, texel, vec4(color, 1.0)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_set_alpha.glsl b/source/blender/gpu/shaders/compositor/compositor_set_alpha.glsl deleted file mode 100644 index 7dd40581790..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_set_alpha.glsl +++ /dev/null @@ -1,8 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - vec4 color = vec4(texture_load(image_tx, texel).rgb, texture_load(alpha_tx, texel).x); - imageStore(output_img, texel, color); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_split_viewer.glsl b/source/blender/gpu/shaders/compositor/compositor_split_viewer.glsl deleted file mode 100644 index 866b9045da2..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_split_viewer.glsl +++ /dev/null @@ -1,14 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); -#if defined(SPLIT_HORIZONTAL) - bool condition = (view_size.x * split_ratio) < texel.x; -#elif defined(SPLIT_VERTICAL) - bool condition = (view_size.y * split_ratio) < texel.y; -#endif - vec4 color = condition ? texture_load(first_image_tx, texel) : - texture_load(second_image_tx, texel); - imageStore(output_img, texel, color); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_symmetric_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_symmetric_blur.glsl deleted file mode 100644 index df08991a35c..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_symmetric_blur.glsl +++ /dev/null @@ -1,77 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_blur_common.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -vec4 load_input(ivec2 texel) -{ - vec4 color; - if (extend_bounds) { - /* If bounds are extended, then we treat the input as padded by a radius amount of pixels. So - * we load the input with an offset by the radius amount and fallback to a transparent color if - * it is out of bounds. Notice that we subtract 1 because the weights texture have an extra - * center weight, see the SymmetricBlurWeights for more information. */ - ivec2 blur_size = texture_size(weights_tx) - 1; - color = texture_load(input_tx, texel - blur_size, vec4(0.0)); - } - else { - color = texture_load(input_tx, texel); - } - - if (gamma_correct) { - color = gamma_correct_blur_input(color); - } - - return color; -} - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - vec4 accumulated_color = vec4(0.0); - - /* First, compute the contribution of the center pixel. */ - vec4 center_color = load_input(texel); - accumulated_color += center_color * texture_load(weights_tx, ivec2(0)).x; - - ivec2 weights_size = texture_size(weights_tx); - - /* Then, compute the contributions of the pixels along the x axis of the filter, noting that the - * weights texture only stores the weights for the positive half, but since the filter is - * symmetric, the same weight is used for the negative half and we add both of their - * contributions. */ - for (int x = 1; x < weights_size.x; x++) { - float weight = texture_load(weights_tx, ivec2(x, 0)).x; - accumulated_color += load_input(texel + ivec2(x, 0)) * weight; - accumulated_color += load_input(texel + ivec2(-x, 0)) * weight; - } - - /* Then, compute the contributions of the pixels along the y axis of the filter, noting that the - * weights texture only stores the weights for the positive half, but since the filter is - * symmetric, the same weight is used for the negative half and we add both of their - * contributions. */ - for (int y = 1; y < weights_size.y; y++) { - float weight = texture_load(weights_tx, ivec2(0, y)).x; - accumulated_color += load_input(texel + ivec2(0, y)) * weight; - accumulated_color += load_input(texel + ivec2(0, -y)) * weight; - } - - /* Finally, compute the contributions of the pixels in the four quadrants of the filter, noting - * that the weights texture only stores the weights for the upper right quadrant, but since the - * filter is symmetric, the same weight is used for the rest of the quadrants and we add all four - * of their contributions. */ - for (int y = 1; y < weights_size.y; y++) { - for (int x = 1; x < weights_size.x; x++) { - float weight = texture_load(weights_tx, ivec2(x, y)).x; - accumulated_color += load_input(texel + ivec2(x, y)) * weight; - accumulated_color += load_input(texel + ivec2(-x, y)) * weight; - accumulated_color += load_input(texel + ivec2(x, -y)) * weight; - accumulated_color += load_input(texel + ivec2(-x, -y)) * weight; - } - } - - if (gamma_correct) { - accumulated_color = gamma_uncorrect_blur_output(accumulated_color); - } - - imageStore(output_img, texel, accumulated_color); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_symmetric_separable_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_symmetric_separable_blur.glsl deleted file mode 100644 index ab0c7baa787..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_symmetric_separable_blur.glsl +++ /dev/null @@ -1,53 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_blur_common.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -vec4 load_input(ivec2 texel) -{ - vec4 color; - if (extend_bounds) { - /* If bounds are extended, then we treat the input as padded by a radius amount of pixels. So - * we load the input with an offset by the radius amount and fallback to a transparent color if - * it is out of bounds. Notice that we subtract 1 because the weights texture have an extra - * center weight, see the SymmetricSeparableBlurWeights for more information. */ - int blur_size = texture_size(weights_tx) - 1; - color = texture_load(input_tx, texel - ivec2(blur_size, 0), vec4(0.0)); - } - else { - color = texture_load(input_tx, texel); - } - - if (gamma_correct_input) { - color = gamma_correct_blur_input(color); - } - - return color; -} - -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - vec4 accumulated_color = vec4(0.0); - - /* First, compute the contribution of the center pixel. */ - vec4 center_color = load_input(texel); - accumulated_color += center_color * texture_load(weights_tx, 0).x; - - /* Then, compute the contributions of the pixel to the right and left, noting that the - * weights texture only stores the weights for the positive half, but since the filter is - * symmetric, the same weight is used for the negative half and we add both of their - * contributions. */ - for (int i = 1; i < texture_size(weights_tx); i++) { - float weight = texture_load(weights_tx, i).x; - accumulated_color += load_input(texel + ivec2(i, 0)) * weight; - accumulated_color += load_input(texel + ivec2(-i, 0)) * weight; - } - - if (gamma_uncorrect_output) { - accumulated_color = gamma_uncorrect_blur_output(accumulated_color); - } - - /* Write the color using the transposed texel. See the execute_separable_blur_horizontal_pass - * method for more information on the rational behind this. */ - imageStore(output_img, texel.yx, accumulated_color); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_tone_map_photoreceptor.glsl b/source/blender/gpu/shaders/compositor/compositor_tone_map_photoreceptor.glsl deleted file mode 100644 index 167006585ca..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_tone_map_photoreceptor.glsl +++ /dev/null @@ -1,22 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) - -/* Tone mapping based on equation (1) and the trilinear interpolation between equations (6) and (7) - * from Reinhard, Erik, and Kate Devlin. "Dynamic range reduction inspired by photoreceptor - * physiology." IEEE transactions on visualization and computer graphics 11.1 (2005): 13-24. */ -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - vec4 input_color = texture_load(input_tx, texel); - float input_luminance = dot(input_color.rgb, luminance_coefficients); - - /* Trilinear interpolation between equations (6) and (7) from Reinhard's 2005 paper. */ - vec4 local_adaptation_level = mix(vec4(input_luminance), input_color, chromatic_adaptation); - vec4 adaptation_level = mix(global_adaptation_level, local_adaptation_level, light_adaptation); - - /* Equation (1) from Reinhard's 2005 paper, assuming Vmax is 1. */ - vec4 semi_saturation = pow(intensity * adaptation_level, vec4(contrast)); - vec4 tone_mapped_color = input_color / (input_color + semi_saturation); - - imageStore(output_img, texel, vec4(tone_mapped_color.rgb, input_color.a)); -} diff --git a/source/blender/gpu/shaders/compositor/compositor_tone_map_simple.glsl b/source/blender/gpu/shaders/compositor/compositor_tone_map_simple.glsl deleted file mode 100644 index ce42d021dd1..00000000000 --- a/source/blender/gpu/shaders/compositor/compositor_tone_map_simple.glsl +++ /dev/null @@ -1,26 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) - -/* Tone mapping based on equation (3) from Reinhard, Erik, et al. "Photographic tone reproduction - * for digital images." Proceedings of the 29th annual conference on Computer graphics and - * interactive techniques. 2002. */ -void main() -{ - ivec2 texel = ivec2(gl_GlobalInvocationID.xy); - - vec4 input_color = texture_load(input_tx, texel); - - /* Equation (2) from Reinhard's 2002 paper. */ - vec4 scaled_color = input_color * luminance_scale; - - /* Equation (3) from Reinhard's 2002 paper, but with the 1 replaced with the blend factor for - * more flexibility. See ToneMapOperation::compute_luminance_scale_blend_factor. */ - vec4 denominator = luminance_scale_blend_factor + scaled_color; - vec4 tone_mapped_color = safe_divide(scaled_color, denominator); - - if (inverse_gamma != 0.0) { - tone_mapped_color = pow(max(tone_mapped_color, vec4(0.0)), vec4(inverse_gamma)); - } - - imageStore(output_img, texel, vec4(tone_mapped_color.rgb, input_color.a)); -} diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_alpha_crop_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_alpha_crop_info.hh deleted file mode 100644 index 11f2f329cd8..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_alpha_crop_info.hh +++ /dev/null @@ -1,12 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_alpha_crop) - .local_group_size(16, 16) - .push_constant(Type::IVEC2, "lower_bound") - .push_constant(Type::IVEC2, "upper_bound") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_alpha_crop.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_bilateral_blur_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_bilateral_blur_info.hh deleted file mode 100644 index 301cd6acd9e..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_bilateral_blur_info.hh +++ /dev/null @@ -1,13 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_bilateral_blur) - .local_group_size(16, 16) - .push_constant(Type::INT, "radius") - .push_constant(Type::FLOAT, "threshold") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .sampler(1, ImageType::FLOAT_2D, "determinator_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_bilateral_blur.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_blur_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_blur_info.hh deleted file mode 100644 index 36b772aa486..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_blur_info.hh +++ /dev/null @@ -1,14 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_blur) - .local_group_size(16, 16) - .push_constant(Type::INT, "radius") - .push_constant(Type::BOOL, "extend_bounds") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .sampler(1, ImageType::FLOAT_2D, "weights_tx") - .sampler(2, ImageType::FLOAT_2D, "mask_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_blur.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_blur_variable_size_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_blur_variable_size_info.hh deleted file mode 100644 index 05b6385fd1e..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_blur_variable_size_info.hh +++ /dev/null @@ -1,15 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_blur_variable_size) - .local_group_size(16, 16) - .push_constant(Type::FLOAT, "base_size") - .push_constant(Type::INT, "search_radius") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .sampler(1, ImageType::FLOAT_2D, "weights_tx") - .sampler(2, ImageType::FLOAT_2D, "size_tx") - .sampler(3, ImageType::FLOAT_2D, "mask_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_blur_variable_size.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_bokeh_image_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_bokeh_image_info.hh deleted file mode 100644 index 3541de53070..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_bokeh_image_info.hh +++ /dev/null @@ -1,14 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_bokeh_image) - .local_group_size(16, 16) - .push_constant(Type::FLOAT, "exterior_angle") - .push_constant(Type::FLOAT, "rotation") - .push_constant(Type::FLOAT, "roundness") - .push_constant(Type::FLOAT, "catadioptric") - .push_constant(Type::FLOAT, "lens_shift") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_bokeh_image.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_box_mask_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_box_mask_info.hh deleted file mode 100644 index ecb253bbab1..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_box_mask_info.hh +++ /dev/null @@ -1,35 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_box_mask_shared) - .local_group_size(16, 16) - .push_constant(Type::IVEC2, "domain_size") - .push_constant(Type::VEC2, "location") - .push_constant(Type::VEC2, "size") - .push_constant(Type::FLOAT, "cos_angle") - .push_constant(Type::FLOAT, "sin_angle") - .sampler(0, ImageType::FLOAT_2D, "base_mask_tx") - .sampler(1, ImageType::FLOAT_2D, "mask_value_tx") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_mask_img") - .compute_source("compositor_box_mask.glsl"); - -GPU_SHADER_CREATE_INFO(compositor_box_mask_add) - .additional_info("compositor_box_mask_shared") - .define("CMP_NODE_MASKTYPE_ADD") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_box_mask_subtract) - .additional_info("compositor_box_mask_shared") - .define("CMP_NODE_MASKTYPE_SUBTRACT") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_box_mask_multiply) - .additional_info("compositor_box_mask_shared") - .define("CMP_NODE_MASKTYPE_MULTIPLY") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_box_mask_not) - .additional_info("compositor_box_mask_shared") - .define("CMP_NODE_MASKTYPE_NOT") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_convert_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_convert_info.hh deleted file mode 100644 index 35e60056736..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_convert_info.hh +++ /dev/null @@ -1,69 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_convert_shared) - .local_group_size(16, 16) - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .typedef_source("gpu_shader_compositor_type_conversion.glsl") - .compute_source("compositor_convert.glsl"); - -GPU_SHADER_CREATE_INFO(compositor_convert_float_to_vector) - .additional_info("compositor_convert_shared") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("CONVERT_EXPRESSION(value)", "vec4(vec3_from_float(value.x), 0.0)") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_convert_float_to_color) - .additional_info("compositor_convert_shared") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("CONVERT_EXPRESSION(value)", "vec4_from_float(value.x)") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_convert_color_to_float) - .additional_info("compositor_convert_shared") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("CONVERT_EXPRESSION(value)", "vec4(float_from_vec4(value), vec3(0.0))") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_convert_color_to_vector) - .additional_info("compositor_convert_shared") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("CONVERT_EXPRESSION(value)", "vec4(vec3_from_vec4(value), 0.0)") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_convert_vector_to_float) - .additional_info("compositor_convert_shared") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("CONVERT_EXPRESSION(value)", "vec4(float_from_vec3(value.xyz), vec3(0.0))") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_convert_vector_to_color) - .additional_info("compositor_convert_shared") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("CONVERT_EXPRESSION(value)", "vec4_from_vec3(value.xyz)") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_extract_alpha_from_color) - .additional_info("compositor_convert_shared") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("CONVERT_EXPRESSION(value)", "vec4(value.a, vec3(0.0))") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_convert_color_to_half_color) - .additional_info("compositor_convert_shared") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("CONVERT_EXPRESSION(value)", "value") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_convert_float_to_half_float) - .additional_info("compositor_convert_shared") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("CONVERT_EXPRESSION(value)", "vec4(value.r, vec3(0.0))") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_convert_color_to_opaque) - .additional_info("compositor_convert_shared") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("CONVERT_EXPRESSION(value)", "vec4(value.rgb, 1.0)") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_despeckle_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_despeckle_info.hh deleted file mode 100644 index df86c3a8258..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_despeckle_info.hh +++ /dev/null @@ -1,13 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_despeckle) - .local_group_size(16, 16) - .push_constant(Type::FLOAT, "threshold") - .push_constant(Type::FLOAT, "neighbor_threshold") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .sampler(1, ImageType::FLOAT_2D, "factor_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_despeckle.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_directional_blur_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_directional_blur_info.hh deleted file mode 100644 index bb9199dcd26..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_directional_blur_info.hh +++ /dev/null @@ -1,12 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_directional_blur) - .local_group_size(16, 16) - .push_constant(Type::INT, "iterations") - .push_constant(Type::MAT4, "inverse_transformation") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_directional_blur.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_edge_filter_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_edge_filter_info.hh deleted file mode 100644 index 916ec62bdba..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_edge_filter_info.hh +++ /dev/null @@ -1,12 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_edge_filter) - .local_group_size(16, 16) - .push_constant(Type::MAT4, "kernel") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .sampler(1, ImageType::FLOAT_2D, "factor_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_edge_filter.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_ellipse_mask_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_ellipse_mask_info.hh deleted file mode 100644 index 52db91c94e5..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_ellipse_mask_info.hh +++ /dev/null @@ -1,35 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_shared) - .local_group_size(16, 16) - .push_constant(Type::IVEC2, "domain_size") - .push_constant(Type::VEC2, "location") - .push_constant(Type::VEC2, "radius") - .push_constant(Type::FLOAT, "cos_angle") - .push_constant(Type::FLOAT, "sin_angle") - .sampler(0, ImageType::FLOAT_2D, "base_mask_tx") - .sampler(1, ImageType::FLOAT_2D, "mask_value_tx") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_mask_img") - .compute_source("compositor_ellipse_mask.glsl"); - -GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_add) - .additional_info("compositor_ellipse_mask_shared") - .define("CMP_NODE_MASKTYPE_ADD") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_subtract) - .additional_info("compositor_ellipse_mask_shared") - .define("CMP_NODE_MASKTYPE_SUBTRACT") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_multiply) - .additional_info("compositor_ellipse_mask_shared") - .define("CMP_NODE_MASKTYPE_MULTIPLY") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_ellipse_mask_not) - .additional_info("compositor_ellipse_mask_shared") - .define("CMP_NODE_MASKTYPE_NOT") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_filter_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_filter_info.hh deleted file mode 100644 index 9d565cf4b8a..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_filter_info.hh +++ /dev/null @@ -1,12 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_filter) - .local_group_size(16, 16) - .push_constant(Type::MAT4, "kernel") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .sampler(1, ImageType::FLOAT_2D, "factor_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_filter.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_flip_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_flip_info.hh deleted file mode 100644 index db831518cb7..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_flip_info.hh +++ /dev/null @@ -1,12 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_flip) - .local_group_size(16, 16) - .push_constant(Type::BOOL, "flip_x") - .push_constant(Type::BOOL, "flip_y") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_flip.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_image_crop_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_image_crop_info.hh deleted file mode 100644 index e7736744c40..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_image_crop_info.hh +++ /dev/null @@ -1,11 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_image_crop) - .local_group_size(16, 16) - .push_constant(Type::IVEC2, "lower_bound") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_image_crop.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_feather_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_feather_info.hh deleted file mode 100644 index 9f17f60129d..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_feather_info.hh +++ /dev/null @@ -1,21 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_morphological_distance_feather_shared) - .local_group_size(16, 16) - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .sampler(1, ImageType::FLOAT_1D, "weights_tx") - .sampler(2, ImageType::FLOAT_1D, "falloffs_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_morphological_distance_feather.glsl"); - -GPU_SHADER_CREATE_INFO(compositor_morphological_distance_feather_dilate) - .additional_info("compositor_morphological_distance_feather_shared") - .define("COMPARE(x, y)", "x > y") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_morphological_distance_feather_erode) - .additional_info("compositor_morphological_distance_feather_shared") - .define("COMPARE(x, y)", "x < y") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_info.hh deleted file mode 100644 index fc960e119e5..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_info.hh +++ /dev/null @@ -1,22 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_morphological_distance_shared) - .local_group_size(16, 16) - .push_constant(Type::INT, "radius") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_morphological_distance.glsl"); - -GPU_SHADER_CREATE_INFO(compositor_morphological_distance_dilate) - .additional_info("compositor_morphological_distance_shared") - .define("OPERATOR(a, b)", "max(a, b)") - .define("LIMIT", "FLT_MIN") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_morphological_distance_erode) - .additional_info("compositor_morphological_distance_shared") - .define("OPERATOR(a, b)", "min(a, b)") - .define("LIMIT", "FLT_MAX") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_threshold_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_threshold_info.hh deleted file mode 100644 index b1d64f61b80..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_distance_threshold_info.hh +++ /dev/null @@ -1,13 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_morphological_distance_threshold) - .local_group_size(16, 16) - .push_constant(Type::INT, "radius") - .push_constant(Type::INT, "distance") - .push_constant(Type::FLOAT, "inset") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_morphological_distance_threshold.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_step_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_morphological_step_info.hh deleted file mode 100644 index e97ffd9feea..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_morphological_step_info.hh +++ /dev/null @@ -1,22 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_morphological_step_shared) - .local_group_size(16, 16) - .push_constant(Type::INT, "radius") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_morphological_step.glsl"); - -GPU_SHADER_CREATE_INFO(compositor_morphological_step_dilate) - .additional_info("compositor_morphological_step_shared") - .define("OPERATOR(a, b)", "max(a, b)") - .define("LIMIT", "FLT_MIN") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_morphological_step_erode) - .additional_info("compositor_morphological_step_shared") - .define("OPERATOR(a, b)", "min(a, b)") - .define("LIMIT", "FLT_MAX") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_normalize_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_normalize_info.hh deleted file mode 100644 index 02fdc424014..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_normalize_info.hh +++ /dev/null @@ -1,12 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_normalize) - .local_group_size(16, 16) - .push_constant(Type::FLOAT, "minimum") - .push_constant(Type::FLOAT, "scale") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_normalize.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_parallel_reduction_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_parallel_reduction_info.hh deleted file mode 100644 index e2252b14758..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_parallel_reduction_info.hh +++ /dev/null @@ -1,149 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_parallel_reduction_shared) - .local_group_size(16, 16) - .push_constant(Type::BOOL, "is_initial_reduction") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .compute_source("compositor_parallel_reduction.glsl"); - -/* -------------------------------------------------------------------- - * Sum Reductions. - */ - -GPU_SHADER_CREATE_INFO(compositor_sum_shared) - .additional_info("compositor_parallel_reduction_shared") - .define("IDENTITY", "vec4(0.0)") - .define("REDUCE(lhs, rhs)", "lhs + rhs"); - -GPU_SHADER_CREATE_INFO(compositor_sum_float_shared) - .additional_info("compositor_sum_shared") - .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("TYPE", "float") - .define("LOAD(value)", "value.x"); - -GPU_SHADER_CREATE_INFO(compositor_sum_red) - .additional_info("compositor_sum_float_shared") - .define("INITIALIZE(value)", "value.r") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_sum_green) - .additional_info("compositor_sum_float_shared") - .define("INITIALIZE(value)", "value.g") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_sum_blue) - .additional_info("compositor_sum_float_shared") - .define("INITIALIZE(value)", "value.b") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_sum_luminance) - .additional_info("compositor_sum_float_shared") - .push_constant(Type::VEC3, "luminance_coefficients") - .define("INITIALIZE(value)", "dot(value.rgb, luminance_coefficients)") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_sum_log_luminance) - .additional_info("compositor_sum_float_shared") - .push_constant(Type::VEC3, "luminance_coefficients") - .define("INITIALIZE(value)", "log(max(dot(value.rgb, luminance_coefficients), 1e-5))") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_sum_color) - .additional_info("compositor_sum_shared") - .image(0, GPU_RGBA32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .define("TYPE", "vec4") - .define("INITIALIZE(value)", "value") - .define("LOAD(value)", "value") - .do_static_compilation(true); - -/* -------------------------------------------------------------------- - * Sum Of Squared Difference Reductions. - */ - -GPU_SHADER_CREATE_INFO(compositor_sum_squared_difference_float_shared) - .additional_info("compositor_parallel_reduction_shared") - .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .push_constant(Type::FLOAT, "subtrahend") - .define("TYPE", "float") - .define("IDENTITY", "vec4(subtrahend)") - .define("LOAD(value)", "value.x") - .define("REDUCE(lhs, rhs)", "lhs + rhs"); - -GPU_SHADER_CREATE_INFO(compositor_sum_red_squared_difference) - .additional_info("compositor_sum_squared_difference_float_shared") - .define("INITIALIZE(value)", "pow(value.r - subtrahend, 2.0)") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_sum_green_squared_difference) - .additional_info("compositor_sum_squared_difference_float_shared") - .define("INITIALIZE(value)", "pow(value.g - subtrahend, 2.0)") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_sum_blue_squared_difference) - .additional_info("compositor_sum_squared_difference_float_shared") - .define("INITIALIZE(value)", "pow(value.b - subtrahend, 2.0)") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_sum_luminance_squared_difference) - .additional_info("compositor_sum_squared_difference_float_shared") - .push_constant(Type::VEC3, "luminance_coefficients") - .define("INITIALIZE(value)", "pow(dot(value.rgb, luminance_coefficients) - subtrahend, 2.0)") - .do_static_compilation(true); - -/* -------------------------------------------------------------------- - * Maximum Reductions. - */ - -GPU_SHADER_CREATE_INFO(compositor_maximum_luminance) - .additional_info("compositor_parallel_reduction_shared") - .typedef_source("common_math_lib.glsl") - .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .push_constant(Type::VEC3, "luminance_coefficients") - .define("TYPE", "float") - .define("IDENTITY", "vec4(FLT_MIN)") - .define("INITIALIZE(value)", "dot(value.rgb, luminance_coefficients)") - .define("LOAD(value)", "value.x") - .define("REDUCE(lhs, rhs)", "max(lhs, rhs)") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_maximum_float_in_range) - .additional_info("compositor_parallel_reduction_shared") - .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .push_constant(Type::FLOAT, "lower_bound") - .push_constant(Type::FLOAT, "upper_bound") - .define("TYPE", "float") - .define("IDENTITY", "vec4(lower_bound)") - .define("INITIALIZE(v)", "((v.x <= upper_bound) && (v.x >= lower_bound)) ? v.x : lower_bound") - .define("LOAD(value)", "value.x") - .define("REDUCE(lhs, rhs)", "((rhs > lhs) && (rhs <= upper_bound)) ? rhs : lhs") - .do_static_compilation(true); - -/* -------------------------------------------------------------------- - * Minimum Reductions. - */ - -GPU_SHADER_CREATE_INFO(compositor_minimum_luminance) - .additional_info("compositor_parallel_reduction_shared") - .typedef_source("common_math_lib.glsl") - .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .push_constant(Type::VEC3, "luminance_coefficients") - .define("TYPE", "float") - .define("IDENTITY", "vec4(FLT_MAX)") - .define("INITIALIZE(value)", "dot(value.rgb, luminance_coefficients)") - .define("LOAD(value)", "value.x") - .define("REDUCE(lhs, rhs)", "min(lhs, rhs)") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_minimum_float_in_range) - .additional_info("compositor_parallel_reduction_shared") - .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .push_constant(Type::FLOAT, "lower_bound") - .push_constant(Type::FLOAT, "upper_bound") - .define("TYPE", "float") - .define("IDENTITY", "vec4(upper_bound)") - .define("INITIALIZE(v)", "((v.x <= upper_bound) && (v.x >= lower_bound)) ? v.x : upper_bound") - .define("LOAD(value)", "value.x") - .define("REDUCE(lhs, rhs)", "((rhs < lhs) && (rhs >= lower_bound)) ? rhs : lhs") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_projector_lens_distortion_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_projector_lens_distortion_info.hh deleted file mode 100644 index 98fe1731703..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_projector_lens_distortion_info.hh +++ /dev/null @@ -1,11 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_projector_lens_distortion) - .local_group_size(16, 16) - .push_constant(Type::FLOAT, "dispersion") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_projector_lens_distortion.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_realize_on_domain_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_realize_on_domain_info.hh deleted file mode 100644 index 4528649ae98..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_realize_on_domain_info.hh +++ /dev/null @@ -1,24 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_shared) - .local_group_size(16, 16) - .push_constant(Type::MAT4, "inverse_transformation") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .compute_source("compositor_realize_on_domain.glsl"); - -GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_color) - .additional_info("compositor_realize_on_domain_shared") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "domain_img") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_vector) - .additional_info("compositor_realize_on_domain_shared") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "domain_img") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_realize_on_domain_float) - .additional_info("compositor_realize_on_domain_shared") - .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "domain_img") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_screen_lens_distortion_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_screen_lens_distortion_info.hh deleted file mode 100644 index c42f2b328d4..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_screen_lens_distortion_info.hh +++ /dev/null @@ -1,20 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_screen_lens_distortion_shared) - .local_group_size(16, 16) - .push_constant(Type::VEC3, "chromatic_distortion") - .push_constant(Type::FLOAT, "scale") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_screen_lens_distortion.glsl"); - -GPU_SHADER_CREATE_INFO(compositor_screen_lens_distortion) - .additional_info("compositor_screen_lens_distortion_shared") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_screen_lens_distortion_jitter) - .additional_info("compositor_screen_lens_distortion_shared") - .define("JITTER") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_set_alpha_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_set_alpha_info.hh deleted file mode 100644 index ca28194e921..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_set_alpha_info.hh +++ /dev/null @@ -1,11 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_set_alpha) - .local_group_size(16, 16) - .sampler(0, ImageType::FLOAT_2D, "image_tx") - .sampler(1, ImageType::FLOAT_2D, "alpha_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_set_alpha.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_split_viewer_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_split_viewer_info.hh deleted file mode 100644 index d5793b0ce59..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_split_viewer_info.hh +++ /dev/null @@ -1,22 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_split_viewer_shared) - .local_group_size(16, 16) - .push_constant(Type::FLOAT, "split_ratio") - .push_constant(Type::IVEC2, "view_size") - .sampler(0, ImageType::FLOAT_2D, "first_image_tx") - .sampler(1, ImageType::FLOAT_2D, "second_image_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_split_viewer.glsl"); - -GPU_SHADER_CREATE_INFO(compositor_split_viewer_horizontal) - .additional_info("compositor_split_viewer_shared") - .define("SPLIT_HORIZONTAL") - .do_static_compilation(true); - -GPU_SHADER_CREATE_INFO(compositor_split_viewer_vertical) - .additional_info("compositor_split_viewer_shared") - .define("SPLIT_VERTICAL") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_blur_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_blur_info.hh deleted file mode 100644 index 8ba2b4e04ef..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_blur_info.hh +++ /dev/null @@ -1,13 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_symmetric_blur) - .local_group_size(16, 16) - .push_constant(Type::BOOL, "extend_bounds") - .push_constant(Type::BOOL, "gamma_correct") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .sampler(1, ImageType::FLOAT_2D, "weights_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_symmetric_blur.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_separable_blur_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_separable_blur_info.hh deleted file mode 100644 index 57247dba4b8..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_symmetric_separable_blur_info.hh +++ /dev/null @@ -1,14 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_symmetric_separable_blur) - .local_group_size(16, 16) - .push_constant(Type::BOOL, "extend_bounds") - .push_constant(Type::BOOL, "gamma_correct_input") - .push_constant(Type::BOOL, "gamma_uncorrect_output") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .sampler(1, ImageType::FLOAT_1D, "weights_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_symmetric_separable_blur.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_photoreceptor_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_photoreceptor_info.hh deleted file mode 100644 index a460c9d58a6..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_photoreceptor_info.hh +++ /dev/null @@ -1,16 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_tone_map_photoreceptor) - .local_group_size(16, 16) - .push_constant(Type::VEC4, "global_adaptation_level") - .push_constant(Type::FLOAT, "contrast") - .push_constant(Type::FLOAT, "intensity") - .push_constant(Type::FLOAT, "chromatic_adaptation") - .push_constant(Type::FLOAT, "light_adaptation") - .push_constant(Type::VEC3, "luminance_coefficients") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_tone_map_photoreceptor.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_simple_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_simple_info.hh deleted file mode 100644 index 2b220af9460..00000000000 --- a/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_simple_info.hh +++ /dev/null @@ -1,13 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -#include "gpu_shader_create_info.hh" - -GPU_SHADER_CREATE_INFO(compositor_tone_map_simple) - .local_group_size(16, 16) - .push_constant(Type::FLOAT, "luminance_scale") - .push_constant(Type::FLOAT, "luminance_scale_blend_factor") - .push_constant(Type::FLOAT, "inverse_gamma") - .sampler(0, ImageType::FLOAT_2D, "input_tx") - .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img") - .compute_source("compositor_tone_map_simple.glsl") - .do_static_compilation(true); diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_alpha_over.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_alpha_over.glsl deleted file mode 100644 index 8e3e033147f..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_alpha_over.glsl +++ /dev/null @@ -1,48 +0,0 @@ -void node_composite_alpha_over_mixed( - float factor, vec4 color, vec4 over_color, float premultiply_factor, out vec4 result) -{ - if (over_color.a <= 0.0) { - result = color; - } - else if (factor == 1.0 && over_color.a >= 1.0) { - result = over_color; - } - else { - float add_factor = 1.0 - premultiply_factor + over_color.a * premultiply_factor; - float premultiplier = factor * add_factor; - float multiplier = 1.0 - factor * over_color.a; - - result = multiplier * color + vec2(premultiplier, factor).xxxy * over_color; - } -} - -void node_composite_alpha_over_key(float factor, vec4 color, vec4 over_color, out vec4 result) -{ - if (over_color.a <= 0.0) { - result = color; - } - else if (factor == 1.0 && over_color.a >= 1.0) { - result = over_color; - } - else { - result = mix(color, vec4(over_color.rgb, 1.0), factor * over_color.a); - } -} - -void node_composite_alpha_over_premultiply(float factor, - vec4 color, - vec4 over_color, - out vec4 result) -{ - if (over_color.a < 0.0) { - result = color; - } - else if (factor == 1.0 && over_color.a >= 1.0) { - result = over_color; - } - else { - float multiplier = 1.0 - factor * over_color.a; - - result = multiplier * color + factor * over_color; - } -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_blur_common.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_blur_common.glsl deleted file mode 100644 index e404c03bbb0..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_blur_common.glsl +++ /dev/null @@ -1,32 +0,0 @@ -/* Preprocess the input of the blur filter by squaring it in its alpha straight form, assuming the - * given color is alpha premultiplied. */ -vec4 gamma_correct_blur_input(vec4 color) -{ - /* Unpremultiply alpha. */ - color.rgb /= color.a > 0.0 ? color.a : 1.0; - - /* Square color channel if it is positive, otherwise zero it. */ - color.rgb *= mix(color.rgb, vec3(0.0), lessThan(color.rgb, vec3(0.0))); - - /* Premultiply alpha to undo previous alpha unpremultiplication. */ - color.rgb *= color.a > 0.0 ? color.a : 1.0; - - return color; -} - -/* Postprocess the output of the blur filter by taking its square root it in its alpha straight - * form, assuming the given color is alpha premultiplied. This essential undoes the processing done - * by the gamma_correct_blur_input function. */ -vec4 gamma_uncorrect_blur_output(vec4 color) -{ - /* Unpremultiply alpha. */ - color.rgb /= color.a > 0.0 ? color.a : 1.0; - - /* Take the square root of the color channel if it is positive, otherwise zero it. */ - color.rgb = mix(sqrt(color.rgb), vec3(0.0), lessThan(color.rgb, vec3(0.0))); - - /* Premultiply alpha to undo previous alpha unpremultiplication. */ - color.rgb *= color.a > 0.0 ? color.a : 1.0; - - return color; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_bright_contrast.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_bright_contrast.glsl deleted file mode 100644 index ce71b4fd8a4..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_bright_contrast.glsl +++ /dev/null @@ -1,38 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -/* The algorithm is by Werner D. Streidt - * (http://visca.com/ffactory/archives/5-99/msg00021.html) - * Extracted of OpenCV demhist.c - */ - -#define FLT_EPSILON 1.192092896e-07F - -void node_composite_bright_contrast( - vec4 color, float brightness, float contrast, const float use_premultiply, out vec4 result) -{ - brightness /= 100.0; - float delta = contrast / 200.0; - - float multiplier, offset; - if (contrast > 0.0) { - multiplier = 1.0 - delta * 2.0; - multiplier = 1.0 / max(multiplier, FLT_EPSILON); - offset = multiplier * (brightness - delta); - } - else { - delta *= -1.0; - multiplier = max(1.0 - delta * 2.0, 0.0); - offset = multiplier * brightness + delta; - } - - if (use_premultiply != 0.0) { - color_alpha_unpremultiply(color, color); - } - - result.rgb = color.rgb * multiplier + offset; - result.a = color.a; - - if (use_premultiply != 0.0) { - color_alpha_premultiply(result, result); - } -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_channel_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_channel_matte.glsl deleted file mode 100644 index f2dcc9543f2..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_channel_matte.glsl +++ /dev/null @@ -1,52 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -#define CMP_NODE_CHANNEL_MATTE_CS_RGB 1.0 -#define CMP_NODE_CHANNEL_MATTE_CS_HSV 2.0 -#define CMP_NODE_CHANNEL_MATTE_CS_YUV 3.0 -#define CMP_NODE_CHANNEL_MATTE_CS_YCC 4.0 - -void node_composite_channel_matte(vec4 color, - const float color_space, - const float matte_channel, - const vec2 limit_channels, - float max_limit, - float min_limit, - out vec4 result, - out float matte) -{ - vec4 channels; - if (color_space == CMP_NODE_CHANNEL_MATTE_CS_HSV) { - rgb_to_hsv(color, channels); - } - else if (color_space == CMP_NODE_CHANNEL_MATTE_CS_YUV) { - rgba_to_yuva_itu_709(color, channels); - } - else if (color_space == CMP_NODE_CHANNEL_MATTE_CS_YCC) { - rgba_to_ycca_itu_709(color, channels); - } - else { - channels = color; - } - - float matte_value = channels[int(matte_channel)]; - float limit_value = max(channels[int(limit_channels.x)], channels[int(limit_channels.y)]); - - float alpha = 1.0 - (matte_value - limit_value); - if (alpha > max_limit) { - alpha = color.a; - } - else if (alpha < min_limit) { - alpha = 0.0; - } - else { - alpha = (alpha - min_limit) / (max_limit - min_limit); - } - - matte = min(alpha, color.a); - result = color * matte; -} - -#undef CMP_NODE_CHANNEL_MATTE_CS_RGB -#undef CMP_NODE_CHANNEL_MATTE_CS_HSV -#undef CMP_NODE_CHANNEL_MATTE_CS_YUV -#undef CMP_NODE_CHANNEL_MATTE_CS_YCC diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_chroma_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_chroma_matte.glsl deleted file mode 100644 index 5d6bea0c9db..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_chroma_matte.glsl +++ /dev/null @@ -1,43 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -/* Algorithm from the book Video Demystified. Chapter 7. Chroma Keying. */ -void node_composite_chroma_matte(vec4 color, - vec4 key, - float acceptance, - float cutoff, - float falloff, - out vec4 result, - out float matte) -{ - vec4 color_ycca; - rgba_to_ycca_itu_709(color, color_ycca); - vec4 key_ycca; - rgba_to_ycca_itu_709(key, key_ycca); - - /* Normalize the CrCb components into the [-1, 1] range. */ - vec2 color_cc = color_ycca.yz * 2.0 - 1.0; - vec2 key_cc = key_ycca.yz * 2.0 - 1.0; - - /* Rotate the color onto the space of the key such that x axis of the color space passes through - * the key color. */ - color_cc = vector_to_rotation_matrix(key_cc * vec2(1.0, -1.0)) * color_cc; - - /* Compute foreground key. If positive, the value is in the [0, 1] range. */ - float foreground_key = color_cc.x - (abs(color_cc.y) / acceptance); - - /* Negative foreground key values retain the original alpha. Positive values are scaled by the - * falloff, while colors that make an angle less than the cutoff angle get a zero alpha. */ - float alpha = color.a; - if (foreground_key > 0.0) { - alpha = 1.0 - (foreground_key / falloff); - - if (abs(atan(color_cc.y, color_cc.x)) < (cutoff / 2.0)) { - alpha = 0.0; - } - } - - /* Compute output. */ - matte = min(alpha, color.a); - result = color * matte; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_balance.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_balance.glsl deleted file mode 100644 index bffb94cdedb..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_balance.glsl +++ /dev/null @@ -1,34 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -void node_composite_color_balance_lgg( - float factor, vec4 color, vec3 lift, vec3 gamma, vec3 gain, out vec4 result) -{ - lift = 2.0 - lift; - vec3 srgb_color = linear_rgb_to_srgb(color.rgb); - vec3 lift_balanced = ((srgb_color - 1.0) * lift) + 1.0; - - vec3 gain_balanced = lift_balanced * gain; - gain_balanced = max(gain_balanced, vec3(0.0)); - - vec3 linear_color = srgb_to_linear_rgb(gain_balanced); - gamma = mix(gamma, vec3(1e-6), equal(gamma, vec3(0.0))); - vec3 gamma_balanced = pow(linear_color, 1.0 / gamma); - - result.rgb = mix(color.rgb, gamma_balanced, min(factor, 1.0)); - result.a = color.a; -} - -void node_composite_color_balance_asc_cdl(float factor, - vec4 color, - vec3 offset, - vec3 power, - vec3 slope, - float offset_basis, - out vec4 result) -{ - offset += offset_basis; - vec3 balanced = color.rgb * slope + offset; - balanced = pow(max(balanced, vec3(0.0)), power); - result.rgb = mix(color.rgb, balanced, min(factor, 1.0)); - result.a = color.a; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_correction.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_correction.glsl deleted file mode 100644 index 9b4858f03be..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_correction.glsl +++ /dev/null @@ -1,87 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -void node_composite_color_correction(vec4 color, - float mask, - const vec3 enabled_channels, - float start_midtones, - float end_midtones, - float master_saturation, - float master_contrast, - float master_gamma, - float master_gain, - float master_lift, - float shadows_saturation, - float shadows_contrast, - float shadows_gamma, - float shadows_gain, - float shadows_lift, - float midtones_saturation, - float midtones_contrast, - float midtones_gamma, - float midtones_gain, - float midtones_lift, - float highlights_saturation, - float highlights_contrast, - float highlights_gamma, - float highlights_gain, - float highlights_lift, - const vec3 luminance_coefficients, - out vec4 result) -{ - const float margin = 0.10; - const float margin_divider = 0.5 / margin; - float level = (color.r + color.g + color.b) / 3.0; - float level_shadows = 0.0; - float level_midtones = 0.0; - float level_highlights = 0.0; - if (level < (start_midtones - margin)) { - level_shadows = 1.0; - } - else if (level < (start_midtones + margin)) { - level_midtones = ((level - start_midtones) * margin_divider) + 0.5; - level_shadows = 1.0 - level_midtones; - } - else if (level < (end_midtones - margin)) { - level_midtones = 1.0; - } - else if (level < (end_midtones + margin)) { - level_highlights = ((level - end_midtones) * margin_divider) + 0.5; - level_midtones = 1.0 - level_highlights; - } - else { - level_highlights = 1.0; - } - - float contrast = level_shadows * shadows_contrast; - contrast += level_midtones * midtones_contrast; - contrast += level_highlights * highlights_contrast; - contrast *= master_contrast; - float saturation = level_shadows * shadows_saturation; - saturation += level_midtones * midtones_saturation; - saturation += level_highlights * highlights_saturation; - saturation *= master_saturation; - float gamma = level_shadows * shadows_gamma; - gamma += level_midtones * midtones_gamma; - gamma += level_highlights * highlights_gamma; - gamma *= master_gamma; - float gain = level_shadows * shadows_gain; - gain += level_midtones * midtones_gain; - gain += level_highlights * highlights_gain; - gain *= master_gain; - float lift = level_shadows * shadows_lift; - lift += level_midtones * midtones_lift; - lift += level_highlights * highlights_lift; - lift += master_lift; - - float inverse_gamma = 1.0 / gamma; - float luma = get_luminance(color.rgb, luminance_coefficients); - - vec3 corrected = luma + saturation * (color.rgb - luma); - corrected = 0.5 + (corrected - 0.5) * contrast; - corrected = fallback_pow(corrected * gain + lift, inverse_gamma, corrected); - corrected = mix(color.rgb, corrected, min(mask, 1.0)); - - result.rgb = mix(corrected, color.rgb, equal(enabled_channels, vec3(0.0))); - result.a = color.a; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_matte.glsl deleted file mode 100644 index 038471bc1bc..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_matte.glsl +++ /dev/null @@ -1,27 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -void node_composite_color_matte(vec4 color, - vec4 key, - float hue_epsilon, - float saturation_epsilon, - float value_epsilon, - out vec4 result, - out float matte) - -{ - vec4 color_hsva; - rgb_to_hsv(color, color_hsva); - vec4 key_hsva; - rgb_to_hsv(key, key_hsva); - - bool is_within_saturation = distance(color_hsva.y, key_hsva.y) < saturation_epsilon; - bool is_within_value = distance(color_hsva.z, key_hsva.z) < value_epsilon; - bool is_within_hue = distance(color_hsva.x, key_hsva.x) < hue_epsilon; - /* Hue wraps around, so check the distance around the boundary. */ - float min_hue = min(color_hsva.x, key_hsva.x); - float max_hue = max(color_hsva.x, key_hsva.x); - is_within_hue = is_within_hue || ((min_hue + (1.0 - max_hue)) < hue_epsilon); - - matte = (is_within_hue && is_within_saturation && is_within_value) ? 0.0 : color.a; - result = color * matte; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_spill.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_spill.glsl deleted file mode 100644 index 0adad53ad80..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_spill.glsl +++ /dev/null @@ -1,13 +0,0 @@ -void node_composite_color_spill(vec4 color, - float factor, - const float spill_channel, - vec3 spill_scale, - const vec2 limit_channels, - float limit_scale, - out vec4 result) -{ - float average_limit = (color[int(limit_channels.x)] + color[int(limit_channels.y)]) / 2.0; - float map = factor * color[int(spill_channel)] - limit_scale * average_limit; - result.rgb = map > 0.0 ? color.rgb + spill_scale * map : color.rgb; - result.a = color.a; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_to_luminance.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_to_luminance.glsl deleted file mode 100644 index bcdd625bd4f..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_color_to_luminance.glsl +++ /dev/null @@ -1,6 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -void color_to_luminance(vec4 color, const vec3 luminance_coefficients, out float result) -{ - result = get_luminance(color.rgb, luminance_coefficients); -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_difference_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_difference_matte.glsl deleted file mode 100644 index d769cadce3c..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_difference_matte.glsl +++ /dev/null @@ -1,10 +0,0 @@ -void node_composite_difference_matte( - vec4 color, vec4 key, float tolerance, float falloff, out vec4 result, out float matte) -{ - vec4 difference = abs(color - key); - float average_difference = (difference.r + difference.g + difference.b) / 3.0; - bool is_opaque = average_difference > tolerance + falloff; - float alpha = is_opaque ? color.a : (max(0.0, average_difference - tolerance) / falloff); - matte = min(alpha, color.a); - result = color * matte; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_distance_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_distance_matte.glsl deleted file mode 100644 index 9beed66826c..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_distance_matte.glsl +++ /dev/null @@ -1,26 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -void node_composite_distance_matte_rgba( - vec4 color, vec4 key, float tolerance, float falloff, out vec4 result, out float matte) -{ - float difference = distance(color.rgb, key.rgb); - bool is_opaque = difference > tolerance + falloff; - float alpha = is_opaque ? color.a : max(0.0, difference - tolerance) / falloff; - matte = min(alpha, color.a); - result = color * matte; -} - -void node_composite_distance_matte_ycca( - vec4 color, vec4 key, float tolerance, float falloff, out vec4 result, out float matte) -{ - vec4 color_ycca; - rgba_to_ycca_itu_709(color, color_ycca); - vec4 key_ycca; - rgba_to_ycca_itu_709(key, key_ycca); - - float difference = distance(color_ycca.yz, key_ycca.yz); - bool is_opaque = difference > tolerance + falloff; - float alpha = is_opaque ? color.a : max(0.0, difference - tolerance) / falloff; - matte = min(alpha, color.a); - result = color * matte; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_exposure.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_exposure.glsl deleted file mode 100644 index f246635a91e..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_exposure.glsl +++ /dev/null @@ -1,6 +0,0 @@ -void node_composite_exposure(vec4 color, float exposure, out vec4 result) -{ - float multiplier = exp2(exposure); - result.rgb = color.rgb * multiplier; - result.a = color.a; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_gamma.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_gamma.glsl deleted file mode 100644 index 53070d4b0e2..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_gamma.glsl +++ /dev/null @@ -1,7 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl) - -void node_composite_gamma(vec4 color, float gamma, out vec4 result) -{ - result.rgb = fallback_pow(color.rgb, gamma, color.rgb); - result.a = color.a; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_correct.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_correct.glsl deleted file mode 100644 index 99eb125cdf2..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_correct.glsl +++ /dev/null @@ -1,39 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -/* Curve maps are stored in sampler objects that are evaluated in the [0, 1] range, so normalize - * parameters accordingly. */ -#define NORMALIZE_PARAMETER(parameter, minimum, range) ((parameter - minimum) * range) - -void node_composite_hue_correct(float factor, - vec4 color, - sampler1DArray curve_map, - const float layer, - vec3 minimums, - vec3 range_dividers, - out vec4 result) -{ - vec4 hsv; - rgb_to_hsv(color, hsv); - - /* First, adjust the hue channel on its own, since corrections in the saturation and value - * channels depends on the new value of the hue, not its original value. A curve map value of 0.5 - * means no change in hue, so adjust the value to get an identity at 0.5. Since the identity of - * addition is 0, we subtract 0.5 (0.5 - 0.5 = 0). */ - const float hue_parameter = NORMALIZE_PARAMETER(hsv.x, minimums.x, range_dividers.x); - hsv.x += texture(curve_map, vec2(hue_parameter, layer)).x - 0.5; - - /* Second, adjust the saturation and value based on the new value of the hue. A curve map value - * of 0.5 means no change in hue, so adjust the value to get an identity at 0.5. Since the - * identity of duplication is 1, we multiply by 2 (0.5 * 2 = 1). */ - vec2 parameters = NORMALIZE_PARAMETER(hsv.x, minimums.yz, range_dividers.yz); - hsv.y *= texture(curve_map, vec2(parameters.x, layer)).y * 2.0; - hsv.z *= texture(curve_map, vec2(parameters.y, layer)).z * 2.0; - - /* Sanitize the new hue and saturation values. */ - hsv.x = fract(hsv.x); - hsv.y = clamp(hsv.y, 0.0, 1.0); - - hsv_to_rgb(hsv, result); - - result = mix(color, result, factor); -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_saturation_value.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_saturation_value.glsl deleted file mode 100644 index dd5eb33d318..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_hue_saturation_value.glsl +++ /dev/null @@ -1,16 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -void node_composite_hue_saturation_value( - vec4 color, float hue, float saturation, float value, float factor, out vec4 result) -{ - vec4 hsv; - rgb_to_hsv(color, hsv); - - hsv.x = fract(hsv.x + hue + 0.5); - hsv.y = clamp(hsv.y * saturation, 0.0, 1.0); - hsv.z = hsv.z * value; - - hsv_to_rgb(hsv, result); - - result = mix(color, result, factor); -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_invert.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_invert.glsl deleted file mode 100644 index 59be746da7f..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_invert.glsl +++ /dev/null @@ -1,13 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -void node_composite_invert(float fac, vec4 color, float do_rgb, float do_alpha, out vec4 result) -{ - result = color; - if (do_rgb != 0.0) { - result.rgb = 1.0 - result.rgb; - } - if (do_alpha != 0.0) { - result.a = 1.0 - result.a; - } - result = mix(color, result, fac); -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_luminance_matte.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_luminance_matte.glsl deleted file mode 100644 index 3647ac583fe..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_luminance_matte.glsl +++ /dev/null @@ -1,14 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -void node_composite_luminance_matte(vec4 color, - float high, - float low, - const vec3 luminance_coefficients, - out vec4 result, - out float matte) -{ - float luminance = get_luminance(color.rgb, luminance_coefficients); - float alpha = clamp(0.0, 1.0, (luminance - low) / (high - low)); - matte = min(alpha, color.a); - result = color * matte; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_main.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_main.glsl deleted file mode 100644 index 27624223dbc..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_main.glsl +++ /dev/null @@ -1,7 +0,0 @@ -/* The compute shader that will be dispatched by the compositor ShaderOperation. It just calls the - * evaluate function that will be dynamically generated and appended to this shader in the - * ShaderOperation::generate_code method. */ -void main() -{ - evaluate(); -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_map_value.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_map_value.glsl deleted file mode 100644 index 20874b4ef44..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_map_value.glsl +++ /dev/null @@ -1,56 +0,0 @@ -/* An arbitrary value determined by Blender. */ -#define BLENDER_ZMAX 10000.0 - -void node_composite_map_range(float value, - float from_min, - float from_max, - float to_min, - float to_max, - const float should_clamp, - out float result) -{ - if (abs(from_max - from_min) < 1e-6) { - result = 0.0; - } - else { - if (value >= -BLENDER_ZMAX && value <= BLENDER_ZMAX) { - result = (value - from_min) / (from_max - from_min); - result = to_min + result * (to_max - to_min); - } - else if (value > BLENDER_ZMAX) { - result = to_max; - } - else { - result = to_min; - } - - if (should_clamp != 0.0) { - if (to_max > to_min) { - result = clamp(result, to_min, to_max); - } - else { - result = clamp(result, to_max, to_min); - } - } - } -} - -void node_composite_map_value(float value, - float offset, - float size, - const float use_min, - float min, - const float use_max, - float max, - out float result) -{ - result = (value + offset) * size; - - if (use_min != 0.0 && result < min) { - result = min; - } - - if (use_max != 0.0 && result > max) { - result = max; - } -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_normal.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_normal.glsl deleted file mode 100644 index a2e3b6c4aaa..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_normal.glsl +++ /dev/null @@ -1,9 +0,0 @@ -void node_composite_normal(vec3 input_vector, - vec3 input_normal, - out vec3 result_normal, - out float result_dot) -{ - vec3 normal = normalize(input_normal); - result_normal = normal; - result_dot = -dot(input_vector, normal); -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_posterize.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_posterize.glsl deleted file mode 100644 index ee8ae234abe..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_posterize.glsl +++ /dev/null @@ -1,6 +0,0 @@ -void node_composite_posterize(vec4 color, float steps, out vec4 result) -{ - steps = clamp(steps, 2.0, 1024.0); - result = floor(color * steps) / steps; - result.a = color.a; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_separate_combine.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_separate_combine.glsl deleted file mode 100644 index d72d2260394..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_separate_combine.glsl +++ /dev/null @@ -1,132 +0,0 @@ -#pragma BLENDER_REQUIRE(gpu_shader_common_color_utils.glsl) - -/* ** Combine/Separate XYZ ** */ - -void node_composite_combine_xyz(float x, float y, float z, out vec3 vector) -{ - vector = vec3(x, y, z); -} - -void node_composite_separate_xyz(vec3 vector, out float x, out float y, out float z) -{ - x = vector.x; - y = vector.y; - z = vector.z; -} - -/* ** Combine/Separate RGBA ** */ - -void node_composite_combine_rgba(float r, float g, float b, float a, out vec4 color) -{ - color = vec4(r, g, b, a); -} - -void node_composite_separate_rgba(vec4 color, out float r, out float g, out float b, out float a) -{ - r = color.r; - g = color.g; - b = color.b; - a = color.a; -} - -/* ** Combine/Separate HSVA ** */ - -void node_composite_combine_hsva(float h, float s, float v, float a, out vec4 color) -{ - hsv_to_rgb(vec4(h, s, v, a), color); -} - -void node_composite_separate_hsva(vec4 color, out float h, out float s, out float v, out float a) -{ - vec4 hsva; - rgb_to_hsv(color, hsva); - h = hsva.x; - s = hsva.y; - v = hsva.z; - a = hsva.a; -} - -/* ** Combine/Separate HSLA ** */ - -void node_composite_combine_hsla(float h, float s, float l, float a, out vec4 color) -{ - hsl_to_rgb(vec4(h, s, l, a), color); -} - -void node_composite_separate_hsla(vec4 color, out float h, out float s, out float l, out float a) -{ - vec4 hsla; - rgb_to_hsl(color, hsla); - h = hsla.x; - s = hsla.y; - l = hsla.z; - a = hsla.a; -} - -/* ** Combine/Separate YCCA ** */ - -void node_composite_combine_ycca_itu_601(float y, float cb, float cr, float a, out vec4 color) -{ - ycca_to_rgba_itu_601(vec4(y, cb, cr, a), color); -} - -void node_composite_combine_ycca_itu_709(float y, float cb, float cr, float a, out vec4 color) -{ - ycca_to_rgba_itu_709(vec4(y, cb, cr, a), color); -} - -void node_composite_combine_ycca_jpeg(float y, float cb, float cr, float a, out vec4 color) -{ - ycca_to_rgba_jpeg(vec4(y, cb, cr, a), color); -} - -void node_composite_separate_ycca_itu_601( - vec4 color, out float y, out float cb, out float cr, out float a) -{ - vec4 ycca; - rgba_to_ycca_itu_601(color, ycca); - y = ycca.x; - cb = ycca.y; - cr = ycca.z; - a = ycca.a; -} - -void node_composite_separate_ycca_itu_709( - vec4 color, out float y, out float cb, out float cr, out float a) -{ - vec4 ycca; - rgba_to_ycca_itu_709(color, ycca); - y = ycca.x; - cb = ycca.y; - cr = ycca.z; - a = ycca.a; -} - -void node_composite_separate_ycca_jpeg( - vec4 color, out float y, out float cb, out float cr, out float a) -{ - vec4 ycca; - rgba_to_ycca_jpeg(color, ycca); - y = ycca.x; - cb = ycca.y; - cr = ycca.z; - a = ycca.a; -} - -/* ** Combine/Separate YUVA ** */ - -void node_composite_combine_yuva_itu_709(float y, float u, float v, float a, out vec4 color) -{ - yuva_to_rgba_itu_709(vec4(y, u, v, a), color); -} - -void node_composite_separate_yuva_itu_709( - vec4 color, out float y, out float u, out float v, out float a) -{ - vec4 yuva; - rgba_to_yuva_itu_709(color, yuva); - y = yuva.x; - u = yuva.y; - v = yuva.z; - a = yuva.a; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_set_alpha.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_set_alpha.glsl deleted file mode 100644 index 95380d1ed0f..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_set_alpha.glsl +++ /dev/null @@ -1,9 +0,0 @@ -void node_composite_set_alpha_apply(vec4 color, float alpha, out vec4 result) -{ - result = color * alpha; -} - -void node_composite_set_alpha_replace(vec4 color, float alpha, out vec4 result) -{ - result = vec4(color.rgb, alpha); -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_store_output.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_store_output.glsl deleted file mode 100644 index 7fba26907b5..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_store_output.glsl +++ /dev/null @@ -1,26 +0,0 @@ -/* The following functions are called to store the given value in the output identified by the - * given ID. The ID is an unsigned integer that is encoded in a float, so floatBitsToUint is called - * to get the actual identifier. The functions have an output value as their last argument that is - * used to establish an output link that is then used to track the nodes that contribute to the - * output of the compositor node tree. - * - * The store_[float|vector|color] functions are dynamically generated in - * ShaderOperation::generate_code_for_outputs. */ - -void node_compositor_store_output_float(const float id, float value, out float out_value) -{ - store_float(floatBitsToUint(id), value); - out_value = value; -} - -void node_compositor_store_output_vector(const float id, vec3 vector, out vec3 out_vector) -{ - store_vector(floatBitsToUint(id), vector); - out_vector = vector; -} - -void node_compositor_store_output_color(const float id, vec4 color, out vec4 out_color) -{ - store_color(floatBitsToUint(id), color); - out_color = color; -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_texture_utilities.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_texture_utilities.glsl deleted file mode 100644 index 128fc6aeaf5..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_texture_utilities.glsl +++ /dev/null @@ -1,35 +0,0 @@ -/* A shorthand for 1D textureSize with a zero LOD. */ -int texture_size(sampler1D sampler) -{ - return textureSize(sampler, 0); -} - -/* A shorthand for 1D texelFetch with zero LOD and bounded access clamped to border. */ -vec4 texture_load(sampler1D sampler, int x) -{ - const int texture_bound = texture_size(sampler) - 1; - return texelFetch(sampler, clamp(x, 0, texture_bound), 0); -} - -/* A shorthand for 2D textureSize with a zero LOD. */ -ivec2 texture_size(sampler2D sampler) -{ - return textureSize(sampler, 0); -} - -/* A shorthand for 2D texelFetch with zero LOD and bounded access clamped to border. */ -vec4 texture_load(sampler2D sampler, ivec2 texel) -{ - const ivec2 texture_bounds = texture_size(sampler) - ivec2(1); - return texelFetch(sampler, clamp(texel, ivec2(0), texture_bounds), 0); -} - -/* A shorthand for 2D texelFetch with zero LOD and a fallback value for out-of-bound access. */ -vec4 texture_load(sampler2D sampler, ivec2 texel, vec4 fallback) -{ - const ivec2 texture_bounds = texture_size(sampler) - ivec2(1); - if (any(lessThan(texel, ivec2(0))) || any(greaterThan(texel, texture_bounds))) { - return fallback; - } - return texelFetch(sampler, texel, 0); -} diff --git a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_type_conversion.glsl b/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_type_conversion.glsl deleted file mode 100644 index 75c76fd7341..00000000000 --- a/source/blender/gpu/shaders/compositor/library/gpu_shader_compositor_type_conversion.glsl +++ /dev/null @@ -1,29 +0,0 @@ -float float_from_vec4(vec4 vector) -{ - return dot(vector.rgb, vec3(1.0)) / 3.0; -} - -float float_from_vec3(vec3 vector) -{ - return dot(vector, vec3(1.0)) / 3.0; -} - -vec3 vec3_from_vec4(vec4 vector) -{ - return vector.rgb; -} - -vec3 vec3_from_float(float value) -{ - return vec3(value); -} - -vec4 vec4_from_vec3(vec3 vector) -{ - return vec4(vector, 1.0); -} - -vec4 vec4_from_float(float value) -{ - return vec4(vec3(value), 1.0); -} -- cgit v1.2.3