Add Chromium-only Blender WebEngine parity work

blender-5.2.0/source/blender/gpu/metal/kernels/compute_texture_read.msl

@@ -0,0 +1,216 @@
+/* SPDX-FileCopyrightText: 2022 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/* MATCHING GPUTextureType. */
+#define GPU_TEXTURE_1D (1 << 0)
+#define GPU_TEXTURE_2D (1 << 1)
+#define GPU_TEXTURE_3D (1 << 2)
+#define GPU_TEXTURE_CUBE (1 << 3)
+#define GPU_TEXTURE_ARRAY (1 << 4)
+#define GPU_TEXTURE_BUFFER (1 << 5)
+#define GPU_TEXTURE_1D_ARRAY (GPU_TEXTURE_1D | GPU_TEXTURE_ARRAY)
+#define GPU_TEXTURE_2D_ARRAY (GPU_TEXTURE_2D | GPU_TEXTURE_ARRAY)
+#define GPU_TEXTURE_CUBE_ARRAY (GPU_TEXTURE_CUBE | GPU_TEXTURE_ARRAY)
+
+/* Determine input texture type. */
+#if IS_DEPTH_FORMAT == 1
+#  define TEX_NAME_BASE depth
+#else
+#  define TEX_NAME_BASE texture
+#endif
+
+#define JOIN(x, y) x##y
+#define FUNC_NAME(x, y) JOIN(x, y)
+
+/* Assign parameters based on texture type. */
+#if TEX_TYPE == GPU_TEXTURE_1D
+#  define TEX_TYPE_NAME FUNC_NAME(TEX_NAME_BASE, 1d)
+#  define DIMS 1
+#elif TEX_TYPE == GPU_TEXTURE_2D
+#  define TEX_TYPE_NAME FUNC_NAME(TEX_NAME_BASE, 2d)
+#  define DIMS 2
+#elif TEX_TYPE == GPU_TEXTURE_3D
+#  define TEX_TYPE_NAME FUNC_NAME(TEX_NAME_BASE, 3d)
+#  define DIMS 3
+#elif TEX_TYPE == GPU_TEXTURE_1D_ARRAY
+#  define TEX_TYPE_NAME FUNC_NAME(TEX_NAME_BASE, 1d_array)
+#  define DIMS 2
+#elif TEX_TYPE == GPU_TEXTURE_2D_ARRAY
+#  define TEX_TYPE_NAME FUNC_NAME(TEX_NAME_BASE, 2d_array)
+#  define DIMS 3
+#endif
+
+/* Position dimensionality for thread-group. */
+#if DIMS == 1
+#  define POSITION_TYPE uint
+#elif DIMS == 2
+#  define POSITION_TYPE uint2
+#elif DIMS == 3
+#  define POSITION_TYPE uint3
+#endif
+
+using namespace metal;
+
+template<typename T> T denormalize(float val)
+{
+  return T(float(DEPTH_SCALE_FACTOR) * val);
+};
+
+template<> int denormalize<int>(float val)
+{
+  return int((float(DEPTH_SCALE_FACTOR) * val - 1.0f) / 2.0f);
+}
+template<> uint denormalize<uint>(float val)
+{
+  return uint(float(DEPTH_SCALE_FACTOR) * val);
+}
+
+/* `float` to other type case. */
+template<typename T> T convert_type(float type)
+{
+  return T(type);
+}
+
+/* `uint` to other types. */
+template<typename T> T convert_type(uint type)
+{
+  return T(type);
+}
+
+/* `int` to other types. */
+template<typename T> T convert_type(int type)
+{
+  return T(type);
+}
+
+template<> uchar convert_type<uchar>(float val)
+{
+  return uchar(val * float(0xFF));
+}
+
+template<> uint convert_type<uint>(float val)
+{
+  return uint(val * float(0xFFFFFFFFu));
+}
+
+template<typename D, typename S> uint pack_depth_stencil(D depth, S stencil)
+{
+  return (((uint(depth)) << 8) & (~(0xFFu - 1))) | (uint(stencil) & (0xFFu - 1));
+}
+
+struct TextureReadParams {
+  int mip_index;
+  int extent[3];
+  int offset[3];
+};
+
+#if IS_DEPTH_FORMAT == 1
+constexpr sampler pixelSampler = sampler(coord::pixel, address::clamp_to_edge, filter::nearest);
+#endif
+
+kernel void compute_texture_read(constant TextureReadParams &params [[buffer(0)]],
+                                 device OUTPUT_DATA_TYPE *output_data [[buffer(1)]],
+#if IS_DEPTH_FORMAT == 1
+                                 TEX_TYPE_NAME<float, access::sample> read_tex [[texture(0)]],
+#else
+                                 TEX_TYPE_NAME<INPUT_DATA_TYPE, access::read> read_tex
+                                 [[texture(0)]],
+#endif
+                                 POSITION_TYPE position [[thread_position_in_grid]])
+{
+  /* Read colour. */
+  vec<INPUT_DATA_TYPE, 4> read_colour;
+
+/* 1D TEXTURE */
+#if TEX_TYPE == GPU_TEXTURE_1D
+
+  /* xx, yy, layer determined by kernel invocation pattern */
+  uint xx = position[0];
+  int index = (xx)*COMPONENT_COUNT_OUTPUT;
+  read_colour = read_tex.read(uint(params.offset[0]) + uint(xx));
+
+/* 2D TEXTURE */
+#elif TEX_TYPE == GPU_TEXTURE_2D
+
+  /* xx, yy, layer determined by kernel invocation pattern */
+  uint xx = position[0];
+  uint yy = position[1];
+  int index = (yy * params.extent[0] + xx) * COMPONENT_COUNT_OUTPUT;
+
+  /* Read data */
+#  if IS_DEPTH_FORMAT == 1
+  OUTPUT_DATA_TYPE value = denormalize<OUTPUT_DATA_TYPE>(
+      read_tex.sample(pixelSampler, float2(params.offset[0], params.offset[1]) + float2(xx, yy)));
+#    if IS_DEPTHSTENCIL_24_8 == 1
+  /* Shift depth value into 24 bit region and mask out 8 bit stencil.
+   * NOTE: Stencil currently not read as no use cases exist for this. */
+  value = pack_depth_stencil(value, 0);
+#    endif
+  output_data[index] = value;
+#  else
+  read_colour = read_tex.read(uint2(params.offset[0], params.offset[1]) + uint2(xx, yy));
+#  endif
+
+/* 3D TEXTURE */
+#elif TEX_TYPE == GPU_TEXTURE_3D
+  /* xx, yy, layer determined by kernel invocation pattern */
+  uint xx = position[0];
+  uint yy = position[1];
+  uint zz = position[2];
+  int index = (zz * (params.extent[0] * params.extent[1]) + yy * params.extent[0] + xx) *
+              COMPONENT_COUNT_OUTPUT;
+  read_colour = read_tex.read(uint3(params.offset[0], params.offset[1], params.offset[2]) +
+                              uint3(xx, yy, zz));
+
+/* 1D ARRAY TEXTURE */
+#elif TEX_TYPE == GPU_TEXTURE_1D_ARRAY
+
+  /* xx, yy, layer determined by kernel invocation pattern */
+  uint xx = position[0];
+  uint layer = position[1];
+  int index = (layer * params.extent[0] + xx) * COMPONENT_COUNT_OUTPUT;
+  read_colour = read_tex.read(uint(params.offset[0]) + uint(xx), uint(params.offset[1]) + layer);
+
+/* 2D ARRAY TEXTURE */
+#elif TEX_TYPE == GPU_TEXTURE_2D_ARRAY
+
+  /* xx, yy, layer determined by kernel invocation pattern */
+  uint xx = position[0];
+  uint yy = position[1];
+  uint layer = position[2];
+  int index = (layer * (params.extent[0] * params.extent[1]) + yy * params.extent[0] + xx) *
+              COMPONENT_COUNT_OUTPUT;
+
+  /* Read data */
+#  if IS_DEPTH_FORMAT == 1
+  OUTPUT_DATA_TYPE value = denormalize<OUTPUT_DATA_TYPE>(
+      read_tex.sample(pixelSampler,
+                      float2(params.offset[0], params.offset[1]) + float2(xx, yy),
+                      uint(params.offset[2] + layer)));
+#    if IS_DEPTHSTENCIL_24_8 == 1
+  /* Shift depth value into 24 bit region and mask out 8 bit stencil.
+   * NOTE: Stencil currently not read as no use cases exist for this. */
+  value = pack_depth_stencil(value, 0);
+#    endif
+  output_data[index] = value;
+#  else
+  read_colour = read_tex.read(uint2(params.offset[0], params.offset[1]) + uint2(xx, yy),
+                              uint(params.offset[2] + layer));
+#  endif
+
+#endif
+
+  /* Output per-component colour data. */
+#if IS_DEPTH_FORMAT != 1
+  /* Write data to block */
+  for (int i = 0; i < WRITE_COMPONENT_COUNT; i++) {
+    output_data[index + i] = convert_type<OUTPUT_DATA_TYPE>(read_colour[i]);
+  }
+
+  /* Fill in empty cells if more components are being read than exist */
+  for (int i = COMPONENT_COUNT_INPUT; i < COMPONENT_COUNT_OUTPUT; i++) {
+    output_data[index + i] = convert_type<OUTPUT_DATA_TYPE>(0);
+  }
+#endif
+}

