Merge branch 'master' into blender-projects-basicsblender-projects-basics

59 files changed, 1528 insertions, 59 deletions

diff --git a/source/blender/gpu/CMakeLists.txt b/source/blender/gpu/CMakeLists.txt
index 5a1e0cde1d8..bfbbf1be225 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
@@ -184,6 +185,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 +264,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()
@@ -282,6 +315,8 @@ set(GLSL_SRC
   shaders/gpu_shader_2D_image_vert.glsl
   shaders/gpu_shader_2D_image_rect_vert.glsl
   shaders/gpu_shader_2D_image_multi_rect_vert.glsl
+  shaders/gpu_shader_icon_frag.glsl
+  shaders/gpu_shader_icon_vert.glsl
   shaders/gpu_shader_image_frag.glsl
   shaders/gpu_shader_image_desaturate_frag.glsl
   shaders/gpu_shader_image_overlays_merge_frag.glsl
@@ -349,6 +384,7 @@ set(GLSL_SRC
   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
@@ -357,6 +393,8 @@ set(GLSL_SRC
   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
@@ -606,6 +644,7 @@ set(SRC_SHADER_CREATE_INFOS
   shaders/infos/gpu_shader_3D_smooth_color_info.hh
   shaders/infos/gpu_shader_3D_uniform_color_info.hh
   shaders/infos/gpu_shader_gpencil_stroke_info.hh
+  shaders/infos/gpu_shader_icon_info.hh
   shaders/infos/gpu_shader_instance_varying_color_varying_size_info.hh
   shaders/infos/gpu_shader_keyframe_shape_info.hh
   shaders/infos/gpu_shader_line_dashed_uniform_color_info.hh
@@ -631,6 +670,7 @@ set(SRC_SHADER_CREATE_INFOS
   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
@@ -639,6 +679,8 @@ set(SRC_SHADER_CREATE_INFOS
   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
diff --git a/source/blender/gpu/GPU_context.h b/source/blender/gpu/GPU_context.h
index b59ea9e55d2..ac82774039a 100644
--- a/source/blender/gpu/GPU_context.h
+++ b/source/blender/gpu/GPU_context.h
@@ -21,6 +21,8 @@ extern "C" {
  * automatically initializes the back-end, and #GPU_context_discard frees it when there
  * are no more contexts. */
 bool GPU_backend_supported(void);
+void GPU_backend_type_selection_set(const eGPUBackendType backend);
+eGPUBackendType GPU_backend_type_selection_get(void);
 eGPUBackendType GPU_backend_get_type(void);
 
 /** Opaque type hiding blender::gpu::Context. */
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/GPU_shader.h b/source/blender/gpu/GPU_shader.h
index 3f35db42eb9..1148207fc57 100644
--- a/source/blender/gpu/GPU_shader.h
+++ b/source/blender/gpu/GPU_shader.h
@@ -209,6 +209,10 @@ typedef enum eGPUBuiltinShader {
   GPU_SHADER_KEYFRAME_SHAPE,
   GPU_SHADER_SIMPLE_LIGHTING,
   /**
+   * Draw an icon, leaving a semi-transparent rectangle on top of the icon.
+   */
+  GPU_SHADER_ICON,
+  /**
    * Take a 2D position and color for each vertex with linear interpolation in window space.
    *
    * \param color: in vec4
diff --git a/source/blender/gpu/intern/gpu_context.cc b/source/blender/gpu/intern/gpu_context.cc
index 48d7b2019c5..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
@@ -223,9 +226,19 @@ void GPU_render_step()
 /* NOTE: To enable Metal API, we need to temporarily change this to `GPU_BACKEND_METAL`.
  * Until a global switch is added, Metal also needs to be enabled in GHOST_ContextCGL:
  * `m_useMetalForRendering = true`. */
-static const eGPUBackendType g_backend_type = GPU_BACKEND_OPENGL;
+static eGPUBackendType g_backend_type = GPU_BACKEND_OPENGL;
 static GPUBackend *g_backend = nullptr;
 
+void GPU_backend_type_selection_set(const eGPUBackendType backend)
+{
+  g_backend_type = backend;
+}
+
+eGPUBackendType GPU_backend_type_selection_get()
+{
+  return g_backend_type;
+}
+
 bool GPU_backend_supported(void)
 {
   switch (g_backend_type) {
@@ -235,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();
@@ -258,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 76e816e7f65..cb7fd62445c 100644
--- a/source/blender/gpu/intern/gpu_framebuffer_private.hh
+++ b/source/blender/gpu/intern/gpu_framebuffer_private.hh
@@ -95,11 +95,6 @@ class FrameBuffer {
 #endif
 
  public:
-  /* Reference of a pointer that needs to be cleaned when deallocating the frame-buffer.
-   * Points to #BPyGPUFrameBuffer::fb */
-  void **ref = nullptr;
-
- public:
   FrameBuffer(const char *name);
   virtual ~FrameBuffer();
 
@@ -209,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_immediate.cc b/source/blender/gpu/intern/gpu_immediate.cc
index 3b4accf9cc5..81c0a65bb7c 100644
--- a/source/blender/gpu/intern/gpu_immediate.cc
+++ b/source/blender/gpu/intern/gpu_immediate.cc
@@ -45,7 +45,7 @@ void immBindShader(GPUShader *shader)
   BLI_assert(imm->shader == nullptr);
 
   imm->shader = shader;
-  imm->builtin_shader_bound = GPU_SHADER_TEXT; /* Default value. */
+  imm->builtin_shader_bound = std::nullopt;
 
   if (!imm->vertex_format.packed) {
     VertexFormat_pack(&imm->vertex_format);
@@ -125,9 +125,12 @@ static void wide_line_workaround_start(GPUPrimType prim_type)
     /* No need to change the shader. */
     return;
   }
+  if (!imm->builtin_shader_bound) {
+    return;
+  }
 
   eGPUBuiltinShader polyline_sh;
-  switch (imm->builtin_shader_bound) {
+  switch (*imm->builtin_shader_bound) {
     case GPU_SHADER_3D_CLIPPED_UNIFORM_COLOR:
       polyline_sh = GPU_SHADER_3D_POLYLINE_CLIPPED_UNIFORM_COLOR;
       break;
@@ -180,8 +183,8 @@ static void wide_line_workaround_end()
     }
     immUnbindProgram();
 
-    immBindBuiltinProgram(imm->prev_builtin_shader);
-    imm->prev_builtin_shader = GPU_SHADER_TEXT;
+    immBindBuiltinProgram(*imm->prev_builtin_shader);
+    imm->prev_builtin_shader = std::nullopt;
   }
 }
 
diff --git a/source/blender/gpu/intern/gpu_immediate_private.hh b/source/blender/gpu/intern/gpu_immediate_private.hh
index 74ebbdc7ae3..c4e11e7082b 100644
--- a/source/blender/gpu/intern/gpu_immediate_private.hh
+++ b/source/blender/gpu/intern/gpu_immediate_private.hh
@@ -9,6 +9,8 @@
 
 #pragma once
 
+#include <optional>
+
 #include "GPU_batch.h"
 #include "GPU_primitive.h"
 #include "GPU_shader.h"
@@ -42,9 +44,9 @@ class Immediate {
   /** Wide Line workaround. */
 
   /** Previously bound shader to restore after drawing. */
-  eGPUBuiltinShader prev_builtin_shader = GPU_SHADER_TEXT;
-  /** Builtin shader index. Used to test if the workaround can be done. */
-  eGPUBuiltinShader builtin_shader_bound = GPU_SHADER_TEXT;
+  std::optional<eGPUBuiltinShader> prev_builtin_shader;
+  /** Builtin shader index. Used to test if the line width workaround can be done. */
+  std::optional<eGPUBuiltinShader> builtin_shader_bound;
   /** Uniform color: Kept here to update the wide-line shader just before #immBegin. */
   float uniform_color[4];
 
diff --git a/source/blender/gpu/intern/gpu_shader_builder.cc b/source/blender/gpu/intern/gpu_shader_builder.cc
index 3aa2963ecd0..abb45ca074a 100644
--- a/source/blender/gpu/intern/gpu_shader_builder.cc
+++ b/source/blender/gpu/intern/gpu_shader_builder.cc
@@ -15,6 +15,8 @@
 #include "GPU_init_exit.h"
 #include "gpu_shader_create_info_private.hh"
 
+#include "BLI_vector.hh"
+
 #include "CLG_log.h"
 
 namespace blender::gpu::shader_builder {
@@ -41,6 +43,22 @@ void ShaderBuilder::init()
   CLG_init();
 
   GHOST_GLSettings glSettings = {0};
+  switch (GPU_backend_type_selection_get()) {
+    case GPU_BACKEND_OPENGL:
+      glSettings.context_type = GHOST_kDrawingContextTypeOpenGL;
+      break;
+
+#ifdef WITH_METAL_BACKEND
+    case GPU_BACKEND_METAL:
+      glSettings.context_type = GHOST_kDrawingContextTypeMetal;
+      break;
+#endif
+
+    default:
+      BLI_assert_unreachable();
+      break;
+  }
+
   ghost_system_ = GHOST_CreateSystem();
   ghost_context_ = GHOST_CreateOpenGLContext(ghost_system_, glSettings);
   GHOST_ActivateOpenGLContext(ghost_context_);
@@ -73,13 +91,32 @@ int main(int argc, const char *argv[])
 
   int exit_code = 0;
 
-  blender::gpu::shader_builder::ShaderBuilder builder;
-  builder.init();
-  if (!builder.bake_create_infos()) {
-    exit_code = 1;
+  struct NamedBackend {
+    std::string name;
+    eGPUBackendType backend;
+  };
+
+  blender::Vector<NamedBackend> backends_to_validate;
+  backends_to_validate.append({"OpenGL", GPU_BACKEND_OPENGL});
+#ifdef WITH_METAL_BACKEND
+  backends_to_validate.append({"Metal", GPU_BACKEND_METAL});
+#endif
+  for (NamedBackend &backend : backends_to_validate) {
+    GPU_backend_type_selection_set(backend.backend);
+    if (!GPU_backend_supported()) {
+      printf("%s isn't supported on this platform. Shader compilation is skipped\n",
+             backend.name.c_str());
+      continue;
+    }
+    blender::gpu::shader_builder::ShaderBuilder builder;
+    builder.init();
+    if (!builder.bake_create_infos()) {
+      printf("Shader compilation failed for %s backend\n", backend.name.c_str());
+      exit_code = 1;
+    }
+    builder.exit();
   }
-  builder.exit();
-  exit(exit_code);
 
+  exit(exit_code);
   return exit_code;
 }
diff --git a/source/blender/gpu/intern/gpu_shader_builder_stubs.cc b/source/blender/gpu/intern/gpu_shader_builder_stubs.cc
index 7a06ede5c6d..65bda7ba858 100644
--- a/source/blender/gpu/intern/gpu_shader_builder_stubs.cc
+++ b/source/blender/gpu/intern/gpu_shader_builder_stubs.cc
@@ -46,6 +46,15 @@ void IMB_freeImBuf(ImBuf * /*ibuf*/)
   BLI_assert_unreachable();
 }
 
+struct ImBuf *IMB_allocImBuf(unsigned int /*x*/,
+                             unsigned int /*y*/,
+                             unsigned char /*planes*/,
+                             unsigned int /*flags*/)
+{
+  BLI_assert_unreachable();
+  return nullptr;
+}
+
 /** \} */
 
 /* -------------------------------------------------------------------- */
diff --git a/source/blender/gpu/intern/gpu_shader_builtin.c b/source/blender/gpu/intern/gpu_shader_builtin.c
index 8a6586e06f6..470643ba863 100644
--- a/source/blender/gpu/intern/gpu_shader_builtin.c
+++ b/source/blender/gpu/intern/gpu_shader_builtin.c
@@ -153,6 +153,11 @@ static const GPUShaderStages builtin_shader_stages[GPU_SHADER_BUILTIN_LEN] = {
             .create_info = "gpu_shader_2D_diag_stripes",
         },
 
+    [GPU_SHADER_ICON] =
+        {
+            .name = "GPU_SHADER_ICON",
+            .create_info = "gpu_shader_icon",
+        },
     [GPU_SHADER_2D_IMAGE_OVERLAYS_MERGE] =
         {
             .name = "GPU_SHADER_2D_IMAGE_OVERLAYS_MERGE",
diff --git a/source/blender/gpu/intern/gpu_texture_private.hh b/source/blender/gpu/intern/gpu_texture_private.hh
index 2ad31183206..124b1751b96 100644
--- a/source/blender/gpu/intern/gpu_texture_private.hh
+++ b/source/blender/gpu/intern/gpu_texture_private.hh
@@ -588,7 +588,7 @@ inline eGPUFrameBufferBits to_framebuffer_bits(eGPUTextureFormat tex_format)
 
 static inline eGPUTextureFormat to_texture_format(const GPUVertFormat *format)
 {
-  if (format->attr_len > 1 || format->attr_len == 0) {
+  if (format->attr_len == 0) {
     BLI_assert_msg(0, "Incorrect vertex format for buffer texture");
     return GPU_DEPTH_COMPONENT24;
   }
diff --git a/source/blender/gpu/intern/gpu_vertex_format.cc b/source/blender/gpu/intern/gpu_vertex_format.cc
index b30e3c358c8..76d95ac1b55 100644
--- a/source/blender/gpu/intern/gpu_vertex_format.cc
+++ b/source/blender/gpu/intern/gpu_vertex_format.cc
@@ -361,8 +361,12 @@ void VertexFormat_texture_buffer_pack(GPUVertFormat *format)
    * minimum per-vertex stride, which mandates 4-byte alignment in Metal.
    * This additional alignment padding caused smaller data types, e.g. U16,
    * to mis-align. */
-  BLI_assert_msg(format->attr_len == 1,
-                 "Texture buffer mode should only use a single vertex attribute.");
+  for (int i = 0; i < format->attr_len; i++) {
+    /* The buffer texture setup uses the first attribute for type and size.
+     * Make sure all attributes use the same size. */
+    BLI_assert_msg(format->attrs[i].size == format->attrs[0].size,
+                   "Texture buffer mode should only use a attributes with the same size.");
+  }
 
   /* Pack vertex format without minimum stride, as this is not required by texture buffers. */
   VertexFormat_pack_impl(format, 1);
diff --git a/source/blender/gpu/metal/mtl_batch.mm b/source/blender/gpu/metal/mtl_batch.mm
index e9804d4be77..988fb9b793b 100644
--- a/source/blender/gpu/metal/mtl_batch.mm
+++ b/source/blender/gpu/metal/mtl_batch.mm
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 
 /** \file
  * \ingroup gpu
@@ -68,7 +69,7 @@ void MTLBatch::MTLVertexDescriptorCache::vertex_descriptor_cache_ensure()
     }
   }
 
-  /* Initialise cache if not ready. */
+  /* Initialize cache if not ready. */
   if (cache_context_ == nullptr) {
     this->vertex_descriptor_cache_init(MTLContext::get());
   }
@@ -188,7 +189,7 @@ int MTLBatch::prepare_vertex_binding(MTLVertBuf *verts,
                        buffer_stride);
         }
         else {
-          /* Ensure stride is correct for de-interlevaed attributes. */
+          /* Ensure stride is correct for de-interleaved attributes. */
           desc.vertex_descriptor.buffer_layouts[buffer_index].stride = buffer_stride;
         }
 
@@ -278,7 +279,7 @@ int MTLBatch::prepare_vertex_binding(MTLVertBuf *verts,
            * elements).
            *
            * Certain conversion cannot be performed however, and in these cases, we need to
-           * instruct the shader to generate a specialised version with a conversion routine upon
+           * instruct the shader to generate a specialized version with a conversion routine upon
            * attribute read.
            *   - This handles cases such as conversion between types e.g. Integer to float without
            * normalization.
@@ -310,7 +311,7 @@ int MTLBatch::prepare_vertex_binding(MTLVertBuf *verts,
              * This then controls how a given attribute is interpreted. The data will be read
              * as specified and then converted appropriately to the correct form.
              *
-             * e.g. if `GPU_FETCH_INT_TO_FLOAT` is specified, the specialised read-routine
+             * e.g. if `GPU_FETCH_INT_TO_FLOAT` is specified, the specialized read-routine
              * in the shader will read the data as an int, and cast this to floating point
              * representation. (Rather than reading the source data as float).
              *
@@ -403,7 +404,7 @@ id<MTLRenderCommandEncoder> MTLBatch::bind(uint v_first, uint v_count, uint i_fi
   active_shader_ = (shader) ? static_cast<MTLShader *>(unwrap(shader)) : nullptr;
 
   if (active_shader_ == nullptr || !active_shader_->is_valid()) {
-    /* Skip drawing if there is no vaid Metal shader.
+    /* Skip drawing if there is no valid Metal shader.
      * This will occur if the path through which the shader is prepared
      * is invalid (e.g. Python without create-info), or, the source shader uses a geometry pass. */
     BLI_assert_msg(false, "No valid Metal shader!");
@@ -455,7 +456,7 @@ id<MTLRenderCommandEncoder> MTLBatch::bind(uint v_first, uint v_count, uint i_fi
   /* Fetch RenderPassState to enable resource binding for active pass. */
   MTLRenderPassState &rps = ctx->main_command_buffer.get_render_pass_state();
 
-  /* Debug Check: Ensure Framebuffer instance is not dirty. */
+  /* Debug Check: Ensure Frame-buffer instance is not dirty. */
   BLI_assert(!ctx->main_command_buffer.get_active_framebuffer()->get_dirty());
 
   /* Bind Shader. */
@@ -495,8 +496,8 @@ id<MTLRenderCommandEncoder> MTLBatch::bind(uint v_first, uint v_count, uint i_fi
 
     if (mtl_elem != nullptr) {
 
-      /* Fetch index buffer. This function can situationally return an optimised
-       * index buffer of a different primtiive type. If this is the case, `final_prim_type`
+      /* Fetch index buffer. This function can situationally return an optimized
+       * index buffer of a different primitive type. If this is the case, `final_prim_type`
        * and `v_count` will be updated with the new format.
        * NOTE: For indexed rendering, v_count represents the number of indices. */
       idx_buffer = mtl_elem->get_index_buffer(final_prim_type, v_count);
@@ -594,8 +595,10 @@ void MTLBatch::prepare_vertex_descriptor_and_bindings(
   desc.reset_vertex_descriptor();
 
   /* Fetch Vertex and Instance Buffers. */
-  Span<MTLVertBuf *> mtl_verts(reinterpret_cast<MTLVertBuf **>(this->verts), GPU_BATCH_VBO_MAX_LEN);
-  Span<MTLVertBuf *> mtl_inst(reinterpret_cast<MTLVertBuf **>(this->inst), GPU_BATCH_INST_VBO_MAX_LEN);
+  Span<MTLVertBuf *> mtl_verts(reinterpret_cast<MTLVertBuf **>(this->verts),
+                               GPU_BATCH_VBO_MAX_LEN);
+  Span<MTLVertBuf *> mtl_inst(reinterpret_cast<MTLVertBuf **>(this->inst),
+                              GPU_BATCH_INST_VBO_MAX_LEN);
 
   /* SSBO Vertex fetch also passes vertex descriptor information into the shader. */
   if (active_shader_->get_uses_ssbo_vertex_fetch()) {
@@ -671,7 +674,7 @@ void MTLBatch::prepare_vertex_descriptor_and_bindings(
       }
     }
 
-    /* Extract Vertex attribues (First-bound vertex buffer takes priority). */
+    /* Extract Vertex attributes (First-bound vertex buffer takes priority). */
     for (int v = 0; v < GPU_BATCH_VBO_MAX_LEN; v++) {
       if (mtl_verts[v] != NULL) {
         MTL_LOG_INFO(" -- [Batch] Checking bindings for bound vertex buffer %p\n", mtl_verts[v]);
@@ -829,7 +832,7 @@ void MTLBatch::draw_advanced(int v_first, int v_count, int i_first, int i_count)
                    "Index offset is not 2/4-byte aligned as per METAL spec");
 
     /* Fetch index buffer. May return an index buffer of a differing format,
-     * if index buffer optimisation is used. In these cases, final_prim_type and
+     * if index buffer optimization is used. In these cases, final_prim_type and
      * index_count get updated with the new properties. */
     GPUPrimType final_prim_type = this->prim_type;
     uint index_count = v_count;
diff --git a/source/blender/gpu/metal/mtl_drawlist.mm b/source/blender/gpu/metal/mtl_drawlist.mm
index 76e2abb4ea6..99194d2b72c 100644
--- a/source/blender/gpu/metal/mtl_drawlist.mm
+++ b/source/blender/gpu/metal/mtl_drawlist.mm
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
 /** \file
  * \ingroup gpu
  *
@@ -151,7 +153,7 @@ void MTLDrawList::submit()
 {
   /* Metal does not support MDI from the host side, but we still benefit from only executing the
    * batch bind a single time, rather than per-draw.
-   * NOTE(Metal): Consider using MTLIndirectCommandBuffer to achieve similar behaviour. */
+   * NOTE(Metal): Consider using #MTLIndirectCommandBuffer to achieve similar behavior. */
   if (command_len_ == 0) {
     return;
   }
@@ -192,12 +194,12 @@ void MTLDrawList::submit()
   /* Common properties. */
   MTLPrimitiveType mtl_prim_type = gpu_prim_type_to_metal(batch_->prim_type);
 
-  /* Execute multidraw indirect. */
+  /* Execute multi-draw indirect. */
   if (can_use_MDI && false) {
     /* Metal Doesn't support MDI -- Singular Indirect draw calls are supported,
-     * but Multidraw is not.
-     * TODO(Metal): Consider using IndirectCommandBuffers to provide similar
-     * behaviour. */
+     * but Multi-draw is not.
+     * TODO(Metal): Consider using #IndirectCommandBuffers to provide similar
+     * behavior. */
   }
   else {
 
@@ -214,7 +216,7 @@ void MTLDrawList::submit()
       uint32_t index_count = cmd->indexCount;
 
       /* Fetch index buffer. May return an index buffer of a differing format,
-       * if index buffer optimisation is used. In these cases, mtl_prim_type and
+       * if index buffer optimization is used. In these cases, mtl_prim_type and
        * index_count get updated with the new properties. */
       GPUPrimType final_prim_type = batch_->prim_type;
       id<MTLBuffer> index_buffer = mtl_elem->get_index_buffer(final_prim_type, index_count);
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.mm b/source/blender/gpu/metal/mtl_texture.mm
index 4931f8a4f52..29dcc8d32ee 100644
--- a/source/blender/gpu/metal/mtl_texture.mm
+++ b/source/blender/gpu/metal/mtl_texture.mm
@@ -1510,7 +1510,7 @@ bool gpu::MTLTexture::init_internal(GPUVertBuf *vbo)
   texture_descriptor_.mipmapLevelCount = mtl_max_mips_;
   texture_descriptor_.usage =
       MTLTextureUsageShaderRead | MTLTextureUsageShaderWrite |
-      MTLTextureUsagePixelFormatView; /* TODO(Metal): Optimise usage flags. */
+      MTLTextureUsagePixelFormatView; /* TODO(Metal): Optimize usage flags. */
   texture_descriptor_.storageMode = [source_buffer storageMode];
   texture_descriptor_.sampleCount = 1;
   texture_descriptor_.cpuCacheMode = [source_buffer cpuCacheMode];
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/opengl/gl_batch.cc b/source/blender/gpu/opengl/gl_batch.cc
index ff8867fe3e6..28105e326ee 100644
--- a/source/blender/gpu/opengl/gl_batch.cc
+++ b/source/blender/gpu/opengl/gl_batch.cc
@@ -272,8 +272,8 @@ void GLBatch::bind(int i_first)
 
 #if GPU_TRACK_INDEX_RANGE
   /* Can be removed if GL 4.3 is required. */
-  if (!GLContext::fixed_restart_index_support && (elem != nullptr)) {
-    glPrimitiveRestartIndex(this->elem_()->restart_index());
+  if (!GLContext::fixed_restart_index_support) {
+    glPrimitiveRestartIndex((elem != nullptr) ? this->elem_()->restart_index() : 0xFFFFFFFFu);
   }
 #endif
 
diff --git a/source/blender/gpu/opengl/gl_shader_interface.cc b/source/blender/gpu/opengl/gl_shader_interface.cc
index c9432fca561..ef97d74bf81 100644
--- a/source/blender/gpu/opengl/gl_shader_interface.cc
+++ b/source/blender/gpu/opengl/gl_shader_interface.cc
@@ -200,6 +200,9 @@ static Type gpu_type_from_gl_type(int gl_type)
 
 GLShaderInterface::GLShaderInterface(GLuint program)
 {
+  GLuint last_program;
+  glGetIntegerv(GL_CURRENT_PROGRAM, (GLint *)&last_program);
+
   /* Necessary to make #glUniform works. */
   glUseProgram(program);
 
@@ -385,6 +388,8 @@ GLShaderInterface::GLShaderInterface(GLuint program)
   // this->debug_print();
 
   this->sort_inputs();
+
+  glUseProgram(last_program);
 }
 
 GLShaderInterface::GLShaderInterface(GLuint program, const shader::ShaderCreateInfo &info)
@@ -442,6 +447,9 @@ GLShaderInterface::GLShaderInterface(GLuint program, const shader::ShaderCreateI
   uint32_t name_buffer_offset = 0;
 
   /* Necessary to make #glUniform works. TODO(fclem) Remove. */
+  GLuint last_program;
+  glGetIntegerv(GL_CURRENT_PROGRAM, (GLint *)&last_program);
+
   glUseProgram(program);
 
   /* Attributes */
@@ -552,6 +560,8 @@ GLShaderInterface::GLShaderInterface(GLuint program, const shader::ShaderCreateI
   this->sort_inputs();
 
   // this->debug_print();
+
+  glUseProgram(last_program);
 }
 
 GLShaderInterface::~GLShaderInterface()
diff --git a/source/blender/gpu/shaders/compositor/compositor_blur.glsl b/source/blender/gpu/shaders/compositor/compositor_blur.glsl
index 4f981c84f59..c7ac620f99b 100644
--- a/source/blender/gpu/shaders/compositor/compositor_blur.glsl
+++ b/source/blender/gpu/shaders/compositor/compositor_blur.glsl
@@ -18,13 +18,24 @@ vec4 load_input(ivec2 texel)
 }
 
 /* Given the texel in the range [-radius, radius] in both axis, load the appropriate weight from
- * the weights texture, where the texel (0, 0) is considered the center of weights texture. */
+ * 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], 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, also add 0.5 to sample at the center of the pixels. */
-  return texture(weights_tx, (texel + vec2(radius + 0.5)) / (radius * 2 + 1));
+  /* 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()
diff --git a/source/blender/gpu/shaders/compositor/compositor_blur_variable_size.glsl b/source/blender/gpu/shaders/compositor/compositor_blur_variable_size.glsl
index e7e5aac12a5..9383bbf9825 100644
--- a/source/blender/gpu/shaders/compositor/compositor_blur_variable_size.glsl
+++ b/source/blender/gpu/shaders/compositor/compositor_blur_variable_size.glsl
@@ -2,7 +2,16 @@
 #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 texel (0, 0) is considered the center of weights texture. */
+ * 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
@@ -12,10 +21,12 @@ vec4 load_weight(ivec2 texel, float radius)
     return vec4(1.0);
   }
 
-  /* Add the radius to transform the texel into the range [0, radius * 2], 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, also add 0.5 to sample at the center of the pixels. */
-  return texture(weights_tx, (texel + vec2(radius + 0.5)) / (radius * 2 + 1));
+  /* 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()
diff --git a/source/blender/gpu/shaders/compositor/compositor_normalize.glsl b/source/blender/gpu/shaders/compositor/compositor_normalize.glsl
new file mode 100644
index 00000000000..53dfeb01730
--- /dev/null
+++ b/source/blender/gpu/shaders/compositor/compositor_normalize.glsl
@@ -0,0 +1,10 @@
+#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
+
+void main()
+{
+  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
+  float value = texture_load(input_tx, texel).x;
+  float normalized_value = (value - minimum) * scale;
+  float clamped_value = clamp(normalized_value, 0.0, 1.0);
+  imageStore(output_img, texel, vec4(clamped_value));
+}
diff --git a/source/blender/gpu/shaders/compositor/compositor_tone_map_photoreceptor.glsl b/source/blender/gpu/shaders/compositor/compositor_tone_map_photoreceptor.glsl
new file mode 100644
index 00000000000..167006585ca
--- /dev/null
+++ b/source/blender/gpu/shaders/compositor/compositor_tone_map_photoreceptor.glsl
@@ -0,0 +1,22 @@
+#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
+
+/* Tone mapping based on equation (1) and the trilinear interpolation between equations (6) and (7)
+ * from Reinhard, Erik, and Kate Devlin. "Dynamic range reduction inspired by photoreceptor
+ * physiology." IEEE transactions on visualization and computer graphics 11.1 (2005): 13-24. */
+void main()
+{
+  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
+
+  vec4 input_color = texture_load(input_tx, texel);
+  float input_luminance = dot(input_color.rgb, luminance_coefficients);
+
+  /* Trilinear interpolation between equations (6) and (7) from Reinhard's 2005 paper. */
+  vec4 local_adaptation_level = mix(vec4(input_luminance), input_color, chromatic_adaptation);
+  vec4 adaptation_level = mix(global_adaptation_level, local_adaptation_level, light_adaptation);
+
+  /* Equation (1) from Reinhard's 2005 paper, assuming Vmax is 1. */
+  vec4 semi_saturation = pow(intensity * adaptation_level, vec4(contrast));
+  vec4 tone_mapped_color = input_color / (input_color + semi_saturation);
+
+  imageStore(output_img, texel, vec4(tone_mapped_color.rgb, input_color.a));
+}
diff --git a/source/blender/gpu/shaders/compositor/compositor_tone_map_simple.glsl b/source/blender/gpu/shaders/compositor/compositor_tone_map_simple.glsl
new file mode 100644
index 00000000000..ce42d021dd1
--- /dev/null
+++ b/source/blender/gpu/shaders/compositor/compositor_tone_map_simple.glsl
@@ -0,0 +1,26 @@
+#pragma BLENDER_REQUIRE(gpu_shader_compositor_texture_utilities.glsl)
+#pragma BLENDER_REQUIRE(gpu_shader_common_math_utils.glsl)
+
+/* Tone mapping based on equation (3) from Reinhard, Erik, et al. "Photographic tone reproduction
+ * for digital images." Proceedings of the 29th annual conference on Computer graphics and
+ * interactive techniques. 2002. */
+void main()
+{
+  ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
+
+  vec4 input_color = texture_load(input_tx, texel);
+
+  /* Equation (2) from Reinhard's 2002 paper. */
+  vec4 scaled_color = input_color * luminance_scale;
+
+  /* Equation (3) from Reinhard's 2002 paper, but with the 1 replaced with the blend factor for
+   * more flexibility. See ToneMapOperation::compute_luminance_scale_blend_factor. */
+  vec4 denominator = luminance_scale_blend_factor + scaled_color;
+  vec4 tone_mapped_color = safe_divide(scaled_color, denominator);
+
+  if (inverse_gamma != 0.0) {
+    tone_mapped_color = pow(max(tone_mapped_color, vec4(0.0)), vec4(inverse_gamma));
+  }
+
+  imageStore(output_img, texel, vec4(tone_mapped_color.rgb, input_color.a));
+}
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_normalize_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_normalize_info.hh
new file mode 100644
index 00000000000..02fdc424014
--- /dev/null
+++ b/source/blender/gpu/shaders/compositor/infos/compositor_normalize_info.hh
@@ -0,0 +1,12 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_CREATE_INFO(compositor_normalize)
+    .local_group_size(16, 16)
+    .push_constant(Type::FLOAT, "minimum")
+    .push_constant(Type::FLOAT, "scale")
+    .sampler(0, ImageType::FLOAT_2D, "input_tx")
+    .image(0, GPU_R16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
+    .compute_source("compositor_normalize.glsl")
+    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_parallel_reduction_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_parallel_reduction_info.hh
index 2e661f280af..e2252b14758 100644
--- a/source/blender/gpu/shaders/compositor/infos/compositor_parallel_reduction_info.hh
+++ b/source/blender/gpu/shaders/compositor/infos/compositor_parallel_reduction_info.hh
@@ -12,14 +12,17 @@ GPU_SHADER_CREATE_INFO(compositor_parallel_reduction_shared)
  * Sum Reductions.
  */
 
-GPU_SHADER_CREATE_INFO(compositor_sum_float_shared)
+GPU_SHADER_CREATE_INFO(compositor_sum_shared)
     .additional_info("compositor_parallel_reduction_shared")
-    .image(0, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
-    .define("TYPE", "float")
     .define("IDENTITY", "vec4(0.0)")
-    .define("LOAD(value)", "value.x")
     .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")
@@ -41,6 +44,20 @@ GPU_SHADER_CREATE_INFO(compositor_sum_luminance)
     .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.
  */
@@ -74,3 +91,59 @@ GPU_SHADER_CREATE_INFO(compositor_sum_luminance_squared_difference)
     .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_tone_map_photoreceptor_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_photoreceptor_info.hh
new file mode 100644
index 00000000000..a460c9d58a6
--- /dev/null
+++ b/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_photoreceptor_info.hh
@@ -0,0 +1,16 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_CREATE_INFO(compositor_tone_map_photoreceptor)
+    .local_group_size(16, 16)
+    .push_constant(Type::VEC4, "global_adaptation_level")
+    .push_constant(Type::FLOAT, "contrast")
+    .push_constant(Type::FLOAT, "intensity")
+    .push_constant(Type::FLOAT, "chromatic_adaptation")
+    .push_constant(Type::FLOAT, "light_adaptation")
+    .push_constant(Type::VEC3, "luminance_coefficients")
+    .sampler(0, ImageType::FLOAT_2D, "input_tx")
+    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
+    .compute_source("compositor_tone_map_photoreceptor.glsl")
+    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_simple_info.hh b/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_simple_info.hh
new file mode 100644
index 00000000000..2b220af9460
--- /dev/null
+++ b/source/blender/gpu/shaders/compositor/infos/compositor_tone_map_simple_info.hh
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_CREATE_INFO(compositor_tone_map_simple)
+    .local_group_size(16, 16)
+    .push_constant(Type::FLOAT, "luminance_scale")
+    .push_constant(Type::FLOAT, "luminance_scale_blend_factor")
+    .push_constant(Type::FLOAT, "inverse_gamma")
+    .sampler(0, ImageType::FLOAT_2D, "input_tx")
+    .image(0, GPU_RGBA16F, Qualifier::WRITE, ImageType::FLOAT_2D, "output_img")
+    .compute_source("compositor_tone_map_simple.glsl")
+    .do_static_compilation(true);
diff --git a/source/blender/gpu/shaders/gpu_shader_icon_frag.glsl b/source/blender/gpu/shaders/gpu_shader_icon_frag.glsl
new file mode 100644
index 00000000000..4452349f23c
--- /dev/null
+++ b/source/blender/gpu/shaders/gpu_shader_icon_frag.glsl
@@ -0,0 +1,42 @@
+/**
+ * Draw the icons, leaving a semi-transparent rectangle on top of the icon.
+ *
+ * The top-left corner of the rectangle is rounded and drawned with anti-alias.
+ * The anti-alias is done by transitioning from the outer to the inner radius of
+ * the rounded corner, and the rectangle sides.
+ */
+
+void main()
+{
+  /* Top-left rounded corner parameters. */
+  const float circle_radius_outer = 0.1;
+  const float circle_radius_inner = 0.075;
+
+  /**
+   * Add a bit transparency to see a bit of the icon, without
+   * getting on the way of readability. */
+  const float mask_transparency = 0.25;
+
+  vec2 circle_center = vec2(circle_radius_outer - text_width, 0.5);
+  fragColor = texture(image, texCoord_interp) * color;
+
+  /* radius in icon space (1 is the icon width).  */
+  float radius = length(mask_coord_interp - circle_center);
+  float mask = smoothstep(circle_radius_inner, circle_radius_outer, radius);
+
+  bool lower_half = mask_coord_interp.y < circle_center.y;
+  bool right_half = mask_coord_interp.x > circle_center.x;
+
+  if (right_half && mask_coord_interp.y < circle_center.y + circle_radius_outer) {
+    mask = smoothstep(circle_center.y + circle_radius_inner,
+                      circle_center.y + circle_radius_outer,
+                      mask_coord_interp.y);
+  }
+  if (lower_half && mask_coord_interp.x > circle_center.x - circle_radius_outer) {
+    mask = smoothstep(circle_center.x - circle_radius_inner,
+                      circle_center.x - circle_radius_outer,
+                      mask_coord_interp.x);
+  }
+
+  fragColor = mix(vec4(0.0), fragColor, max(mask_transparency, mask));
+}
diff --git a/source/blender/gpu/shaders/gpu_shader_icon_vert.glsl b/source/blender/gpu/shaders/gpu_shader_icon_vert.glsl
new file mode 100644
index 00000000000..25f64bfe0b6
--- /dev/null
+++ b/source/blender/gpu/shaders/gpu_shader_icon_vert.glsl
@@ -0,0 +1,37 @@
+/**
+ * Simple shader that just draw one icon at the specified location
+ * does not need any vertex input (producing less call to immBegin/End)
+ */
+
+void main()
+{
+  vec2 uv;
+  vec2 co;
+
+  if (gl_VertexID == 0) {
+    co = rect_geom.xw;
+    uv = rect_icon.xw;
+    mask_coord_interp = vec2(0, 1);
+  }
+  else if (gl_VertexID == 1) {
+    co = rect_geom.xy;
+    uv = rect_icon.xy;
+    mask_coord_interp = vec2(0, 0);
+  }
+  else if (gl_VertexID == 2) {
+    co = rect_geom.zw;
+    uv = rect_icon.zw;
+    mask_coord_interp = vec2(1, 1);
+  }
+  else {
+    co = rect_geom.zy;
+    uv = rect_icon.zy;
+    mask_coord_interp = vec2(1, 0);
+  }
+
+  /* Put origin in lower right corner. */
+  mask_coord_interp.x -= 1;
+
+  gl_Position = ModelViewProjectionMatrix * vec4(co, 0.0f, 1.0f);
+  texCoord_interp = uv;
+}
diff --git a/source/blender/gpu/shaders/infos/gpu_interface_info.hh b/source/blender/gpu/shaders/infos/gpu_interface_info.hh
index d77c65e48a7..060def16f81 100644
--- a/source/blender/gpu/shaders/infos/gpu_interface_info.hh
+++ b/source/blender/gpu/shaders/infos/gpu_interface_info.hh
@@ -18,3 +18,6 @@ GPU_SHADER_INTERFACE_INFO(smooth_radii_outline_iface, "").smooth(Type::VEC4, "ra
 GPU_SHADER_INTERFACE_INFO(flat_color_smooth_tex_coord_interp_iface, "")
     .flat(Type::VEC4, "finalColor")
     .smooth(Type::VEC2, "texCoord_interp");
+GPU_SHADER_INTERFACE_INFO(smooth_icon_interp_iface, "")
+    .smooth(Type::VEC2, "texCoord_interp")
+    .smooth(Type::VEC2, "mask_coord_interp");
diff --git a/source/blender/gpu/shaders/infos/gpu_shader_icon_info.hh b/source/blender/gpu/shaders/infos/gpu_shader_icon_info.hh
new file mode 100644
index 00000000000..3d4077bdb09
--- /dev/null
+++ b/source/blender/gpu/shaders/infos/gpu_shader_icon_info.hh
@@ -0,0 +1,22 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later
+ * Copyright 2022 Blender Foundation. All rights reserved. */
+
+/** \file
+ * \ingroup gpu
+ */
+
+#include "gpu_interface_info.hh"
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_CREATE_INFO(gpu_shader_icon)
+    .vertex_out(smooth_icon_interp_iface)
+    .fragment_out(0, Type::VEC4, "fragColor")
+    .push_constant(Type::MAT4, "ModelViewProjectionMatrix")
+    .push_constant(Type::VEC4, "color")
+    .push_constant(Type::VEC4, "rect_icon")
+    .push_constant(Type::VEC4, "rect_geom")
+    .push_constant(Type::FLOAT, "text_width")
+    .sampler(0, ImageType::FLOAT_2D, "image")
+    .vertex_source("gpu_shader_icon_vert.glsl")
+    .fragment_source("gpu_shader_icon_frag.glsl")
+    .do_static_compilation(true);
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