diff options
Diffstat (limited to 'source/blender/gpu')
119 files changed, 1083 insertions, 2831 deletions
diff --git a/source/blender/gpu/CMakeLists.txt b/source/blender/gpu/CMakeLists.txt index 58b1cd0a50b..8da17720339 100644 --- a/source/blender/gpu/CMakeLists.txt +++ b/source/blender/gpu/CMakeLists.txt @@ -12,6 +12,7 @@ endif() set(INC . intern + vulkan metal opengl ../blenkernel @@ -26,6 +27,7 @@ set(INC ../editors/include # For *_info.hh includes. + ../compositor/realtime_compositor ../draw/engines/eevee_next ../draw/intern @@ -184,6 +186,34 @@ set(OPENGL_SRC opengl/gl_vertex_buffer.hh ) +set(VULKAN_SRC + vulkan/vk_backend.cc + vulkan/vk_batch.cc + vulkan/vk_context.cc + vulkan/vk_drawlist.cc + vulkan/vk_framebuffer.cc + vulkan/vk_index_buffer.cc + vulkan/vk_query.cc + vulkan/vk_shader.cc + vulkan/vk_storage_buffer.cc + vulkan/vk_texture.cc + vulkan/vk_uniform_buffer.cc + vulkan/vk_vertex_buffer.cc + + vulkan/vk_backend.hh + vulkan/vk_batch.hh + vulkan/vk_context.hh + vulkan/vk_drawlist.hh + vulkan/vk_framebuffer.hh + vulkan/vk_index_buffer.hh + vulkan/vk_query.hh + vulkan/vk_shader.hh + vulkan/vk_storage_buffer.hh + vulkan/vk_texture.hh + vulkan/vk_uniform_buffer.hh + vulkan/vk_vertex_buffer.hh +) + set(METAL_SRC metal/mtl_backend.mm metal/mtl_batch.mm @@ -235,6 +265,10 @@ if(WITH_OPENGL) list(APPEND SRC ${OPENGL_SRC}) endif() +if(WITH_VULKAN_BACKEND) + list(APPEND SRC ${VULKAN_SRC}) +endif() + if(WITH_METAL_BACKEND) list(APPEND SRC ${METAL_SRC}) endif() @@ -333,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 @@ -618,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 @@ -682,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/GPU_framebuffer.h b/source/blender/gpu/GPU_framebuffer.h index bdb384c16f1..917407eece3 100644 --- a/source/blender/gpu/GPU_framebuffer.h +++ b/source/blender/gpu/GPU_framebuffer.h @@ -47,6 +47,9 @@ typedef struct GPUOffScreen GPUOffScreen; GPUFrameBuffer *GPU_framebuffer_create(const char *name); void GPU_framebuffer_free(GPUFrameBuffer *fb); void GPU_framebuffer_bind(GPUFrameBuffer *fb); + +const char *GPU_framebuffer_get_name(GPUFrameBuffer *fb); + /** * Workaround for binding a SRGB frame-buffer without doing the SRGB transform. */ diff --git a/source/blender/gpu/GPU_platform.h b/source/blender/gpu/GPU_platform.h index b63fe4c0580..657b45df1a5 100644 --- a/source/blender/gpu/GPU_platform.h +++ b/source/blender/gpu/GPU_platform.h @@ -16,6 +16,7 @@ typedef enum eGPUBackendType { GPU_BACKEND_NONE = 0, GPU_BACKEND_OPENGL = 1 << 0, GPU_BACKEND_METAL = 1 << 1, + GPU_BACKEND_VULKAN = 1 << 3, GPU_BACKEND_ANY = 0xFFFFFFFFu } eGPUBackendType; diff --git a/source/blender/gpu/intern/gpu_context.cc b/source/blender/gpu/intern/gpu_context.cc index f6b88c4231c..7e94538892a 100644 --- a/source/blender/gpu/intern/gpu_context.cc +++ b/source/blender/gpu/intern/gpu_context.cc @@ -33,6 +33,9 @@ # include "gl_backend.hh" # include "gl_context.hh" #endif +#ifdef WITH_VULKAN_BACKEND +# include "vk_backend.hh" +#endif #ifdef WITH_METAL_BACKEND # include "mtl_backend.hh" #endif @@ -245,6 +248,12 @@ bool GPU_backend_supported(void) #else return false; #endif + case GPU_BACKEND_VULKAN: +#ifdef WITH_VULKAN_BACKEND + return true; +#else + return false; +#endif case GPU_BACKEND_METAL: #ifdef WITH_METAL_BACKEND return MTLBackend::metal_is_supported(); @@ -268,6 +277,11 @@ static void gpu_backend_create() g_backend = new GLBackend; break; #endif +#ifdef WITH_VULKAN_BACKEND + case GPU_BACKEND_VULKAN: + g_backend = new VKBackend; + break; +#endif #ifdef WITH_METAL_BACKEND case GPU_BACKEND_METAL: g_backend = new MTLBackend; diff --git a/source/blender/gpu/intern/gpu_framebuffer.cc b/source/blender/gpu/intern/gpu_framebuffer.cc index 6528f39d4ec..5b50fd66196 100644 --- a/source/blender/gpu/intern/gpu_framebuffer.cc +++ b/source/blender/gpu/intern/gpu_framebuffer.cc @@ -238,6 +238,11 @@ void GPU_framebuffer_free(GPUFrameBuffer *gpu_fb) delete unwrap(gpu_fb); } +const char *GPU_framebuffer_get_name(GPUFrameBuffer *gpu_fb) +{ + return unwrap(gpu_fb)->name_get(); +} + /* ---------- Binding ----------- */ void GPU_framebuffer_bind(GPUFrameBuffer *gpu_fb) diff --git a/source/blender/gpu/intern/gpu_framebuffer_private.hh b/source/blender/gpu/intern/gpu_framebuffer_private.hh index 5afcc102e44..cb7fd62445c 100644 --- a/source/blender/gpu/intern/gpu_framebuffer_private.hh +++ b/source/blender/gpu/intern/gpu_framebuffer_private.hh @@ -204,6 +204,11 @@ class FrameBuffer { { return attachments_[GPU_FB_COLOR_ATTACHMENT0 + slot].tex; }; + + inline const char *const name_get() const + { + return name_; + }; }; /* Syntactic sugar. */ 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/metal/mtl_shader_generator.hh b/source/blender/gpu/metal/mtl_shader_generator.hh index 43890ca0170..63e2e6d5924 100644 --- a/source/blender/gpu/metal/mtl_shader_generator.hh +++ b/source/blender/gpu/metal/mtl_shader_generator.hh @@ -497,7 +497,7 @@ inline std::string get_stage_class_name(ShaderStage stage) inline bool is_builtin_type(std::string type) { /* Add Types as needed. */ - /* TODO(Metal): Consider replacing this with a switch and constexpr hash and switch. + /* TODO(Metal): Consider replacing this with a switch and `constexpr` hash and switch. * Though most efficient and maintainable approach to be determined. */ static std::map<std::string, eMTLDataType> glsl_builtin_types = { {"float", MTL_DATATYPE_FLOAT}, diff --git a/source/blender/gpu/metal/mtl_texture_util.mm b/source/blender/gpu/metal/mtl_texture_util.mm index 5ed7659f260..33a62e2e3ef 100644 --- a/source/blender/gpu/metal/mtl_texture_util.mm +++ b/source/blender/gpu/metal/mtl_texture_util.mm @@ -34,7 +34,7 @@ MTLPixelFormat gpu_texture_format_to_metal(eGPUTextureFormat tex_format) { switch (tex_format) { - /* Formats texture & renderbuffer. */ + /* Formats texture & render-buffer. */ case GPU_RGBA8UI: return MTLPixelFormatRGBA8Uint; case GPU_RGBA8I: 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); -} diff --git a/source/blender/gpu/vulkan/vk_backend.cc b/source/blender/gpu/vulkan/vk_backend.cc new file mode 100644 index 00000000000..00bc43333d6 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_backend.cc @@ -0,0 +1,107 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_backend.hh" + +#include "vk_batch.hh" +#include "vk_context.hh" +#include "vk_drawlist.hh" +#include "vk_framebuffer.hh" +#include "vk_index_buffer.hh" +#include "vk_query.hh" +#include "vk_shader.hh" +#include "vk_storage_buffer.hh" +#include "vk_texture.hh" +#include "vk_uniform_buffer.hh" +#include "vk_vertex_buffer.hh" + +namespace blender::gpu { + +void VKBackend::delete_resources() +{ +} + +void VKBackend::samplers_update() +{ +} + +void VKBackend::compute_dispatch(int /*groups_x_len*/, int /*groups_y_len*/, int /*groups_z_len*/) +{ +} + +void VKBackend::compute_dispatch_indirect(StorageBuf * /*indirect_buf*/) +{ +} + +Context *VKBackend::context_alloc(void * /*ghost_window*/, void * /*ghost_context*/) +{ + return new VKContext(); +} + +Batch *VKBackend::batch_alloc() +{ + return new VKBatch(); +} + +DrawList *VKBackend::drawlist_alloc(int /*list_length*/) +{ + return new VKDrawList(); +} + +FrameBuffer *VKBackend::framebuffer_alloc(const char *name) +{ + return new VKFrameBuffer(name); +} + +IndexBuf *VKBackend::indexbuf_alloc() +{ + return new VKIndexBuffer(); +} + +QueryPool *VKBackend::querypool_alloc() +{ + return new VKQueryPool(); +} + +Shader *VKBackend::shader_alloc(const char *name) +{ + return new VKShader(name); +} + +Texture *VKBackend::texture_alloc(const char *name) +{ + return new VKTexture(name); +} + +UniformBuf *VKBackend::uniformbuf_alloc(int size, const char *name) +{ + return new VKUniformBuffer(size, name); +} + +StorageBuf *VKBackend::storagebuf_alloc(int size, GPUUsageType /*usage*/, const char *name) +{ + return new VKStorageBuffer(size, name); +} + +VertBuf *VKBackend::vertbuf_alloc() +{ + return new VKVertexBuffer(); +} + +void VKBackend::render_begin() +{ +} + +void VKBackend::render_end() +{ +} + +void VKBackend::render_step() +{ +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_backend.hh b/source/blender/gpu/vulkan/vk_backend.hh new file mode 100644 index 00000000000..549478586e8 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_backend.hh @@ -0,0 +1,42 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_backend.hh" + +namespace blender::gpu { + +class VKBackend : public GPUBackend { + public: + void delete_resources() override; + + void samplers_update() override; + void compute_dispatch(int groups_x_len, int groups_y_len, int groups_z_len) override; + void compute_dispatch_indirect(StorageBuf *indirect_buf) override; + + Context *context_alloc(void *ghost_window, void *ghost_context) override; + + Batch *batch_alloc() override; + DrawList *drawlist_alloc(int list_length) override; + FrameBuffer *framebuffer_alloc(const char *name) override; + IndexBuf *indexbuf_alloc() override; + QueryPool *querypool_alloc() override; + Shader *shader_alloc(const char *name) override; + Texture *texture_alloc(const char *name) override; + UniformBuf *uniformbuf_alloc(int size, const char *name) override; + StorageBuf *storagebuf_alloc(int size, GPUUsageType usage, const char *name) override; + VertBuf *vertbuf_alloc() override; + + /* Render Frame Coordination -- + * Used for performing per-frame actions globally */ + void render_begin() override; + void render_end() override; + void render_step() override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_batch.cc b/source/blender/gpu/vulkan/vk_batch.cc new file mode 100644 index 00000000000..a25f98a2e24 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_batch.cc @@ -0,0 +1,27 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_batch.hh" + +namespace blender::gpu { + +void VKBatch::draw(int /*v_first*/, int /*v_count*/, int /*i_first*/, int /*i_count*/) +{ +} + +void VKBatch::draw_indirect(GPUStorageBuf * /*indirect_buf*/, intptr_t /*offset*/) +{ +} + +void VKBatch::multi_draw_indirect(GPUStorageBuf * /*indirect_buf*/, + int /*count*/, + intptr_t /*offset*/, + intptr_t /*stride*/) +{ +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_batch.hh b/source/blender/gpu/vulkan/vk_batch.hh new file mode 100644 index 00000000000..0f6df41606d --- /dev/null +++ b/source/blender/gpu/vulkan/vk_batch.hh @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_batch_private.hh" + +namespace blender::gpu { + +class VKBatch : public Batch { + public: + void draw(int v_first, int v_count, int i_first, int i_count) override; + void draw_indirect(GPUStorageBuf *indirect_buf, intptr_t offset) override; + void multi_draw_indirect(GPUStorageBuf *indirect_buf, + int count, + intptr_t offset, + intptr_t stride) override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_context.cc b/source/blender/gpu/vulkan/vk_context.cc new file mode 100644 index 00000000000..55b29ea4e2f --- /dev/null +++ b/source/blender/gpu/vulkan/vk_context.cc @@ -0,0 +1,48 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_context.hh" + +namespace blender::gpu { + +void VKContext::activate() +{ +} + +void VKContext::deactivate() +{ +} + +void VKContext::begin_frame() +{ +} + +void VKContext::end_frame() +{ +} + +void VKContext::flush() +{ +} + +void VKContext::finish() +{ +} + +void VKContext::memory_statistics_get(int * /*total_mem*/, int * /*free_mem*/) +{ +} + +void VKContext::debug_group_begin(const char *, int) +{ +} + +void VKContext::debug_group_end() +{ +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_context.hh b/source/blender/gpu/vulkan/vk_context.hh new file mode 100644 index 00000000000..17292b891b6 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_context.hh @@ -0,0 +1,34 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_context_private.hh" + +namespace blender::gpu { + +class VKContext : public Context { + public: + VKContext() + { + } + + void activate() override; + void deactivate() override; + void begin_frame() override; + void end_frame() override; + + void flush() override; + void finish() override; + + void memory_statistics_get(int *total_mem, int *free_mem) override; + + void debug_group_begin(const char *, int) override; + void debug_group_end() override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_drawlist.cc b/source/blender/gpu/vulkan/vk_drawlist.cc new file mode 100644 index 00000000000..c8f3c736bb8 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_drawlist.cc @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_drawlist.hh" + +namespace blender::gpu { + +void VKDrawList::append(GPUBatch * /*batch*/, int /*i_first*/, int /*i_count*/) +{ +} + +void VKDrawList::submit() +{ +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_drawlist.hh b/source/blender/gpu/vulkan/vk_drawlist.hh new file mode 100644 index 00000000000..4707bf4bb26 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_drawlist.hh @@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_drawlist_private.hh" + +namespace blender::gpu { + +class VKDrawList : public DrawList { + public: + void append(GPUBatch *batch, int i_first, int i_count) override; + void submit() override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_framebuffer.cc b/source/blender/gpu/vulkan/vk_framebuffer.cc new file mode 100644 index 00000000000..48b0685bf38 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_framebuffer.cc @@ -0,0 +1,62 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_framebuffer.hh" + +namespace blender::gpu { + +void VKFrameBuffer::bind(bool /*enabled_srgb*/) +{ +} + +bool VKFrameBuffer::check(char /*err_out*/[256]) +{ + return false; +} + +void VKFrameBuffer::clear(eGPUFrameBufferBits /*buffers*/, + const float /*clear_col*/[4], + float /*clear_depth*/, + uint /*clear_stencil*/) +{ +} + +void VKFrameBuffer::clear_multi(const float (*/*clear_col*/)[4]) +{ +} + +void VKFrameBuffer::clear_attachment(GPUAttachmentType /*type*/, + eGPUDataFormat /*data_format*/, + const void * /*clear_value*/) +{ +} + +void VKFrameBuffer::attachment_set_loadstore_op(GPUAttachmentType /*type*/, + eGPULoadOp /*load_action*/, + eGPUStoreOp /*store_action*/) +{ +} + +void VKFrameBuffer::read(eGPUFrameBufferBits /*planes*/, + eGPUDataFormat /*format*/, + const int /*area*/[4], + int /*channel_len*/, + int /*slot*/, + void * /*r_data*/) +{ +} + +void VKFrameBuffer::blit_to(eGPUFrameBufferBits /*planes*/, + int /*src_slot*/, + FrameBuffer * /*dst*/, + int /*dst_slot*/, + int /*dst_offset_x*/, + int /*dst_offset_y*/) +{ +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_framebuffer.hh b/source/blender/gpu/vulkan/vk_framebuffer.hh new file mode 100644 index 00000000000..632d45ce709 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_framebuffer.hh @@ -0,0 +1,50 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_framebuffer_private.hh" + +namespace blender::gpu { + +class VKFrameBuffer : public FrameBuffer { + public: + VKFrameBuffer(const char *name) : FrameBuffer(name) + { + } + + void bind(bool enabled_srgb) override; + bool check(char err_out[256]) override; + void clear(eGPUFrameBufferBits buffers, + const float clear_col[4], + float clear_depth, + uint clear_stencil) override; + void clear_multi(const float (*clear_col)[4]) override; + void clear_attachment(GPUAttachmentType type, + eGPUDataFormat data_format, + const void *clear_value) override; + + void attachment_set_loadstore_op(GPUAttachmentType type, + eGPULoadOp load_action, + eGPUStoreOp store_action) override; + + void read(eGPUFrameBufferBits planes, + eGPUDataFormat format, + const int area[4], + int channel_len, + int slot, + void *r_data) override; + + void blit_to(eGPUFrameBufferBits planes, + int src_slot, + FrameBuffer *dst, + int dst_slot, + int dst_offset_x, + int dst_offset_y) override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_index_buffer.cc b/source/blender/gpu/vulkan/vk_index_buffer.cc new file mode 100644 index 00000000000..119a617a159 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_index_buffer.cc @@ -0,0 +1,33 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_index_buffer.hh" + +namespace blender::gpu { + +void VKIndexBuffer::upload_data() +{ +} + +void VKIndexBuffer::bind_as_ssbo(uint /*binding*/) +{ +} + +const uint32_t *VKIndexBuffer::read() const +{ + return 0; +} + +void VKIndexBuffer::update_sub(uint /*start*/, uint /*len*/, const void * /*data*/) +{ +} + +void VKIndexBuffer::strip_restart_indices() +{ +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_index_buffer.hh b/source/blender/gpu/vulkan/vk_index_buffer.hh new file mode 100644 index 00000000000..f002d5581c7 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_index_buffer.hh @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_index_buffer_private.hh" + +namespace blender::gpu { + +class VKIndexBuffer : public IndexBuf { + public: + void upload_data() override; + + void bind_as_ssbo(uint binding) override; + + const uint32_t *read() const override; + + void update_sub(uint start, uint len, const void *data) override; + + private: + void strip_restart_indices() override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_query.cc b/source/blender/gpu/vulkan/vk_query.cc new file mode 100644 index 00000000000..e24fe54e5d0 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_query.cc @@ -0,0 +1,28 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_query.hh" + +namespace blender::gpu { + +void VKQueryPool::init(GPUQueryType /*type*/) +{ +} + +void VKQueryPool::begin_query() +{ +} + +void VKQueryPool::end_query() +{ +} + +void VKQueryPool::get_occlusion_result(MutableSpan<uint32_t> /*r_values*/) +{ +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_query.hh b/source/blender/gpu/vulkan/vk_query.hh new file mode 100644 index 00000000000..36558ef9549 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_query.hh @@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_query.hh" + +namespace blender::gpu { + +class VKQueryPool : public QueryPool { + public: + void init(GPUQueryType type) override; + void begin_query() override; + void end_query() override; + void get_occlusion_result(MutableSpan<uint32_t> r_values) override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_shader.cc b/source/blender/gpu/vulkan/vk_shader.cc new file mode 100644 index 00000000000..d628f3eb851 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_shader.cc @@ -0,0 +1,102 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_shader.hh" + +namespace blender::gpu { +void VKShader::vertex_shader_from_glsl(MutableSpan<const char *> /*sources*/) +{ +} + +void VKShader::geometry_shader_from_glsl(MutableSpan<const char *> /*sources*/) +{ +} + +void VKShader::fragment_shader_from_glsl(MutableSpan<const char *> /*sources*/) +{ +} + +void VKShader::compute_shader_from_glsl(MutableSpan<const char *> /*sources*/) +{ +} + +bool VKShader::finalize(const shader::ShaderCreateInfo * /*info*/) +{ + return false; +} + +void VKShader::transform_feedback_names_set(Span<const char *> /*name_list*/, + eGPUShaderTFBType /*geom_type*/) +{ +} + +bool VKShader::transform_feedback_enable(GPUVertBuf *) +{ + return false; +} + +void VKShader::transform_feedback_disable() +{ +} + +void VKShader::bind() +{ +} + +void VKShader::unbind() +{ +} + +void VKShader::uniform_float(int /*location*/, + int /*comp_len*/, + int /*array_size*/, + const float * /*data*/) +{ +} +void VKShader::uniform_int(int /*location*/, + int /*comp_len*/, + int /*array_size*/, + const int * /*data*/) +{ +} + +std::string VKShader::resources_declare(const shader::ShaderCreateInfo & /*info*/) const +{ + return std::string(); +} + +std::string VKShader::vertex_interface_declare(const shader::ShaderCreateInfo & /*info*/) const +{ + return std::string(); +} + +std::string VKShader::fragment_interface_declare(const shader::ShaderCreateInfo & /*info*/) const +{ + return std::string(); +} + +std::string VKShader::geometry_interface_declare(const shader::ShaderCreateInfo & /*info*/) const +{ + return std::string(); +} + +std::string VKShader::geometry_layout_declare(const shader::ShaderCreateInfo & /*info*/) const +{ + return std::string(); +} + +std::string VKShader::compute_layout_declare(const shader::ShaderCreateInfo & /*info*/) const +{ + return std::string(); +} + +int VKShader::program_handle_get() const +{ + return -1; +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_shader.hh b/source/blender/gpu/vulkan/vk_shader.hh new file mode 100644 index 00000000000..9ab0aca67eb --- /dev/null +++ b/source/blender/gpu/vulkan/vk_shader.hh @@ -0,0 +1,48 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_shader_private.hh" + +namespace blender::gpu { + +class VKShader : public Shader { + public: + VKShader(const char *name) : Shader(name) + { + } + + void vertex_shader_from_glsl(MutableSpan<const char *> sources) override; + void geometry_shader_from_glsl(MutableSpan<const char *> sources) override; + void fragment_shader_from_glsl(MutableSpan<const char *> sources) override; + void compute_shader_from_glsl(MutableSpan<const char *> sources) override; + bool finalize(const shader::ShaderCreateInfo *info = nullptr) override; + + void transform_feedback_names_set(Span<const char *> name_list, + eGPUShaderTFBType geom_type) override; + bool transform_feedback_enable(GPUVertBuf *) override; + void transform_feedback_disable() override; + + void bind() override; + void unbind() override; + + void uniform_float(int location, int comp_len, int array_size, const float *data) override; + void uniform_int(int location, int comp_len, int array_size, const int *data) override; + + std::string resources_declare(const shader::ShaderCreateInfo &info) const override; + std::string vertex_interface_declare(const shader::ShaderCreateInfo &info) const override; + std::string fragment_interface_declare(const shader::ShaderCreateInfo &info) const override; + std::string geometry_interface_declare(const shader::ShaderCreateInfo &info) const override; + std::string geometry_layout_declare(const shader::ShaderCreateInfo &info) const override; + std::string compute_layout_declare(const shader::ShaderCreateInfo &info) const override; + + /* DEPRECATED: Kept only because of BGL API. */ + int program_handle_get() const override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_storage_buffer.cc b/source/blender/gpu/vulkan/vk_storage_buffer.cc new file mode 100644 index 00000000000..2b6fda0547d --- /dev/null +++ b/source/blender/gpu/vulkan/vk_storage_buffer.cc @@ -0,0 +1,42 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_vertex_buffer.hh" + +#include "vk_storage_buffer.hh" + +namespace blender::gpu { + +void VKStorageBuffer::update(const void * /*data*/) +{ +} + +void VKStorageBuffer::bind(int /*slot*/) +{ +} + +void VKStorageBuffer::unbind() +{ +} + +void VKStorageBuffer::clear(eGPUTextureFormat /* internal_format*/, + eGPUDataFormat /*data_format*/, + void * /*data*/) +{ +} +void VKStorageBuffer::copy_sub(VertBuf * /*src*/, + uint /*dst_offset*/, + uint /*src_offset*/, + uint /*copy_size*/) +{ +} + +void VKStorageBuffer::read(void * /*data*/) +{ +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_storage_buffer.hh b/source/blender/gpu/vulkan/vk_storage_buffer.hh new file mode 100644 index 00000000000..a51f89f627a --- /dev/null +++ b/source/blender/gpu/vulkan/vk_storage_buffer.hh @@ -0,0 +1,30 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "GPU_texture.h" + +#include "gpu_storage_buffer_private.hh" + +namespace blender::gpu { + +class VKStorageBuffer : public StorageBuf { + public: + VKStorageBuffer(int size, const char *name) : StorageBuf(size, name) + { + } + + void update(const void *data) override; + void bind(int slot) override; + void unbind() override; + void clear(eGPUTextureFormat internal_format, eGPUDataFormat data_format, void *data) override; + void copy_sub(VertBuf *src, uint dst_offset, uint src_offset, uint copy_size) override; + void read(void *data) override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_texture.cc b/source/blender/gpu/vulkan/vk_texture.cc new file mode 100644 index 00000000000..ea5379e6572 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_texture.cc @@ -0,0 +1,70 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_texture.hh" + +namespace blender::gpu { + +void VKTexture::generate_mipmap() +{ +} + +void VKTexture::copy_to(Texture * /*tex*/) +{ +} + +void VKTexture::clear(eGPUDataFormat /*format*/, const void * /*data*/) +{ +} + +void VKTexture::swizzle_set(const char /*swizzle_mask*/[4]) +{ +} + +void VKTexture::stencil_texture_mode_set(bool /*use_stencil*/) +{ +} + +void VKTexture::mip_range_set(int /*min*/, int /*max*/) +{ +} + +void *VKTexture::read(int /*mip*/, eGPUDataFormat /*format*/) +{ + return nullptr; +} + +void VKTexture::update_sub(int /*mip*/, + int /*offset*/[3], + int /*extent*/[3], + eGPUDataFormat /*format*/, + const void * /*data*/) +{ +} + +/* TODO(fclem): Legacy. Should be removed at some point. */ +uint VKTexture::gl_bindcode_get() const +{ + return 0; +} + +bool VKTexture::init_internal() +{ + return false; +} + +bool VKTexture::init_internal(GPUVertBuf * /*vbo*/) +{ + return false; +} + +bool VKTexture::init_internal(const GPUTexture * /*src*/, int /*mip_offset*/, int /*layer_offset*/) +{ + return false; +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_texture.hh b/source/blender/gpu/vulkan/vk_texture.hh new file mode 100644 index 00000000000..93094b7e540 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_texture.hh @@ -0,0 +1,39 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_texture_private.hh" + +namespace blender::gpu { + +class VKTexture : public Texture { + public: + VKTexture(const char *name) : Texture(name) + { + } + + void generate_mipmap() override; + void copy_to(Texture *tex) override; + void clear(eGPUDataFormat format, const void *data) override; + void swizzle_set(const char swizzle_mask[4]) override; + void stencil_texture_mode_set(bool use_stencil) override; + void mip_range_set(int min, int max) override; + void *read(int mip, eGPUDataFormat format) override; + void update_sub( + int mip, int offset[3], int extent[3], eGPUDataFormat format, const void *data) override; + + /* TODO(fclem): Legacy. Should be removed at some point. */ + uint gl_bindcode_get() const override; + + protected: + bool init_internal() override; + bool init_internal(GPUVertBuf *vbo) override; + bool init_internal(const GPUTexture *src, int mip_offset, int layer_offset) override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_uniform_buffer.cc b/source/blender/gpu/vulkan/vk_uniform_buffer.cc new file mode 100644 index 00000000000..8ef5b19273a --- /dev/null +++ b/source/blender/gpu/vulkan/vk_uniform_buffer.cc @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_uniform_buffer.hh" + +namespace blender::gpu { + +void VKUniformBuffer::update(const void * /*data*/) +{ +} + +void VKUniformBuffer::bind(int /*slot*/) +{ +} + +void VKUniformBuffer::unbind() +{ +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_uniform_buffer.hh b/source/blender/gpu/vulkan/vk_uniform_buffer.hh new file mode 100644 index 00000000000..f086a7aa391 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_uniform_buffer.hh @@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_uniform_buffer_private.hh" + +namespace blender::gpu { + +class VKUniformBuffer : public UniformBuf { + public: + VKUniformBuffer(int size, const char *name) : UniformBuf(size, name) + { + } + + void update(const void *data) override; + void bind(int slot) override; + void unbind() override; +}; + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_vertex_buffer.cc b/source/blender/gpu/vulkan/vk_vertex_buffer.cc new file mode 100644 index 00000000000..5791e20fb30 --- /dev/null +++ b/source/blender/gpu/vulkan/vk_vertex_buffer.cc @@ -0,0 +1,58 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#include "vk_vertex_buffer.hh" + +namespace blender::gpu { + +void VKVertexBuffer::bind_as_ssbo(uint /*binding*/) +{ +} + +void VKVertexBuffer::bind_as_texture(uint /*binding*/) +{ +} + +void VKVertexBuffer::wrap_handle(uint64_t /*handle*/) +{ +} + +void VKVertexBuffer::update_sub(uint /*start*/, uint /*len*/, const void * /*data*/) +{ +} + +const void *VKVertexBuffer::read() const +{ + return nullptr; +} + +void *VKVertexBuffer::unmap(const void * /*mapped_data*/) const +{ + return nullptr; +} + +void VKVertexBuffer::acquire_data() +{ +} + +void VKVertexBuffer::resize_data() +{ +} + +void VKVertexBuffer::release_data() +{ +} + +void VKVertexBuffer::upload_data() +{ +} + +void VKVertexBuffer::duplicate_data(VertBuf * /*dst*/) +{ +} + +} // namespace blender::gpu
\ No newline at end of file diff --git a/source/blender/gpu/vulkan/vk_vertex_buffer.hh b/source/blender/gpu/vulkan/vk_vertex_buffer.hh new file mode 100644 index 00000000000..84ccc65bcdf --- /dev/null +++ b/source/blender/gpu/vulkan/vk_vertex_buffer.hh @@ -0,0 +1,32 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later + * Copyright 2022 Blender Foundation. All rights reserved. */ + +/** \file + * \ingroup gpu + */ + +#pragma once + +#include "gpu_vertex_buffer_private.hh" + +namespace blender::gpu { + +class VKVertexBuffer : public VertBuf { + public: + void bind_as_ssbo(uint binding) override; + void bind_as_texture(uint binding) override; + void wrap_handle(uint64_t handle) override; + + void update_sub(uint start, uint len, const void *data) override; + const void *read() const override; + void *unmap(const void *mapped_data) const override; + + protected: + void acquire_data() override; + void resize_data() override; + void release_data() override; + void upload_data() override; + void duplicate_data(VertBuf *dst) override; +}; + +} // namespace blender::gpu
\ No newline at end of file |