blender-5.2.0/source/blender/gpu/metal/kernels/compute_texture_update.msl

@@ -0,0 +1,163 @@
+/* SPDX-FileCopyrightText: 2022 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+using namespace metal;
+
+/* MATCHING GPUTextureType. */
+#define GPU_TEXTURE_1D (1 << 0)
+#define GPU_TEXTURE_2D (1 << 1)
+#define GPU_TEXTURE_3D (1 << 2)
+#define GPU_TEXTURE_CUBE (1 << 3)
+#define GPU_TEXTURE_ARRAY (1 << 4)
+#define GPU_TEXTURE_BUFFER (1 << 5)
+#define GPU_TEXTURE_1D_ARRAY (GPU_TEXTURE_1D | GPU_TEXTURE_ARRAY)
+#define GPU_TEXTURE_2D_ARRAY (GPU_TEXTURE_2D | GPU_TEXTURE_ARRAY)
+#define GPU_TEXTURE_CUBE_ARRAY (GPU_TEXTURE_CUBE | GPU_TEXTURE_ARRAY)
+
+/* Assign parameters based on texture type. */
+#if TEX_TYPE == GPU_TEXTURE_1D
+#  define TEX_TYPE_NAME texture1d
+#  define DIMS 1
+#elif TEX_TYPE == GPU_TEXTURE_2D
+#  define TEX_TYPE_NAME texture2d
+#  define DIMS 2
+#elif TEX_TYPE == GPU_TEXTURE_3D
+#  define TEX_TYPE_NAME texture3d
+#  define DIMS 3
+#elif TEX_TYPE == GPU_TEXTURE_1D_ARRAY
+#  define TEX_TYPE_NAME texture1d_array
+#  define DIMS 2
+#elif TEX_TYPE == GPU_TEXTURE_2D_ARRAY
+#  define TEX_TYPE_NAME texture2d_array
+#  define DIMS 3
+#endif
+
+/* `base_offset` refers to the base read offset in bytes of the input data buffer.
+ * Component offset adds an additional offset to read components. When clearing a buffer
+ * and only one source color data element is provided, the base_offset is always zero.*/
+#if IS_TEXTURE_CLEAR == 1
+#  define READ_INPUT_DATA(base_offset, component_offset) (input_data[0 + component_offset])
+#else
+#  define READ_INPUT_DATA(base_offset, component_offset) \
+    (input_data[base_offset + component_offset])
+#endif
+
+/* Position dimensionality for thread-group. */
+#if DIMS == 1
+#  define POSITION_TYPE uint
+#elif DIMS == 2
+#  define POSITION_TYPE uint2
+#elif DIMS == 3
+#  define POSITION_TYPE uint3
+#endif
+
+struct TextureUpdateParams {
+  int mip_index;
+  int extent[3];
+  int offset[3];
+  uint unpack_row_length;
+};
+
+kernel void compute_texture_update(constant TextureUpdateParams &params [[buffer(0)]],
+                                   constant INPUT_DATA_TYPE *input_data [[buffer(1)]],
+                                   TEX_TYPE_NAME<OUTPUT_DATA_TYPE, access::write> update_tex
+                                   [[texture(0)]],
+                                   POSITION_TYPE position [[thread_position_in_grid]])
+{
+
+/* 1D TEXTURE */
+#if TEX_TYPE == GPU_TEXTURE_1D
+
+  /* xx, yy, layer determined by kernel invocation pattern */
+  uint xx = position;
+  int index = xx * COMPONENT_COUNT_INPUT;
+
+  vec<OUTPUT_DATA_TYPE, /*COMPONENT_COUNT_OUTPUT*/ 4> output;
+  for (int i = 0; i < COMPONENT_COUNT_INPUT; i++) {
+    output[i] = OUTPUT_DATA_TYPE(READ_INPUT_DATA(index, i));
+  }
+  for (int i = COMPONENT_COUNT_INPUT; i < COMPONENT_COUNT_OUTPUT; i++) {
+    output[i] = OUTPUT_DATA_TYPE(i == 3 ? 1 : 0);
+  }
+  update_tex.write(output, uint(params.offset[0]) + uint(xx));
+
+/* 2D TEXTURE */
+#elif TEX_TYPE == GPU_TEXTURE_2D
+
+  /* xx, yy, layer determined by kernel invocation pattern */
+  uint xx = position[0];
+  uint yy = position[1];
+  int index = (yy * params.unpack_row_length + xx) * COMPONENT_COUNT_INPUT;
+
+  vec<OUTPUT_DATA_TYPE, /*COMPONENT_COUNT_OUTPUT*/ 4> output;
+  for (int i = 0; i < COMPONENT_COUNT_INPUT; i++) {
+    output[i] = OUTPUT_DATA_TYPE(READ_INPUT_DATA(index, i));
+  }
+  for (int i = COMPONENT_COUNT_INPUT; i < COMPONENT_COUNT_OUTPUT; i++) {
+    output[i] = OUTPUT_DATA_TYPE(i == 3 ? 1 : 0);
+  }
+  update_tex.write(output, uint2(params.offset[0], params.offset[1]) + uint2(xx, yy));
+
+/* 3D TEXTURE */
+#elif TEX_TYPE == GPU_TEXTURE_3D
+
+  /* xx, yy, zz determined by kernel invocation pattern */
+  uint xx = position[0];
+  uint yy = position[1];
+  uint zz = position[2];
+  int index = (zz * (params.unpack_row_length * params.extent[1]) + yy * params.unpack_row_length +
+               xx) *
+              COMPONENT_COUNT_INPUT;
+
+  vec<OUTPUT_DATA_TYPE, /*COMPONENT_COUNT_OUTPUT*/ 4> output;
+  for (int i = 0; i < COMPONENT_COUNT_INPUT; i++) {
+    output[i] = OUTPUT_DATA_TYPE(READ_INPUT_DATA(index, i));
+  }
+  for (int i = COMPONENT_COUNT_INPUT; i < COMPONENT_COUNT_OUTPUT; i++) {
+    output[i] = OUTPUT_DATA_TYPE(i == 3 ? 1 : 0);
+  }
+  update_tex.write(
+      output, uint3(params.offset[0], params.offset[1], params.offset[2]) + uint3(xx, yy, zz));
+
+/* 1D ARRAY TEXTURE */
+#elif TEX_TYPE == GPU_TEXTURE_1D_ARRAY
+
+  /* xx, yy, layer determined by kernel invocation pattern */
+  uint xx = position[0];
+  uint layer = position[1];
+  int index = (layer * params.unpack_row_length + xx) * COMPONENT_COUNT_INPUT;
+
+  vec<OUTPUT_DATA_TYPE, /*COMPONENT_COUNT_OUTPUT*/ 4> output;
+  for (int i = 0; i < COMPONENT_COUNT_INPUT; i++) {
+    output[i] = OUTPUT_DATA_TYPE(READ_INPUT_DATA(index, i));
+  }
+  for (int i = COMPONENT_COUNT_INPUT; i < COMPONENT_COUNT_OUTPUT; i++) {
+    output[i] = OUTPUT_DATA_TYPE(i == 3 ? 1 : 0);
+  }
+  update_tex.write(
+      output, uint(params.offset[0]) + uint(xx), uint(params.offset[1]) + uint(layer));
+
+/* 2D ARRAY TEXTURE */
+#elif TEX_TYPE == GPU_TEXTURE_2D_ARRAY
+
+  /* xx, yy, layer determined by kernel invocation pattern */
+  uint xx = position[0];
+  uint yy = position[1];
+  uint layer = position[2];
+  int index = (layer * (params.unpack_row_length * params.extent[1]) +
+               yy * params.unpack_row_length + xx) *
+              COMPONENT_COUNT_INPUT;
+
+  vec<OUTPUT_DATA_TYPE, /*COMPONENT_COUNT_OUTPUT*/ 4> output;
+  for (int i = 0; i < COMPONENT_COUNT_INPUT; i++) {
+    output[i] = OUTPUT_DATA_TYPE(READ_INPUT_DATA(index, i));
+  }
+  for (int i = COMPONENT_COUNT_INPUT; i < COMPONENT_COUNT_OUTPUT; i++) {
+    output[i] = OUTPUT_DATA_TYPE(i == 3 ? 1 : 0);
+  }
+  update_tex.write(
+      output, uint2(params.offset[0], params.offset[1]) + uint2(xx, yy), params.offset[2] + layer);
+
+#endif
+}

blender-5.2.0/source/blender/gpu/metal/kernels/depth_2d_update_float_frag.glsl

@@ -0,0 +1,8 @@
+/* SPDX-FileCopyrightText: 2022 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+void main()
+{
+  gl_FragDepth = textureLod(source_data, texCoord_interp, mip).r;
+}

blender-5.2.0/source/blender/gpu/metal/kernels/depth_2d_update_infos.hh

@@ -0,0 +1,56 @@
+/* SPDX-FileCopyrightText: 2023 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup gpu
+ */
+
+#ifdef GPU_SHADER
+#  pragma once
+#endif
+
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_INTERFACE_INFO(depth_2d_update_iface)
+SMOOTH(float2, texCoord_interp)
+GPU_SHADER_INTERFACE_END()
+
+GPU_SHADER_CREATE_INFO(depth_2d_update_info_base)
+VERTEX_IN(0, float2, pos)
+VERTEX_OUT(depth_2d_update_iface)
+FRAGMENT_OUT(0, float4, fragColor)
+PUSH_CONSTANT(float2, extent)
+PUSH_CONSTANT(float2, offset)
+PUSH_CONSTANT(float2, size)
+PUSH_CONSTANT(int, mip)
+DEPTH_WRITE(DepthWrite::ANY)
+VERTEX_SOURCE("depth_2d_update_vert.glsl");
+GPU_SHADER_CREATE_END()
+
+GPU_SHADER_CREATE_INFO(depth_2d_update_float)
+METAL_BACKEND_ONLY()
+FRAGMENT_SOURCE("depth_2d_update_float_frag.glsl")
+SAMPLER(0, sampler2D, source_data)
+ADDITIONAL_INFO(depth_2d_update_info_base)
+DO_STATIC_COMPILATION()
+DEPTH_WRITE(DepthWrite::ANY);
+GPU_SHADER_CREATE_END()
+
+GPU_SHADER_CREATE_INFO(depth_2d_update_int24)
+METAL_BACKEND_ONLY()
+FRAGMENT_SOURCE("depth_2d_update_int24_frag.glsl")
+ADDITIONAL_INFO(depth_2d_update_info_base)
+SAMPLER(0, isampler2D, source_data)
+DO_STATIC_COMPILATION()
+DEPTH_WRITE(DepthWrite::ANY);
+GPU_SHADER_CREATE_END()
+
+GPU_SHADER_CREATE_INFO(depth_2d_update_int32)
+METAL_BACKEND_ONLY()
+FRAGMENT_SOURCE("depth_2d_update_int32_frag.glsl")
+ADDITIONAL_INFO(depth_2d_update_info_base)
+SAMPLER(0, isampler2D, source_data)
+DO_STATIC_COMPILATION()
+DEPTH_WRITE(DepthWrite::ANY);
+GPU_SHADER_CREATE_END()

blender-5.2.0/source/blender/gpu/metal/kernels/depth_2d_update_int24_frag.glsl

@@ -0,0 +1,11 @@
+/* SPDX-FileCopyrightText: 2022 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+void main()
+{
+  uint val = textureLod(source_data, texCoord_interp, mip).r;
+  uint stencil = (val >> 24) & 0xFFu;
+  uint depth = (val) & 0xFFFFFFu;
+  gl_FragDepth = float(depth) / float(0xFFFFFFu);
+}

blender-5.2.0/source/blender/gpu/metal/kernels/depth_2d_update_int32_frag.glsl

@@ -0,0 +1,10 @@
+/* SPDX-FileCopyrightText: 2022 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+void main()
+{
+  uint val = textureLod(source_data, texCoord_interp, mip).r;
+  uint depth = (val) & (0xFFFFFFFFu);
+  gl_FragDepth = float(depth) / float(0xFFFFFFFFu);
+}

blender-5.2.0/source/blender/gpu/metal/kernels/depth_2d_update_vert.glsl

@@ -0,0 +1,30 @@
+/* SPDX-FileCopyrightText: 2022 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+void main()
+{
+  float4 rect = float4(offset.x, offset.y, offset.x + extent.x, offset.y + extent.y);
+  rect /= float4(size, size);
+  float4 tex = rect;
+  rect = rect * 2.0f - 1.0f;
+
+  /* QUAD */
+  if (pos.x == 0.0f && pos.y == 0.0f) {
+    rect.xy = rect.xy;
+    texCoord_interp = tex.xy;
+  }
+  else if (pos.x == 0.0f && pos.y == 1.0f) {
+    rect.xy = rect.xw;
+    texCoord_interp = tex.xw;
+  }
+  else if (pos.x == 1.0f && pos.y == 1.0f) {
+    rect.xy = rect.zw;
+    texCoord_interp = tex.zw;
+  }
+  else {
+    rect.xy = rect.zy;
+    texCoord_interp = tex.zy;
+  }
+  gl_Position = float4(rect.xy, 0.0f, 1.0f);
+}

blender-5.2.0/source/blender/gpu/metal/kernels/gpu_shader_fullscreen_blit_frag.glsl

@@ -0,0 +1,9 @@
+/* SPDX-FileCopyrightText: 2022 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+void main()
+{
+  float4 tex_color = textureLod(imageTexture, screen_uv, mip);
+  fragColor = tex_color;
+}

blender-5.2.0/source/blender/gpu/metal/kernels/gpu_shader_fullscreen_blit_infos.hh

@@ -0,0 +1,30 @@
+/* SPDX-FileCopyrightText: 2023 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup gpu
+ */
+
+#pragma once
+
+#include "gpu_shader_create_info.hh"
+
+GPU_SHADER_INTERFACE_INFO(fullscreen_blit_iface)
+SMOOTH(float2, screen_uv)
+GPU_SHADER_INTERFACE_END()
+
+GPU_SHADER_CREATE_INFO(fullscreen_blit)
+VERTEX_IN(0, float2, pos)
+VERTEX_OUT(fullscreen_blit_iface)
+FRAGMENT_OUT(0, float4, fragColor)
+PUSH_CONSTANT(float2, fullscreen)
+PUSH_CONSTANT(float2, size)
+PUSH_CONSTANT(float2, dst_offset)
+PUSH_CONSTANT(float2, src_offset)
+PUSH_CONSTANT(int, mip)
+SAMPLER(0, sampler2D, imageTexture)
+VERTEX_SOURCE("gpu_shader_fullscreen_blit_vert.glsl")
+FRAGMENT_SOURCE("gpu_shader_fullscreen_blit_frag.glsl")
+DO_STATIC_COMPILATION();
+GPU_SHADER_CREATE_END()

blender-5.2.0/source/blender/gpu/metal/kernels/gpu_shader_fullscreen_blit_vert.glsl

@@ -0,0 +1,13 @@
+/* SPDX-FileCopyrightText: 2022 Blender Authors
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later */
+
+void main()
+{
+  /* The position represents a 0-1 square, we first scale it by the size we want to have it on
+   * screen next we divide by the full-screen size, this will bring everything in range [0,1].
+   * Next we scale to NDC range [-1,1]. */
+  gl_Position = float4((((pos * size + dst_offset) / fullscreen) * 2.0f - 1.0f), 1.0f, 1.0f);
+  float2 uvoff = (src_offset / fullscreen);
+  screen_uv = float2(pos + uvoff);
+}